整合其他消息协议呢，也一并加入进去，可以实现多协议的适配

是的，Spring Integration 可以整合多种协议，实现消息适配接入。以下是一个使用 Spring Integration 整合多种协议的 demo。

首先，我们需要添加 Spring Integration 和相关协议的依赖，例如 JMS、AMQP、HTTP 等。可以在 Maven 中添加以下依赖：

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-jms</artifactId>
    <version>5.5.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-amqp</artifactId>
    <version>5.5.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-http</artifactId>
    <version>5.5.0</version>
</dependency>

接下来，我们需要配置相关协议的连接工厂和目的地。以 JMS 为例：

@Bean
public ConnectionFactory jmsConnectionFactory() {
    ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
    connectionFactory.setBrokerURL("tcp://localhost:61616");
    connectionFactory.setUserName("admin");
    connectionFactory.setPassword("admin");
    return connectionFactory;
}

@Bean
public Destination jmsDestination() {
    return new ActiveMQQueue("test.queue");
}

以 AMQP 为例：

@Bean
public ConnectionFactory amqpConnectionFactory() {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory("localhost", 5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    return connectionFactory;
}

@Bean
public Queue amqpQueue() {
    return new Queue("test.queue");
}

以 HTTP 为例：

@Bean
public HttpComponentsClientHttpRequestFactory httpRequestFactory() {
    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    factory.setConnectTimeout(5000);
    factory.setReadTimeout(5000);
    return factory;
}

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate(httpRequestFactory());
}

@Bean
public IntegrationFlow httpInboundFlow() {
    return IntegrationFlows.from(Http.inboundGateway("/test")
            .requestMapping(r -> r.methods(HttpMethod.POST))
            .requestPayloadType(String.class))
            .handle((payload, headers) -> {
                System.out.println("Received message: " + payload);
                return null;
            })
            .get();
}

然后，我们需要配置消息监听器和消息处理器：

@Bean
public JmsMessageDrivenEndpoint jmsMessageDrivenEndpoint() {
    JmsMessageDrivenEndpoint endpoint = new JmsMessageDrivenEndpoint(
            jmsMessageListenerContainer(),
            new MessageHandler() {
                @Override
                public void handleMessage(Message<?> message) throws MessagingException {
                    System.out.println("Received message: " + message.getPayload());
                }
            }
    );
    return endpoint;
}

@Bean
public DefaultMessageListenerContainer jmsMessageListenerContainer() {
    DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
    container.setConnectionFactory(jmsConnectionFactory());
    container.setDestination(jmsDestination());
    container.setMessageListener(new SimpleMessageListener());
    return container;
}

private static class SimpleMessageListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        System.out.println("Received message: " + message);
    }
}

以 AMQP 为例：

@Bean
public org.springframework.amqp.core.MessageListener amqpMessageListener() {
    return new org.springframework.amqp.core.MessageListener() {
        @Override
        public void onMessage(org.springframework.amqp.core.Message message) {
            System.out.println("Received message: " + new String(message.getBody()));
        }
    };
}

@Bean
public SimpleMessageListenerContainer amqpMessageListenerContainer() {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(amqpConnectionFactory());
    container.setQueueNames(amqpQueue().getName());
    container.setMessageListener(amqpMessageListener());
    return container;
}

最后，我们需要将消息监听器注册到 Spring Integration 的消息通道中：

@Bean
public MessageChannel jmsInputChannel() {
    return new DirectChannel();
}

@Bean
public MessageChannel amqpInputChannel() {
    return new DirectChannel();
}

@Bean
public IntegrationFlow jmsInboundFlow() {
    return IntegrationFlows.from(jmsMessageDrivenEndpoint())
            .channel(jmsInputChannel())
            .get();
}

@Bean
public IntegrationFlow amqpInboundFlow() {
    return IntegrationFlows.from(Amqp.inboundAdapter(amqpMessageListenerContainer()))
            .channel(amqpInputChannel())
            .get();
}

现在，我们已经完成了 Spring Integration 整合多种协议的 demo，可以运行程序进行测试了。当有消息发送到 JMS、AMQP 或 HTTP 中时，程序会自动监听并处理消息。