轉：http://haohaoxuexi.iteye.com/blog/1893676

Spring一共為我們提供了兩種型別的MessageListenerContainer，SimpleMessageListenerContainer和DefaultMessageListenerContainer。

SimpleMessageListenerContainer會在一開始的時候就建立一個會話session和消費者Consumer，並且會使用標準的JMS MessageConsumer.setMessageListener()方法註冊監聽器讓JMS提供者呼叫監聽器的回撥函式。它不會動態的適應執行時需要和參與外部的事務管理。相容性方面，它非常接近於獨立的JMS規範，但一般不相容Java EE的JMS限制。

大多數情況下我們還是使用的DefaultMessageListenerContainer，跟SimpleMessageListenerContainer相比，DefaultMessageListenerContainer會動態的適應執行時需要，並且能夠參與外部的事務管理。它很好的平衡了對JMS提供者要求低、先進功能如事務參與和相容Java EE環境。

三種訊息監聽器:

Spring整合JMS的應用中我們在定義訊息監聽器的時候一共可以定義三種類型的訊息監聽器，分別是MessageListener、SessionAwareMessageListener和MessageListenerAdapter

MessageListener

MessageListener是最原始的訊息監聽器，它是JMS規範中定義的一個介面。其中定義了一個用於處理接收到的訊息的onMessage方法，該方法只接收一個Message引數。

SessionAwareMessageListener

SessionAwareMessageListener是Spring為我們提供的，它不是標準的JMS MessageListener。MessageListener的設計只是純粹用來接收訊息的，假如我們在使用MessageListener處理接收到的訊息時我們需要傳送一個訊息通知對方我們已經收到這個訊息了，那麼這個時候我們就需要在程式碼裡面去重新獲取一個Connection或Session。SessionAwareMessageListener的設計就是為了方便我們在接收到訊息後傳送一個回覆的訊息，它同樣為我們提供了一個處理接收到的訊息的onMessage方法，但是這個方法可以同時接收兩個引數，一個是表示當前接收到的訊息Message，另一個就是可以用來發送訊息的Session物件。

MessageProducer producer = session.createProducer(destination);  Message textMessage = session.createTextMessage("ConsumerSessionAwareMessageListener。。。"); 

producer.send(textMessage);

MessageListenerAdapter

MessageListenerAdapter類實現了MessageListener介面和SessionAwareMessageListener介面，它的主要作用是將接收到的訊息進行型別轉換，然後通過反射的形式把它交給一個普通的Java類進行處理。

1.3     訊息監聽器MessageListener

       在Spring整合JMS的應用中我們在定義訊息監聽器的時候一共可以定義三種類型的訊息監聽器，分別是MessageListener、SessionAwareMessageListener和MessageListenerAdapter。下面就分別來介紹一下這幾種型別的區別。

1.3.1  MessageListener

MessageListener是最原始的訊息監聽器，它是JMS規範中定義的一個介面。其中定義了一個用於處理接收到的訊息的onMessage方法，該方法只接收一個Message引數。我們前面在講配置消費者的時候用的訊息監聽器就是MessageListener，程式碼如下：

Java程式碼  

1. import javax.jms.JMSException;  
2. import javax.jms.Message;  
3. import javax.jms.MessageListener;  
4. import javax.jms.TextMessage;  
5. public class ConsumerMessageListener implements MessageListener {  
6.     public void onMessage(Message message) {  
7.         //這裡我們知道生產者傳送的就是一個純文字訊息，所以這裡可以直接進行強制轉換，或者直接把onMessage方法的引數改成Message的子類TextMessage  
8.         TextMessage textMsg = (TextMessage) message;  
9.         System.out.println("接收到一個純文字訊息。");  
10.         try {  
11.             System.out.println("訊息內容是：" + textMsg.getText());  
12.         } catch (JMSException e) {  
13.             e.printStackTrace();  
14.         }  
15.     }  
16. }  

1.3.2  SessionAwareMessageListener

