配置 TcpInboundGateway 以向同一消息发送多个响应

Question

I currently have a TcpInboundGateway that takes in messages, does some processing on the message and then returns the appropriate response, all as a TcpInboundGateway should.

However, I am curious if this TcpInboundGateway can be configured in such a way that it will send an immediate response to the originating request but continue to process the request and send the post-processing response as well?

Think of this immediate response as an acknowledgement to the sender that the message was received.

Possible Solution:

After reviewing this post , I came up with what I believe to be a viable solution to this problem.

@Configuration
@EnableIntegration
public class Configuration {

    @Bean
    public AbstractServerConnectionFactory serverConnectionFactory() {
        return new TcpNetServerConnectionFactory(2002);
    }

    @Bean
    public TcpReceivingChannelAdapter inboundAdapter(AbstractServerConnectionFactory serverConnectionFactory) {
        TcpReceivingChannelAdapter inboundAdapter = new TcpReceivingChannelAdapter();
        inboundAdapter.setConnectionFactory(serverConnectionFactory);
        inboundAdapter.setOutputChannelName("sendAcknowledgement");
        return inboundAdapter;
    }

    @MessageEndpoint
    public class InboundMessageHandler {

        @Autowired
        private OutboundMessageGateway gateway;

        @ServiceActivator(inputChannel="sendAcknowledgement", outputChannel="doProcessing")
        public Message<String> initialAck(Message<String> message) {
            gateway.send("ACK", message.getHeaders().get(IpHeaders.CONNECTION_ID).toString());
            return message;
        }

        @ServiceActivator(inputChannel="doProcessing", outputChannel="sendResponse")
        public Message<String> mockDelay(Message<String> message) throws InterruptedException {
            return message;
        }
    }

    @MessagingGateway(defaultRequestChannel="sendResponse")
    public interface OutboundMessageGateway {
        void send(@Payload String message, @Header(IpHeaders.CONNECTION_ID) String connectionId);
    }

    @Bean
    @ServiceActivator(inputChannel="sendResponse")
    public TcpSendingMessageHandler outboundAdapter(AbstractServerConnectionFactory serverConnectionFactory) {
        TcpSendingMessageHandler outboundAdapter = new TcpSendingMessageHandler();
        outboundAdapter.setConnectionFactory(serverConnectionFactory);
        return outboundAdapter;
    }

}

Answer 1

For the use-case with the TcpInboundGateway and acking with later reply you need to use a PublishSubscribeChannel with an Executor injected to make a processing async.

The first subscriber should return some ack into the replyChannel header. This way your TcpInboundGateway will perform request-reply and return that ack into the socket connected.

At the same time as you want, the second subscriber can perform desired logic and build the real reply later. Only the point that we need to use the mention in the docs Collaborating Outbound and Inbound Channel Adapters (as you noticed already). So, since TcpInboundGateway populates an IpHeaders.CONNECTION_ID header into a request message, it is going to be available in your async process and subsequent TcpSendingMessageHandler will know where to send your processed reply:

private void handleMessageAsServer(Message<?> message) {
    // We don't own the connection, we are asynchronously replying
    String connectionId = message.getHeaders().get(IpHeaders.CONNECTION_ID, String.class);
    TcpConnection connection = null;
    if (connectionId != null) {
        connection = this.connections.get(connectionId);
    }
    if (connection != null) {
        try {
            connection.send(message);
        }

So, what you need is like this:

1. a PublishSubscribeChannel with an executor for your TcpInboundGateway
2. A simple handler to reply with an ack as a first subscriber
3. A sub-flow for processing a request
4. A TcpSendingMessageHandler to send a process response into the same TCP connection.