Java spring任意消息tcp套接字

我正在使用spring集成开发一个定制的双向tcp套接字服务器

服务器将处理请求/响应任务，但我无法向特定连接Id发送任意消息

另外，我知道可能使用

TcpSendingMessageHandler

和

tcprevivingchanneladapter

是解决方案，但我找不到任何关于如何使用它的示例代码

这是我的密码：

public class SocketServer {

    private Logger logger = LoggerFactory.getLogger(SocketServer.class);

    @Bean
    public AbstractServerConnectionFactory connectionFactory() {
        return new TcpNetServerConnectionFactory(2025);
    }

    @Bean
    public TcpInboundGateway TcpInboundGateway(AbstractServerConnectionFactory connectionFactory) {
        TcpInboundGateway inGate = new TcpInboundGateway();
        inGate.setConnectionFactory(connectionFactory);
        inGate.setRequestChannelName("directChannel");
        return inGate;
    }

    @Bean
    public DirectChannel directChannel() {
        return new DirectChannel();
    }

    @MessageEndpoint
    public class Echo {

        @Transformer(inputChannel = "directChannel")
        public String process(byte[] input) throws Exception {
            return new String(input).toUpperCase();
        }

    }

    public boolean sendMessage(String connectionId){
           //TODO send Message
    }
}

---

给你-应该是不言自明的

@SpringBootApplication
public class So41760289Application {

    public static void main(String[] args) throws Exception {
        ConfigurableApplicationContext context = SpringApplication.run(So41760289Application.class, args);
        Socket socket = SocketFactory.getDefault().createSocket("localhost", 12345);

        // request/reply
        socket.getOutputStream().write("foo\r\n".getBytes());
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        System.out.println(reader.readLine());

        // arbitrary send
        @SuppressWarnings("unchecked")
        Set<String> connections = context.getBean(Set.class);
        for (String connection : connections) {
            context.getBean("bar", MessageChannel.class).send(
                    MessageBuilder.withPayload("foo")
                        .setHeader(IpHeaders.CONNECTION_ID, connection)
                        .build());
        }
        System.out.println(reader.readLine());
        reader.close();
        context.close();
    }

    @Bean
    public TcpNetServerConnectionFactory cf() {
        return new TcpNetServerConnectionFactory(12345);
    }

    @Bean
    public TcpReceivingChannelAdapter receiver() {
        TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
        adapter.setConnectionFactory(cf());
        adapter.setOutputChannelName("foo");
        return adapter;
    }

    @Transformer(inputChannel = "foo", outputChannel = "bar")
    public String process(byte[] in) {
        return new String(in).toUpperCase();
    }

    @Bean
    @ServiceActivator(inputChannel = "bar")
    public TcpSendingMessageHandler sender() {
        TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
        handler.setConnectionFactory(cf());
        return handler;
    }

    @Bean
    public Set<String> connections() {
        return Collections.synchronizedSet(new HashSet<>());
    }

    @Bean
    public ApplicationListener<TcpConnectionEvent> listener() {
        return new ApplicationListener<TcpConnectionEvent>() {

            @Override
            public void onApplicationEvent(TcpConnectionEvent event) {
                if (event instanceof TcpConnectionOpenEvent) {
                    connections().add(event.getConnectionId());
                }
                else if (event instanceof TcpConnectionCloseEvent) {
                    connections().remove(event.getConnectionId());
                }
            }

        };
    }

}

@springboot应用程序
公共类SO41760289应用程序{
公共静态void main（字符串[]args）引发异常{
ConfigurableApplicationContext上下文=SpringApplication.run（So41760289Application.class，args）；
Socket Socket=SocketFactory.getDefault（）.createSocket（“localhost”，12345）；
//请求/答复
socket.getOutputStream（）.write（“foo\r\n.getBytes（））；
BufferedReader=新的BufferedReader（新的InputStreamReader（socket.getInputStream（））；
System.out.println（reader.readLine（））；
//任意发送
@抑制警告（“未选中”）
Set connections=context.getBean（Set.class）；
for（字符串连接：连接）{
getBean（“bar”，MessageChannel.class）.send(
MessageBuilder.withPayload（“foo”）
.setHeader（IpHeaders.CONNECTION\u ID，CONNECTION）
.build（））；
}
System.out.println（reader.readLine（））；
reader.close（）；
context.close（）；
}
@豆子
公共TcpNetServerConnectionFactory cf（）{
返回新的TcpNetServerConnectionFactory（12345）；
}
@豆子
公共TCPrecevingChannelAdapter接收器（）{
TCPrecivingChannelAdapter=新的TCPrecivingChannelAdapter（）；
adapter.setConnectionFactory（cf（））；
adapter.setOutputChannelName（“foo”）；
返回适配器；
}
@变压器（inputChannel=“foo”，outputChannel=“bar”）
公共字符串进程（中的字节[]）{
返回新字符串（在.toUpperCase（）中）；
}
@豆子
@ServiceActivator（inputChannel=“bar”）
公共TcpSendingMessageHandler发送者（）{
TcpSendingMessageHandler=新的TcpSendingMessageHandler（）；
setConnectionFactory（cf（））；
返回处理程序；
}
@豆子
公共集连接（）{
返回Collections.synchronizedSet（newhashset（））；
}
@豆子
公共应用程序侦听器侦听器（）{
返回新的ApplicationListener（）{
@凌驾
ApplicationEvent上的公共无效（TcpConnectionEvent）{
if（TcpConnectionOpenEvent的事件实例）{
connections（）.add（event.getConnectionId（））；
}
else if（TcpConnectionCloseEvent的事件实例）{
连接（）.remove（event.getConnectionId（））；
}
}
};
}
}

您能否将请求/响应、任意消息客户端添加到您的响应中？您能否进一步解释？

main（）

方法就是这样做的。

名为'bar'的Bean应该是'org.springframework.messaging.MessageChannel'类型，但实际上是'org.springframework.integration.ip.tcp.TcpSendingMessageHandler'类型。

您应该问一个新问题，显示您的配置，而不是对旧的现有答案进行评论。看起来您有两个名为

bar

的bean定义，但我需要查看您的配置。