SessionAwareMessageListener是Spring為我們提供的，它不是標準的JMS MessageListener。MessageListener的設計只是純粹用來接收訊息的，假如我們在使用MessageListener處理接收到的訊息時我們需要傳送一個訊息通知對方我們已經收到這個訊息了，那麼這個時候我們就需要在程式碼裡面去重新獲取一個Connection或Session。SessionAwareMessageListener的設計就是為了方便我們在接收到訊息後傳送一個回覆的訊息，它同樣為我們提供了一個處理接收到的訊息的onMessage方法，但是這個方法可以同時接收兩個引數，一個是表示當前接收到的訊息Message，另一個就是可以用來發送訊息的Session物件。先來看一段程式碼：

Java程式碼  

1. package com.tiantian.springintejms.listener;  
2. import javax.jms.Destination;  
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.MessageProducer;  
6. import javax.jms.Session;  
7. import javax.jms.TextMessage;  
8. import org.springframework.jms.listener.SessionAwareMessageListener;  
9. public class ConsumerSessionAwareMessageListener implements  
10.         SessionAwareMessageListener<TextMessage> {  
11.     private Destination destination;  
12.     public void onMessage(TextMessage message, Session session) throws JMSException {  
13.         System.out.println("收到一條訊息");  
14.         System.out.println("訊息內容是：" + message.getText());  
15.         MessageProducer producer = session.createProducer(destination);  
16.         Message textMessage = session.createTextMessage("ConsumerSessionAwareMessageListener。。。");  
17.         producer.send(textMessage);  
18.     }  
19.     public Destination getDestination() {  
20.         returndestination;  
21.     }  
22.     public void setDestination(Destination destination) {  
23.         this.destination = destination;  
24.     }  
25. }  

       在上面程式碼中我們定義了一個SessionAwareMessageListener，在這個Listener中我們在接收到了一個訊息之後，利用對應的Session建立了一個到destination的生產者和對應的訊息，然後利用建立好的生產者傳送對應的訊息。

       接著我們在Spring的配置檔案中配置該訊息監聽器將處理來自一個叫sessionAwareQueue的目的地的訊息，並且往該MessageListener中通過set方法注入其屬性destination的值為queueDestination。這樣當我們的SessionAwareMessageListener接收到訊息之後就會往queueDestination傳送一個訊息。

Xml程式碼  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
4.     xmlns:jms="http://www.springframework.org/schema/jms"  
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
6.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
7.      http://www.springframework.org/schema/context  
8.      http://www.springframework.org/schema/context/spring-context-3.0.xsd  
9.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
10.     http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">  
11.     <context:component-scan base-package="com.tiantian" />   
12.     <!-- Spring提供的JMS工具類，它可以進行訊息傳送、接收等 -->  
13.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
14.         <!-- 這個connectionFactory對應的是我們定義的Spring提供的那個ConnectionFactory物件 -->  
15.         <property name="connectionFactory" ref="connectionFactory"/>  
16.     </bean>  
17.     <!-- 真正可以產生Connection的ConnectionFactory，由對應的 JMS服務廠商提供-->  
18.     <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
19.         <property name="brokerURL" value="tcp://localhost:61616"/>  
20.     </bean>  
21.     <!-- Spring用於管理真正的ConnectionFactory的ConnectionFactory -->  
22.     <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
23.         <!-- 目標ConnectionFactory對應真實的可以產生JMS Connection的ConnectionFactory -->  
24.         <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
25.     </bean>  
26.     <!--這個是佇列目的地-->  
27.     <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">  
28.         <constructor-arg>  
29.             <value>queue</value>  
30.         </constructor-arg>  
31.     </bean>  
32.     <!--這個是sessionAwareQueue目的地-->  
33.     <bean id="sessionAwareQueue" class="org.apache.activemq.command.ActiveMQQueue">  
34.         <constructor-arg>  
35.             <value>sessionAwareQueue</value>  
36.         </constructor-arg>  
37.     </bean>  
38.     <!-- 訊息監聽器 -->  
39.     <bean id="consumerMessageListener" class="com.tiantian.springintejms.listener.ConsumerMessageListener"/>  
40.     <!-- 可以獲取session的MessageListener -->  
41.     <bean id="consumerSessionAwareMessageListener" class="com.tiantian.springintejms.listener.ConsumerSessionAwareMessageListener">  
42.         <property name="destination" ref="queueDestination"/>  
43.     </bean>  
44.     <!-- 訊息監聽容器 -->  
45.     <bean id="jmsContainer"        class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
46.         <property name="connectionFactory" ref="connectionFactory" />  
47.         <property name="destination" ref="queueDestination" />  
48.         <property name="messageListener" ref="consumerMessageListener" />  
49.     </bean>  
50.     <bean id="sessionAwareListenerContainer"  
51.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
52.         <property name="connectionFactory" ref="connectionFactory" />  
53.         <property name="destination" ref="sessionAwareQueue" />  
54.         <property name="messageListener" ref="consumerSessionAwareMessageListener" />  
55.     </bean>  
56. </beans>  

       接著我們來做一個測試，測試程式碼如下：

