使用Spring JMS收发消息

非常感谢http://my.oschina.net/xiaoxishan/blog?catalog=3270616

ActiveMQ技术学习 https://www.itkc8.com 

ActiveMQ学习笔记(四)http://my.oschina.net/xiaoxishan/blog/380446 中记录了如何使用原生的方式从ActiveMQ中收发消息。可以看出，每次收发消息都要写许多重复的代码，Spring 为我们提供了更为方便的方式，这就是Spring JMS。我们通过一个例子展开讲述。包括队列、主题消息的收发相关的Spring配置、代码、测试。

ActiveMQ Spring JMS

 

目录[-]

• 1.使用maven管理依赖包
• 2.队列消息的收发
• 2.1Spring配置文件
• 2.2消息生产者代码
• 2.3消息消费者代码
• 2.4队列消息监听
• 3.主题消息收发
• 3.1Spring配置
• 3.2消息发布者
• 3.3消息订阅者（监听）
• 4.测试
• 4.1 测试代码
• 4.2 测试结果
• 5.代码地址

       ActiveMQ学习笔记(四)http://my.oschina.net/xiaoxishan/blog/380446 中记录了如何使用原生的方式从ActiveMQ中收发消息。可以看出，每次收发消息都要写许多重复的代码，Spring 为我们提供了更为方便的方式，这就是Spring JMS。我们通过一个例子展开讲述。包括队列、主题消息的收发相关的Spring配置、代码、测试。

       本例中，消息的收发都写在了一个工程里。

1.使用maven管理依赖包

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

<dependencies>     <dependency>         <groupId>junit</groupId>         <artifactId>junit</artifactId>         <version>4.12</version>         <scope>test</scope>     </dependency>     <dependency>         <groupId>org.apache.activemq</groupId>         <artifactId>activemq-all</artifactId>         <version>5.11.0</version>     </dependency>     <dependency>         <groupId>org.springframework</groupId>         <artifactId>spring-jms</artifactId>         <version>4.1.4.RELEASE</version>     </dependency>     <dependency>           <groupId>org.springframework</groupId>           <artifactId>spring-test</artifactId>           <version>4.1.4.RELEASE</version>       </dependency>  </dependencies>

 

2.队列消息的收发

2.1Spring配置文件

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd">       <!-- 配置JMS连接工厂 -->     <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">         <property name="brokerURL" value="failover:(tcp://localhost:61616)" />     </bean>           <!-- 定义消息队列（Queue） -->     <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">         <!-- 设置消息队列的名字 -->         <constructor-arg>             <value>queue1</value>         </constructor-arg>     </bean>           <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">         <property name="connectionFactory" ref="connectionFactory" />         <property name="defaultDestination" ref="queueDestination" />         <property name="receiveTimeout" value="10000" />     </bean>           <!--queue消息生产者 -->     <bean id="producerService" class="guo.examples.mq02.queue.ProducerServiceImpl">         <property name="jmsTemplate" ref="jmsTemplate"></property>     </bean>       <!--queue消息消费者 -->     <bean id="consumerService" class="guo.examples.mq02.queue.ConsumerServiceImpl">         <property name="jmsTemplate" ref="jmsTemplate"></property>     </bean>

 

2.2消息生产者代码

从下面的代码可以出，使用Spring JMS，可以减少重复代码（接口类ProducerService代码省略）。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

package guo.examples.mq02.queue;   import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.Session;   import org.springframework.jms.core.JmsTemplate; import org.springframework.jms.core.MessageCreator;   public class ProducerServiceImpl implements ProducerService {     private JmsTemplate jmsTemplate;       /**    * 向指定队列发送消息    */   public void sendMessage(Destination destination, final String msg) {     System.out.println("向队列" + destination.toString() + "发送了消息------------" + msg);     jmsTemplate.send(destination, new MessageCreator() {       public Message createMessage(Session session) throws JMSException {         return session.createTextMessage(msg);       }     });   }   /**  * 向默认队列发送消息  */   public void sendMessage(final String msg) {     String destination =  jmsTemplate.getDefaultDestination().toString();     System.out.println("向队列" +destination+ "发送了消息------------" + msg);     jmsTemplate.send(new MessageCreator() {       public Message createMessage(Session session) throws JMSException {         return session.createTextMessage(msg);       }     });     }     public void setJmsTemplate(JmsTemplate jmsTemplate) {     this.jmsTemplate = jmsTemplate;   }   }

