The difference between the PooledConnectionFactory and the CachingConnectionFactory is a difference in implementation. Below are some of the characteristics that differ between them:

• Although both the PooledConnectionFactory and the CachingConnectionFactory state that they each pool connections, sessions and producers, the PooledConnectionFactory does not actually create a cache of multiple producers. It simply uses a singleton pattern to hand out a single cached producer when one is requested. Whereas the CachingConnectionFactory actually creates a cache containing multiple producers and hands out one producer from the cache when one is requested.

• The PooledConnectionFactory is built on top of the Apache Commons Pool project for pooling JMS sessions. This allows some additional control over the pool because there are features in Commons Pool that are not being used by the PooledConnectionFactory. These additional features include growing the pool size instead of blocking, throwing an exception when the pool is exhausted, etc. You can utilize these features by creating your own Commons Pool GenericObjectPool using your own customized settings and then handing that object to the PooledConnectionFactory via the setPoolFactory method. See the following for additional info: http://commons.apache.org/pool/api-1.4/org/apache/commons/pool/impl/GenericObjectPoolFactory.html

• The CachingConnectionFactory has the ability to also cache consumers. Just need to take care when using this feature so that you know the consumers are cached according to the rules noted in the blog post.

• But most importantly, the CachingConnectionFactory will work with any JMS compliant MOM. It only requires a JMS connection factory. This is important if you are using more than one MOM vendor which is very common in enterprise organizations (this is mainly due to legacy and existing projects). The important point is that the CachingConnectionFactory works very well with many different MOM implementations, not only ActiveMQ.

From here:

• If you have clustered ActiveMQs, and use failover transport it has been reported that CachingConnectionFactory is not a right choice.

• The problem I’m having is that if one box goes down, we should start sending messages on the other, but it seems to still be using the old connection (every send times out). If I restart the program, it’ll connect again and everything works. Source: Autoreconnect problem with ActiveMQ and CachingConnectionFactory

• The problem is that cached connections to the failed ActiveMQ was still in use and that created the problem for the user. Now, the choice for this scenario is PooledConnectionFactory.

• If you’re using ActiveMQ today, and chances are that you may switch to some other broker (JBoss MQ, WebSphere MQ) in future, do not use PooledConnectionFactory, as it tightly couples your code to ActiveMQ.

• 安装NFSV4
• 修改消息存储路径
  
  <persistenceAdapter>
    <kahaDB directory="/sharedFileSystem/sharedBrokerData"/>
  </persistenceAdapter>
• 客户端修改连接字符串
  
  failover://(tcp://master:61616,tcp://slave:61616)?randomize=false

Request-Response is a message-exchange-pattern. In some cases, a message producer may want the consumers to reply to a message. The JMSReplyTo header indicates which destination, if any, a JMS consumer should reply to. The JMSReplyTo header is set explicitly by the JMS client; its contents will be a javax.jms.Destination object (either Topic or Queue).

In some cases, the JMS client will want the message consumers to reply to a temporary topic or queue set up by the JMS client. When a JMS message consumer receives a message that includes a JMSReplyTo destination, it can reply using that destination. A JMS consumer is not required to send a reply, but in some JMS applications, clients are programmed to do so.

For simplicity, this pattern is typically implemented in a purely synchronous fashion, as in web service calls over HTTP, which holds a connection open and waits until the response is delivered or the timeout period expires. However, request–response may also be implemented asynchronously, with a response being returned at some unknown later time.

For more information, check here.

Now, let’s jump into the code. In Spring, there are 2 ways to implement this (at least I know of).

1. Using JMSTemplate
2. Using Spring Integration

For demo purpose, I used ActiveMQ. However, you can implement this in other messaging systems like IBM MQ, Rabbit MQ, Tibco EMS, etc. In this demo, I send an ObjectMessage of type Order and reply with a Shipment object.

Using JMSTemplate

1. First, we include the required dependencies. Replace the activemq dependency with your messaging system’s jars if not using ActiveMQ
   

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.activemq.tooling</groupId>
            <artifactId>activemq-junit</artifactId>
            <version>${activemq.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2. Using the default spring.activemq. properties to configure the application with the ActiveMQ. However, you can do this inside a @Configuration class as well.
   

    spring:
      activemq:
        broker-url: tcp://localhost:61616
        non-blocking-redelivery: true
        packages:
          trust-all: true    
3. Note in the above configuration spring.activemq.packages.trust-all can be changed to spring.activemq.packages.trusted with the appropriate packages.

4. Now spring will do it’s magic and inject all the required Beans as usual :) However, in our code, we need to EnableJms
   

   import org.springframework.context.annotation.Configuration;
    import org.springframework.jms.annotation.EnableJms;
   
    @EnableJms
    @Configuration
    public class ActiveMQConfig {
   
        public static final String ORDER_QUEUE = "order-queue";
        public static final String ORDER_REPLY_2_QUEUE = "order-reply-2-queue";
   
    }