Java程式碼  

1. @RunWith(SpringJUnit4ClassRunner.class)  
2. @ContextConfiguration("/applicationContext.xml")  
3. public class ProducerConsumerTest {  
4.     @Autowired  
5.     private ProducerService producerService;  
6.     @Autowired  
7.     @Qualifier("sessionAwareQueue")  
8.     private Destination sessionAwareQueue;  
9.     @Test  
10.     public void testSessionAwareMessageListener() {  
11.         producerService.sendMessage(sessionAwareQueue, "測試SessionAwareMessageListener");  
12.     }  
13. }  

       在上述測試程式碼中，我們通過前面定義好的生產者往我們定義好的SessionAwareMessageListener監聽的sessionAwareQueue傳送了一個訊息。程式執行之後控制檯輸出如下：

 

       這說明我們已經成功的往sessionAwareQueue傳送了一條純文字訊息，訊息會被ConsumerSessionAwareMessageListener的onMessage方法進行處理，在onMessage方法中ConsumerSessionAwareMessageListener就是簡單的把接收到的純文字資訊的內容打印出來了，之後再往queueDestination傳送了一個純文字訊息，訊息內容是“ConsumerSessionAwareMessageListener…”，該訊息隨後就被ConsumerMessageListener處理了，根據我們的定義，在ConsumerMessageListener中也只是簡單的列印了一下接收到的訊息內容。

1.3.3  MessageListenerAdapter

MessageListenerAdapter類實現了MessageListener介面和SessionAwareMessageListener介面，它的主要作用是將接收到的訊息進行型別轉換，然後通過反射的形式把它交給一個普通的Java類進行處理。

       MessageListenerAdapter會把接收到的訊息做如下轉換：

       TextMessage轉換為String物件；

       BytesMessage轉換為byte陣列；

       MapMessage轉換為Map物件；

       ObjectMessage轉換為對應的Serializable物件。

       既然前面說了MessageListenerAdapter會把接收到的訊息做一個型別轉換，然後利用反射把它交給真正的目標處理器——一個普通的Java類進行處理（如果真正的目標處理器是一個MessageListener或者是一個SessionAwareMessageListener，那麼Spring將直接使用接收到的Message物件作為引數呼叫它們的onMessage方法，而不會再利用反射去進行呼叫），那麼我們在定義一個MessageListenerAdapter的時候就需要為它指定這樣一個目標類。這個目標類我們可以通過MessageListenerAdapter的構造方法引數指定，如：

Xml程式碼  

1. <!-- 訊息監聽介面卡 -->  
2.     <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
3.         <constructor-arg>  
4.             <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
5.         </constructor-arg>  
6.     </bean>  

       也可以通過它的delegate屬性來指定，如：

Xml程式碼  

1. <!-- 訊息監聽介面卡 -->  
2.     <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
3.         <property name="delegate">  
4.             <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
5.         </property>  
6.         <property name="defaultListenerMethod" value="receiveMessage"/>  
7.     </bean>  

       前面說了如果我們指定的這個目標處理器是一個MessageListener或者是一個SessionAwareMessageListener的時候Spring將直接利用接收到的Message物件作為方法引數呼叫它們的onMessage方法。但是如果指定的目標處理器是一個普通的Java類時Spring將利用Message進行了型別轉換之後的物件作為引數通過反射去呼叫真正的目標處理器的處理方法，那麼Spring是如何知道該呼叫哪個方法呢？這是通過MessageListenerAdapter的defaultListenerMethod屬性來決定的，當我們沒有指定該屬性時，Spring會預設呼叫目標處理器的handleMessage方法。

       接下來我們來看一個示例，假設我們有一個普通的Java類ConsumerListener，其對應有兩個方法，handleMessage和receiveMessage，其程式碼如下：