2.3消息消费者代码

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

package guo.examples.mq02.queue;   import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.TextMessage;   import org.springframework.jms.core.JmsTemplate;   public class ConsumerServiceImpl implements ConsumerService {       private JmsTemplate jmsTemplate;       /**      * 接受消息      */     public void receive(Destination destination) {         TextMessage tm = (TextMessage) jmsTemplate.receive(destination);         try {             System.out.println("从队列" + destination.toString() + "收到了消息：\t"                     + tm.getText());         } catch (JMSException e) {             e.printStackTrace();         }     }       public void setJmsTemplate(JmsTemplate jmsTemplate) {         this.jmsTemplate = jmsTemplate;     }   }

 

2.4队列消息监听

接受消息的时候，可以不用2.3节中的方式，Spring JMS同样提供了消息监听的模式，下面给出对应的配置和代码。

Spring配置

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

<!-- 定义消息队列（Queue），我们监听一个新的队列，queue2 -->     <bean id="queueDestination2" class="org.apache.activemq.command.ActiveMQQueue">         <!-- 设置消息队列的名字 -->         <constructor-arg>             <value>queue2</value>         </constructor-arg>     </bean>           <!-- 配置消息队列监听者（Queue），代码下面给出，只有一个onMessage方法 -->     <bean id="queueMessageListener" class="guo.examples.mq02.queue.QueueMessageListener" />           <!-- 消息监听容器（Queue），配置连接工厂，监听的队列是queue2，监听器是上面定义的监听器 -->     <bean id="jmsContainer"         class="org.springframework.jms.listener.DefaultMessageListenerContainer">         <property name="connectionFactory" ref="connectionFactory" />         <property name="destination" ref="queueDestination2" />         <property name="messageListener" ref="queueMessageListener" />     </bean>

监听类代码

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