5. First, we will configure the Producer
   

    @Slf4j
    @Service
    public class Producer {
   
        @Autowired
        JmsMessagingTemplate jmsMessagingTemplate;
   
        @Autowired
        JmsTemplate jmsTemplate;
         private Session session;
   
         @PostConstruct
          public void init(){
            jmsTemplate.setReceiveTimeout(1000L);
            jmsMessagingTemplate.setJmsTemplate(jmsTemplate);
   
            session = jmsMessagingTemplate.getConnectionFactory().createConnection()
                    .createSession(false, Session.AUTO_ACKNOWLEDGE);
          }
   
        public Shipment sendWithReply(Order order) throws JMSException {
   
   
            ObjectMessage objectMessage = session.createObjectMessage(order);
   
            objectMessage.setJMSCorrelationID(UUID.randomUUID().toString());
            objectMessage.setJMSReplyTo(new ActiveMQQueue(ORDER_REPLY_2_QUEUE));
            objectMessage.setJMSCorrelationID(UUID.randomUUID().toString());
            objectMessage.setJMSExpiration(1000L);
            objectMessage.setJMSDeliveryMode(DeliveryMode.NON_PERSISTENT);
   
            return jmsMessagingTemplate.convertSendAndReceive(new ActiveMQQueue(ORDER_QUEUE),
                    objectMessage, Shipment.class); //this operation seems to be blocking + sync
        }
    }
6. Note in the above code that, JmsMessagingTemplate is used instead of JmsTemplatebecause, we are interested in the method convertSendAndReceive. As seen in the method signature, it waits to receive the Shipment object from the consumer.

7. Next, we can see the Receiver
   

    @Component
    public class Receiver implements SessionAwareMessageListener<Message> {
   
        @Override
        @JmsListener(destination = ORDER_QUEUE)
        public void onMessage(Message message, Session session) throws JMSException {
            Order order = (Order) ((ActiveMQObjectMessage) message).getObject();
            Shipment shipment = new Shipment(order.getId(), UUID.randomUUID().toString());
   
            // done handling the request, now create a response message
            final ObjectMessage responseMessage = new ActiveMQObjectMessage();
            responseMessage.setJMSCorrelationID(message.getJMSCorrelationID());
            responseMessage.setObject(shipment);
   
            // Message sent back to the replyTo address of the income message.
            final MessageProducer producer = session.createProducer(message.getJMSReplyTo());
            producer.send(responseMessage);
        }
    }
8. Using the javax.jms.Session the javax.jms.MessageProducer is created and used to send the reply message to the JMSReplyTo queue. In real life, this receiver could be a different application altogether.

Using Spring Integration

1. First, we include the required dependencies in addition to the above dependencies
   

    <dependency>
      <groupId>org.springframework.integration</groupId>
      <artifactId>spring-integration-jms</artifactId>
    </dependency>

2. Using the default spring.activemq. properties to configure the application with the ActiveMQ. However, you can do this inside a @Configuration class as well.
   

    spring:
      activemq:
        broker-url: tcp://localhost:61616
        non-blocking-redelivery: true
        packages:
          trust-all: true   
3. Note in the above configuration spring.activemq.packages.trust-all can be changed to spring.activemq.packages.trusted with the appropriate packages.

4. Next we create the required Beans for the Spring Integration.
   
   

    @EnableIntegration
    @IntegrationComponentScan
    @Configuration
    public class ActiveMQConfig {
   
        public static final String ORDER_QUEUE = "order-queue";
        public static final String ORDER_REPLY_2_QUEUE = "order-reply-2-queue";
   
        @Bean
        public MessageConverter messageConverter() {
            MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
            converter.setTargetType(MessageType.TEXT);
            converter.setTypeIdPropertyName("_type");
            return converter;
        }
   
        @Bean
        public MessageChannel requests() {
            return new DirectChannel();
        }
   
        @Bean
        @ServiceActivator(inputChannel = "requests")
        public JmsOutboundGateway jmsGateway(ActiveMQConnectionFactory activeMQConnectionFactory) {
            JmsOutboundGateway gateway = new JmsOutboundGateway();
            gateway.setConnectionFactory(activeMQConnectionFactory);
            gateway.setRequestDestinationName(ORDER_QUEUE);
            gateway.setReplyDestinationName(ORDER_REPLY_2_QUEUE);
            gateway.setCorrelationKey("JMSCorrelationID");
            gateway.setSendTimeout(100L);
            gateway.setReceiveTimeout(100L);
            return gateway;
        }
   
        @Autowired
        Receiver receiver;
   
        @Bean
        public DefaultMessageListenerContainer responder(ActiveMQConnectionFactory activeMQConnectionFactory) {
            DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
            container.setConnectionFactory(activeMQConnectionFactory);
            container.setDestinationName(ORDER_QUEUE);
            MessageListenerAdapter adapter = new MessageListenerAdapter(new Object() {
   
                @SuppressWarnings("unused")
                public Shipment handleMessage(Order order) {
                    return receiver.receiveMessage(order);
                }
   
            });
            container.setMessageListener(adapter);
            return container;
        }
    }

5. Next, we will configure the MessagingGateway
   
   

    @MessagingGateway(defaultRequestChannel = "requests")
    public interface ClientGateway {
        Shipment sendAndReceive(Order order);
    }

6. We then Autowire this gateway in our Component class when we want to send and receive the message. A sample is shown below.
   
   

    @Slf4j
    @Component
    public class Receiver {
        public Shipment receiveMessage(@Payload Order order) {
            Shipment shipment = new Shipment(order.getId(), UUID.randomUUID().toString());
            return shipment;
        }
    }
7. Next we configure the Componen to process the Order message. After successful execution, this component will send the Shipment message to the JMSReplyTo queue. In real life, this receiver could be a different application altogether.

For those, who just want to clone the code, head out to aniruthmp/jms