Java程式碼  

1. package com.tiantian.springintejms.listener;  
2. public class ConsumerListener {  
3.     public void handleMessage(String message) {  
4.         System.out.println("ConsumerListener通過handleMessage接收到一個純文字訊息，訊息內容是：" + message);  
5.     }  
6.     public void receiveMessage(String message) {  
7.         System.out.println("ConsumerListener通過receiveMessage接收到一個純文字訊息，訊息內容是：" + message);  
8.     }  
9. }  

       假設我們要把它作為一個訊息監聽器來監聽傳送到adapterQueue的訊息，這個時候我們就可以定義一個對應的MessageListenerAdapter來把它當做一個MessageListener使用。

Xml程式碼  

1. <!-- 訊息監聽介面卡 -->  
2. <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
3.     <property name="delegate">  
4.         <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
5.     </property>  
6.     <property name="defaultListenerMethod" value="receiveMessage"/>  
7. </bean>  

       當然，有了MessageListener之後我們還需要配置其對應的MessageListenerContainer，這裡配置如下：

Xml程式碼  

1.     <!-- 訊息監聽介面卡對應的監聽容器 -->  
2.     <bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
3.         <property name="connectionFactory" ref="connectionFactory"/>  
4.         <property name="destination" ref="adapterQueue"/>  
5.         <property name="messageListener" ref="messageListenerAdapter"/><!-- 使用MessageListenerAdapter來作為訊息監聽器 -->  
6.     </bean>  
7. <!-- 用於測試訊息監聽介面卡的佇列目的地 -->  
8.     <bean id="adapterQueue" class="org.apache.activemq.command.ActiveMQQueue">  
9.         <constructor-arg>  
10.             <value>adapterQueue</value>  
11.         </constructor-arg>  
12.     </bean>  

       在上面的MessageListenerAdapter中我們指定了其defaultListenerMethod屬性的值為receiveMessage，所以當MessageListenerAdapter接收到訊息之後會自動的呼叫我們指定的ConsumerListener的receiveMessage方法。

       針對於上述程式碼我們定義測試程式碼如下：

Java程式碼  

1. package com.tiantian.springintejms.test;  
2. import javax.jms.Destination;  
3. import org.junit.Test;  
4. import org.junit.runner.RunWith;  
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.beans.factory.annotation.Qualifier;  
7. import org.springframework.test.context.ContextConfiguration;  
8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
9. import com.tiantian.springintejms.service.ProducerService;  
10. @RunWith(SpringJUnit4ClassRunner.class)  
11. @ContextConfiguration("/applicationContext.xml")  
12. public class ProducerConsumerTest {  
13.     @Autowired  
14.     @Qualifier("adapterQueue")  
15.     private Destination adapterQueue;  
16.     @Test  
17.     public void testMessageListenerAdapter() {  
18.         producerService.sendMessage(adapterQueue, "測試MessageListenerAdapter");  
19.     }  
20. }  

       這時候我們會看到控制檯輸出如下：

        如果我們不指定MessageListenerAdapter的defaultListenerMethod屬性，那麼在執行上述程式碼時控制檯會輸出如下結果：

        MessageListenerAdapter除了會自動的把一個普通Java類當做MessageListener來處理接收到的訊息之外，其另外一個主要的功能是可以自動的傳送返回訊息。

     當我們用於處理接收到的訊息的方法的返回值不為空的時候，Spring會自動將它封裝為一個JMS Message，然後自動進行回覆。那麼這個時候這個回覆訊息將傳送到哪裡呢？這主要有兩種方式可以指定。
       第一，可以通過傳送的Message的setJMSReplyTo方法指定該訊息對應的回覆訊息的目的地。這裡我們把我們的生產者傳送訊息的程式碼做一下修改，在傳送訊息之前先指定該訊息對應的回覆目的地為一個叫responseQueue的佇列目的地，具體程式碼如下所示：

Java程式碼  