package guo.examples.mq02.queue;   import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageListener; import javax.jms.TextMessage;   public class QueueMessageListener implements MessageListener {         //当收到消息时，自动调用该方法。     public void onMessage(Message message) {         TextMessage tm = (TextMessage) message;         try {             System.out.println("ConsumerMessageListener收到了文本消息：\t"                     + tm.getText());         } catch (JMSException e) {             e.printStackTrace();         }     }   }

 

 

3.主题消息收发

     在使用Spring JMS的时候，主题（Topic）和队列消息的主要差异体现在JmsTemplate中"pubSubDomain"是否设置为True。如果为True，则是Topic；如果是false或者默认，则是queue。

?

1	<property name="pubSubDomain" value="true" />

 

3.1Spring配置

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

<!-- 定义消息主题（Topic） -->     <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">         <constructor-arg>             <value>guo_topic</value>         </constructor-arg>     </bean>     <!-- 配置JMS模板（Topic），pubSubDomain="true"-->     <bean id="topicJmsTemplate" class="org.springframework.jms.core.JmsTemplate">         <property name="connectionFactory" ref="connectionFactory" />         <property name="defaultDestination" ref="topicDestination" />         <property name="pubSubDomain" value="true" />         <property name="receiveTimeout" value="10000" />     </bean>     <!--topic消息发布者 -->     <bean id="topicProvider" class="guo.examples.mq02.topic.TopicProvider">         <property name="topicJmsTemplate" ref="topicJmsTemplate"></property>     </bean>     <!-- 消息主题监听者 和 主题监听容器 可以配置多个，即多个订阅者 -->     <!-- 消息主题监听者(Topic) -->     <bean id="topicMessageListener" class="guo.examples.mq02.topic.TopicMessageListener" />     <!-- 主题监听容器 （Topic） -->     <bean id="topicJmsContainer"         class="org.springframework.jms.listener.DefaultMessageListenerContainer">         <property name="connectionFactory" ref="connectionFactory" />         <property name="destination" ref="topicDestination" />         <property name="messageListener" ref="topicMessageListener" />     </bean>

3.2消息发布者

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

package guo.examples.mq02.topic;   import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.Session;   import org.springframework.jms.core.JmsTemplate; import org.springframework.jms.core.MessageCreator;   public class TopicProvider {       private JmsTemplate topicJmsTemplate;       /**      * 向指定的topic发布消息      *       * @param topic      * @param msg      */     public void publish(final Destination topic, final String msg) {           topicJmsTemplate.send(topic, new MessageCreator() {             public Message createMessage(Session session) throws JMSException {                 System.out.println("topic name 是" + topic.toString()                         + "，发布消息内容为:\t" + msg);                 return session.createTextMessage(msg);             }         });     }       public void setTopicJmsTemplate(JmsTemplate topicJmsTemplate) {         this.topicJmsTemplate = topicJmsTemplate;     }   }

3.3消息订阅者（监听）

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package guo.examples.mq02.topic;   import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageListener; import javax.jms.TextMessage; /**  *和队列监听的代码一样。  */ public class TopicMessageListener implements MessageListener {       public void onMessage(Message message) {         TextMessage tm = (TextMessage) message;         try {             System.out.println("TopicMessageListener \t" + tm.getText());         } catch (JMSException e) {             e.printStackTrace();         }     }   }

 

4.测试

4.1 测试代码

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

package guo.examples.mq02;   import javax.jms.Destination;   import guo.examples.mq02.queue.ConsumerService; import guo.examples.mq02.queue.ProducerService; import guo.examples.mq02.topic.TopicProvider;   import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;   /**  * 测试Spring JMS  *   * 1.测试生产者发送消息  *   * 2. 测试消费者接受消息  *   * 3. 测试消息监听  *   * 4.测试主题监听  *  */ @RunWith(SpringJUnit4ClassRunner.class) // ApplicationContext context = new // ClassPathXmlApplicationContext("applicationContext.xml"); @ContextConfiguration("/applicationContext.xml") public class SpringJmsTest {       /**      * 队列名queue1      */     @Autowired     private Destination queueDestination;       /**      * 队列名queue2      */     @Autowired     private Destination queueDestination2;       /**      * 主题 guo_topic      */     @Autowired     @Qualifier("topicDestination")     private Destination topic;       /**      * 主题消息发布者      */     @Autowired     private TopicProvider topicProvider;       /**      * 队列消息生产者      */     @Autowired     @Qualifier("producerService")     private ProducerService producer;       /**      * 队列消息生产者      */     @Autowired     @Qualifier("consumerService")     private ConsumerService consumer;       /**      * 测试生产者向queue1发送消息      */     @Test     public void testProduce() {         String msg = "Hello world!";         producer.sendMessage(msg);     }       /**      * 测试消费者从queue1接受消息      */     @Test     public void testConsume() {         consumer.receive(queueDestination);     }       /**      * 测试消息监听      *       * 1.生产者向队列queue2发送消息      *       * 2.ConsumerMessageListener监听队列，并消费消息      */     @Test     public void testSend() {         producer.sendMessage(queueDestination2, "Hello China~~~~~~~~~~~~~~~");     }       /**      * 测试主题监听      *       * 1.生产者向主题发布消息      *       * 2.ConsumerMessageListener监听主题，并消费消息      */     @Test     public void testTopic() throws Exception {         topicProvider.publish(topic, "Hello T-To-Top-Topi-Topic!");     }   }

4.2 测试结果

?

1 2 3 4 5 6

topic name 是topic://guo_topic，发布消息内容为:    Hello T-To-Top-Topi-Topic! TopicMessageListener   Hello T-To-Top-Topi-Topic! 向队列queue://queue2发送了消息------------Hello China~~~~~~~~~~~~~~~ ConsumerMessageListener收到了文本消息： Hello China~~~~~~~~~~~~~~~ 向队列queue://queue1发送了消息------------Hello world! 从队列queue://queue1收到了消息： Hello world!

5.代码地址

http://pan.baidu.com/s/1gdvPpWf

ActiveMQ技术学习 https://www.itkc8.com