1. package com.tiantian.springintejms.service.impl;  
2. import javax.jms.Destination;  
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.Session;  
6. import javax.jms.TextMessage;  
7. import org.springframework.beans.factory.annotation.Autowired;  
8. import org.springframework.beans.factory.annotation.Qualifier;  
9. import org.springframework.jms.core.JmsTemplate;  
10. import org.springframework.jms.core.MessageCreator;  
11. import org.springframework.stereotype.Component;  
12. import com.tiantian.springintejms.service.ProducerService;  
13. @Component  
14. public class ProducerServiceImpl implements ProducerService {   
15.     @Autowired  
16.     private JmsTemplate jmsTemplate;  
17.     @Autowired  
18.     @Qualifier("responseQueue")  
19.     private Destination responseDestination;  
20.     public void sendMessage(Destination destination, final String message) {  
21.         System.out.println("---------------生產者傳送訊息-----------------");  
22.         System.out.println("---------------生產者發了一個訊息：" + message);  
23.         jmsTemplate.send(destination, new MessageCreator() {  
24.             public Message createMessage(Session session) throws JMSException {  
25.                 TextMessage textMessage = session.createTextMessage(message);  
26.                 textMessage.setJMSReplyTo(responseDestination);  
27.                 return textMessage;  
28.             }  
29.         });  
30.     }  
31. }  

       接著定義一個叫responseQueue的佇列目的地及其對應的訊息監聽器和監聽容器。

Xml程式碼  

1. <!-- 用於測試訊息回覆的 -->  
2. <bean id="responseQueue" class="org.apache.activemq.command.ActiveMQQueue">  
3.     <constructor-arg>  
4.         <value>responseQueue</value>  
5.     </constructor-arg>  
6. </bean>  
7. <!-- responseQueue對應的監聽器 -->  
8. <bean id="responseQueueListener" class="com.tiantian.springintejms.listener.ResponseQueueListener"/>  
9. <!-- responseQueue對應的監聽容器 -->  
10. <bean id="responseQueueMessageListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
11.     <property name="connectionFactory" ref="connectionFactory"/>  
12.     <property name="destination" ref="responseQueue"/>  
13.     <property name="messageListener" ref="responseQueueListener"/>  
14. </bean>  

       ResponseQueueListener的定義如下所示：

Java程式碼  

1. public class ResponseQueueListener implements MessageListener {  
2.     public void onMessage(Message message) {  
3.         if (message instanceof TextMessage) {  
4.             TextMessage textMessage = (TextMessage) message;  
5.             try {  
6.                 System.out.println("接收到傳送到responseQueue的一個文字訊息，內容是：" + textMessage.getText());  
7.             } catch (JMSException e) {  
8.                 e.printStackTrace();  
9.             }  
10.         }  
11.     }  
12. }  

        接著把我們接收訊息的ConsumerListener的receiveMessage方法改為如下：

Java程式碼  

1. /** 
2.  * 當返回型別是非null時MessageListenerAdapter會自動把返回值封裝成一個Message，然後進行回覆 
3.  * @param message 
4.  * @return 
5.  */  
6. public String receiveMessage(String message) {  
7.     System.out.println("ConsumerListener通過receiveMessage接收到一個純文字訊息，訊息內容是：" + message);  
8.     return "這是ConsumerListener物件的receiveMessage方法的返回值。";  
9. }  

        我們可以看到在上述負責接收訊息的receiveMessage方法有一個非空的返回值。

       接著我們執行我們的測試程式碼，利用生產者往我們定義好的MessageListenerAdapter負責處理的adapterQueue目的地傳送一個訊息。測試程式碼如下所示：

Java程式碼  

1. @RunWith(SpringJUnit4ClassRunner.class)  
2. @ContextConfiguration("/applicationContext.xml")  
3. public class ProducerConsumerTest {  
4.     @Autowired  
5.     private ProducerService producerService;  
6.     @Qualifier("adapterQueue")  
7.     @Autowired  
8.     private Destination adapterQueue;     
9.     @Test  
10.     public void testMessageListenerAdapter() {  
11.         producerService.sendMessage(adapterQueue, "測試MessageListenerAdapter");  
12.     }  
13. }  

       執行上述測試程式碼之後，控制檯輸出如下：

        這說明我們的生產者傳送訊息被MessageListenerAdapter處理之後，MessageListenerAdapter確實把監聽器的返回內容封裝成一個Message往原Message通過setJMSReplyTo方法指定的回覆目的地傳送了一個訊息。對於MessageListenerAdapter對應的監聽器處理方法返回的是一個null值或者返回型別是void的情況，MessageListenerAdapter是不會自動進行訊息的回覆的，有興趣的網友可以自己測試一下。

       第二，通過MessageListenerAdapter的defaultResponseDestination屬性來指定。這裡我們也來做一個測試，首先維持生產者傳送訊息的程式碼不變，即傳送訊息前不通過Message的setJMSReplyTo方法指定訊息的回覆目的地；接著我們在定義MessageListenerAdapter的時候通過其defaultResponseDestination屬性指定其預設的回覆目的地是“defaultResponseQueue”，並定義defaultResponseQueue對應的訊息監聽器和訊息監聽容器。

Xml程式碼  

1. <!-- 訊息監聽介面卡 -->  
2. <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
3.     <!-- <constructor-arg>  
4.         <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
5.     </constructor-arg> -->  
6.     <property name="delegate">  
7.         <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
8.     </property>  
9.     <property name="defaultListenerMethod" value="receiveMessage"/>  
10.     <property name="defaultResponseDestination" ref="defaultResponseQueue"/>  
11. </bean>  
12. <!-- 訊息監聽介面卡對應的監聽容器 -->  
13. <bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
14.     <property name="connectionFactory" ref="connectionFactory"/>  
15.     <property name="destination" ref="adapterQueue"/>  
16.     <property name="messageListener" ref="messageListenerAdapter"/><!-- 使用MessageListenerAdapter來作為訊息監聽器 -->  
17. </bean>  
18. !-- 預設的訊息回覆佇列 -->  
19. <bean id="defaultResponseQueue" class="org.apache.activemq.command.ActiveMQQueue">  
20.     <constructor-arg>  
21.         <value>defaultResponseQueue</value>  
22.     </constructor-arg>  
23. </bean>  
24. <!-- defaultResponseQueue對應的監聽器 -->  
25. <bean id="defaultResponseQueueListener" class="com.tiantian.springintejms.listener.DefaultResponseQueueListener"/>  
26. <!-- defaultResponseQueue對應的監聽容器 -->  
27. <bean id="defaultResponseQueueMessageListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
28.     <property name="connectionFactory" ref="connectionFactory"/>  
29.     <property name="destination" ref="defaultResponseQueue"/>  
30.     <property name="messageListener" ref="defaultResponseQueueListener"/>  
31. </bean>  

       DefaultResponseQueueListener的程式碼如下所示：

Java程式碼  

1. package com.tiantian.springintejms.listener;  
2. import javax.jms.JMSException;  
3. import javax.jms.Message;  
4. import javax.jms.MessageListener;  
5. import javax.jms.TextMessage;  
6. public class DefaultResponseQueueListener implements MessageListener {  
7.     public void onMessage(Message message) {  
8.         if (message instanceof TextMessage) {  
9.             TextMessage textMessage = (TextMessage) message;  
10.             try {  
11.                 System.out.println("DefaultResponseQueueListener接收到傳送到defaultResponseQueue的一個文字訊息，內容是：" + textMessage.getText());  
12.             } catch (JMSException e) {  
13.                 e.printStackTrace();  
14.             }  
15.         }  
16.     }  
17. }  

       這時候執行如下測試程式碼：

Java程式碼  

1. @Test  
2. public void testMessageListenerAdapter() {  
3.     producerService.sendMessage(adapterQueue, "測試MessageListenerAdapter");  
4. }  

       控制檯將輸出如下內容：

        這說明MessageListenerAdapter會自動把真正的訊息處理器返回的非空內容封裝成一個Message傳送回覆訊息到通過defaultResponseDestination屬性指定的預設訊息回覆目的地。

       既然我們可以通過兩種方式來指定MessageListenerAdapter自動傳送回覆訊息的目的地，那麼當我們兩種方式都指定了而且它們的目的地還不一樣的時候會怎麼傳送呢？是兩個都發還是隻發其中的一個呢？關於這部分的測試我這裡就不贅述了，有興趣的網友可以自己進行。這裡我可以直接的告訴大家，當兩種方式都指定了訊息的回覆目的地的時候使用傳送訊息的setJMSReplyTo方法指定的目的地將具有較高的優先順序，MessageListenerAdapter將只往該方法指定的訊息回覆目的地傳送回覆訊息。