JMS学习十（Spring+ActiveMQ同步、异步）

通过前面的九篇我们了解了JMS(ActiveMQ)，接下来这篇文章我们来看看spring中使用ActiveMQ,但通过资料，demo的查找以及整合实例的使用个人感觉spring和activemq整合使用确实不是很好，很方便！

spring中使用activemq我们从如下几个步骤来学习：

1、spring+activemq的同步消息接收（queue+topic）

2、spring+activemq的异步消息接收（queue+topic）

3、spring+activemq消息的持久化订阅（topic）

4、spring+activemq消息的持久化（queue+topic）

5、spring+activemq集群配置（queue+topic）

这篇文章中先学习1、2（为了简单期间，只使用了spring没有springmvc部分，项目是maven格式）

一、spring+activemq的同步消息接收

1、项目结构

项目使用maven的，还有控制层是没用的，直接现在service层main启动，还有其中的ApplicationContext1、2、3同步接收、异步接收和持久化的配置。

2、maven中添加的依赖包即pom.xml中添加依赖包：

[html]  view plain  copy

1. <dependency>  
2.             <groupId>junit</groupId>  
3.             <artifactId>junit</artifactId>  
4.             <version>3.8.1</version>  
5.             <scope>test</scope>  
6.         </dependency>  
7.         <dependency>  
8.             <groupId>org.springframework</groupId>  
9.             <artifactId>spring-core</artifactId>  
10.             <version>4.0.0.RELEASE</version>  
11.         </dependency>  
12.         <dependency>  
13.             <groupId>org.springframework</groupId>  
14.             <artifactId>spring-webmvc</artifactId>  
15.             <version>4.0.0.RELEASE</version>  
16.         </dependency>  
17.         <dependency>  
18.             <groupId>org.springframework</groupId>  
19.             <artifactId>spring-tx</artifactId>  
20.             <version>4.0.0.RELEASE</version>  
21.         </dependency>  
22.         <dependency>  
23.             <groupId>org.springframework</groupId>  
24.             <artifactId>spring-test</artifactId>  
25.             <version>4.0.0.RELEASE</version>  
26.         </dependency>  
27.         <dependency>  
28.             <groupId>org.aspectj</groupId>  
29.             <artifactId>aspectjweaver</artifactId>  
30.             <version>1.8.6</version>  
31.         </dependency>  
32.         <!--ActiveMQ所需要的jar包 -->  
33.         <!-- 添加ActiveMQ的pool包 -->  
34.         <dependency>  
35.             <groupId>org.apache.activemq</groupId>  
36.             <artifactId>activemq-pool</artifactId>  
37.             <version>5.9.0</version>  
38.         </dependency>  
39.         <dependency>  
40.             <groupId>org.apache.activemq</groupId>  
41.             <artifactId>activemq-all</artifactId>  
42.             <version>5.9.0</version>  
43.         </dependency>  
44.         <!--依赖包 -->  
45.         <dependency>  
46.             <groupId>org.springframework</groupId>  
47.             <artifactId>spring-jms</artifactId>  
48.             <version>4.0.0.RELEASE</version>  
49.         </dependency>  
50.         <dependency>  
51.             <groupId>org.springframework</groupId>  
52.             <artifactId>spring-messaging</artifactId>  
53.             <version>4.0.0.RELEASE</version>  
54.         </dependency>  

3、ActiveMQ在spring中的配置即ApplicationContext.xml中配置Activemq

[html]  view plain  copy

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:tx="http://www.springframework.org/schema/tx"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.                   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
8.                   http://www.springframework.org/schema/context  
9.                   http://www.springframework.org/schema/context/spring-context-3.2.xsd  
10.                   http://www.springframework.org/schema/aop   
11.                   http://www.springframework.org/schema/aop/spring-aop.xsd        
12.                   http://www.springframework.org/schema/task  
13.                  http://www.springframework.org/schema/task/spring-task-3.2.xsd  
14.                  http://www.springframework.org/schema/tx   
15.                  http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
16.   
17.     <!--ActiveMQ相关配置 -->  
18.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
19.         destroy-method="stop">  
20.         <property name="connectionFactory">  
21.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
22.                 <!--消息服务连接信息 -->  
23.                 <property name="brokerURL">  
24.                     <value>tcp://127.0.0.1:61616</value>  
25.                 </property>  
26.                 <property name="userName">  
27.                     <value>admin</value>  
28.                 </property>  
29.                 <property name="password">  
30.                     <value>admin</value>  
31.                 </property>  
32.             </bean>  
33.         </property>  
34.         <!--最大连接数，因为上面是使用了pool -->  
35.         <property name="maxConnections" value="100"></property>  
36.     </bean>  
37.     <!-- queue目的地配置 -->  
38.     <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
39.         <constructor-arg index="0" value="spring-queue" />  //value为该队列的名字
40.     </bean>  
41.     <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
42.     <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">  
43.         <constructor-arg index="0" value="spring-topic" />  
44.     </bean>  
45.   
46.     <!-- spring 使用jmsTemplate来实现消息的发送和接受 -->  
47.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
48.         <property name="connectionFactory" ref="jmsFactory"></property>  
49.         <!--目的地的设置，使用spring来使用activemq时，使用queue还是topic很方便，在这里引用不同地址就ok了 -->  
50.         <property name="defaultDestination" ref="destination"></property>  
51.         <!--转换器，我们自己可以继承重写这个类的方法 ，这里使用spring提供的默认方法 -->  
52.         <property name="messageConverter">  
53.             <bean  
54.                 class="org.springframework.jms.support.converter.SimpleMessageConverter" />  
55.         </property>  
56.     </bean>  
57. </beans>  

4、消息生产者：

[java]  view plain  copy

1. package springs.activemq.Service;  
2.   
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.Session;  
6. import javax.jms.TextMessage;  
7.   
8. import org.springframework.context.ApplicationContext;  
9. import org.springframework.context.support.ClassPathXmlApplicationContext;  
10. import org.springframework.jms.core.JmsTemplate;  
11. import org.springframework.jms.core.MessageCreator;  
12.   
13. public class QueueProducer {  
14.     // 负责消息的发送和接收可以理解为MessageProducer 和MessageConsummer的组合。  
15.     private static JmsTemplate jt = null;  
16.   
17.     public static void main(String[] args) {  
18.         ApplicationContext ctx = new ClassPathXmlApplicationContext(  
19.                 "config/ApplicationContext.xml");  
20.         // 获取JmsTemplate对象  
21.         jt = (JmsTemplate) ctx.getBean("jmsTemplate");  
22.         // 调用方法，发送消息  
23.         jt.send(new MessageCreator() {  
24.             // 消息的产生，返回消息发送消息  
25.             public Message createMessage(Session s) throws JMSException {  
26.                 TextMessage msg = s  
27.                         .createTextMessage("Spring send msg ----> Hello activeMQ5");  
28.                 return msg;  
29.             }  
30.         });  
31.         System.out.println("end!");  
32.     }  
33. }  

5、消息消费者：

[java]  view plain  copy

1. package springs.activemq.Service;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5. import org.springframework.jms.core.JmsTemplate;  
6.   
7. public class QueueConsumer {  
8.     private static JmsTemplate jt = null;  
9.   
10.     public static void main(String[] args) {  
11.         ApplicationContext ctx = new ClassPathXmlApplicationContext(  
12.                 "config/ApplicationContext.xml");  
13.         //获取JmsTemplate对象  
14.         jt = (JmsTemplate) ctx.getBean("jmsTemplate");  
15.         //接收消息  
16.         String msg = (String) jt.receiveAndConvert();  
17.         System.out.println("receive msg = " + msg);  
18.     }  
19. }  

6、执行结果：

ok这样一个简单的spring+actvemq整合demo就完成了！

总结流程：

1、在pom.xml中添加依赖的jar包

2、将activemq相关的配置配置到配置文件中，为了更简单明了的说明白，这里只使用了spring，所以你也看到了activemq相关的配置，以后不管用到什么项目中则直接把这些拷过去即ok了！

3、消息生产者即定义消息，发送消息！

4、消息消费者，接收消息，处理消息、回复确认！

就这样ok了……

上面的这个列子是我们使用了queue那我们要使用topic怎么办，看上面的配置，主需要将jmsTemplate中目的地的引用改为定义的topic的引用就ok了配置如下：

[html]  view plain  copy

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:tx="http://www.springframework.org/schema/tx"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.                   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
8.                   http://www.springframework.org/schema/context  
9.                   http://www.springframework.org/schema/context/spring-context-3.2.xsd  
10.                   http://www.springframework.org/schema/aop   
11.                   http://www.springframework.org/schema/aop/spring-aop.xsd        
12.                   http://www.springframework.org/schema/task  
13.                  http://www.springframework.org/schema/task/spring-task-3.2.xsd  
14.                  http://www.springframework.org/schema/tx   
15.                  http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
16.   
17.     <!--ActiveMQ相关配置 -->  
18.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
19.         destroy-method="stop">  
20.         <property name="connectionFactory">  
21.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
22.                 <!--消息服务连接信息 -->  
23.                 <property name="brokerURL">  
24.                     <value>tcp://127.0.0.1:61616</value>  
25.                 </property>  
26.                 <property name="userName">  
27.                     <value>admin</value>  
28.                 </property>  
29.                 <property name="password">  
30.                     <value>admin</value>  
31.                 </property>  
32.             </bean>  
33.         </property>  
34.         <!--最大连接数，因为上面是使用了pool -->  
35.         <property name="maxConnections" value="100"></property>  
36.     </bean>  
37.     <!-- queue目的地配置 -->  
38.     <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
39.         <constructor-arg index="0" value="spring-queue" />  
40.     </bean>  
41.     <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
42.     <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">  
43.         <constructor-arg index="0" value="spring-topic" />  
44.     </bean>  
45.   
46.     <!-- spring 使用jmsTemplate来实现消息的发送和接受 -->  
47.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
48.         <property name="connectionFactory" ref="jmsFactory"></property>  
49.         <!--目的地的设置，使用spring来使用activemq时，使用queue还是topic很方便，在这里引用不同地址就ok了 -->  
50.         <property name="defaultDestination" ref="destinationTopic"></property>  
51.         <!--转换器，我们自己可以继承重写这个类的方法 ，这里使用spring提供的默认方法 -->  
52.         <property name="messageConverter">  
53.             <bean  
54.                 class="org.springframework.jms.support.converter.SimpleMessageConverter" />  
55.         </property>  
56.     </bean>  
57. </beans>  

发现没其实只修改了jmsTemplate中的引用其他的什么都不用改。

这样我们spring+activemq的queue 和topic的同步接收都好了，下面来看看异步接收：

二、spring+activemq的异步消息接收

上面的那种整合方式和直接使用ActiveMQ编写的时候使用receive（）方法接收消息一样，是同步接收，但是我们应该更喜欢异步的，下面来看看其实也很简单！

需要的jar包都一样的没有什么不同，项目结构也是一样的！

1、spring+activemq配置文件：

[html]  view plain  copy

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:tx="http://www.springframework.org/schema/tx"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.                   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
8.                   http://www.springframework.org/schema/context  
9.                   http://www.springframework.org/schema/context/spring-context-3.2.xsd  
10.                   http://www.springframework.org/schema/aop   
11.                   http://www.springframework.org/schema/aop/spring-aop.xsd        
12.                   http://www.springframework.org/schema/task  
13.                  http://www.springframework.org/schema/task/spring-task-3.2.xsd  
14.                  http://www.springframework.org/schema/tx   
15.                  http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
16.   
17.     <!--ActiveMQ相关配置 -->  
18.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
19.         destroy-method="stop">  
20.         <property name="connectionFactory">  
21.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
22.                 <!--消息服务连接信息 -->  
23.                 <property name="brokerURL">  
24.                     <value>tcp://127.0.0.1:61616</value>  
25.                 </property>  
26.                 <property name="userName">  
27.                     <value>admin</value>  
28.                 </property>  
29.                 <property name="password">  
30.                     <value>admin</value>  
31.                 </property>  
32.             </bean>  
33.         </property>  
34.         <!--最大连接数，因为上面是使用了pool -->  
35.         <property name="maxConnections" value="100"></property>  
36.     </bean>  
37.     <!-- queue目的地配置 -->  
38.     <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
39.         <constructor-arg index="0" value="spring-queue" />  
40.     </bean>  
41.     <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
42.     <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">  
43.         <constructor-arg index="0" value="spring-topic" />  
44.     </bean>  
45.   
46.     <!-- spring 使用jmsTemplate来实现消息的发送和接受 -->  
47.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
48.         <property name="connectionFactory" ref="jmsFactory"></property>  
49.         <!--目的地的设置，使用spring来使用activemq时，使用queue还是topic很方便，在这里引用不同地址就ok了 -->  
50.         <property name="defaultDestination" ref="destination"></property>  
51.         <!--转换器，我们自己可以继承重写这个类的方法 ，这里使用spring提供的默认方法 -->  
52.         <property name="messageConverter">  
53.             <bean  
54.                 class="org.springframework.jms.support.converter.SimpleMessageConverter" />  
55.         </property>  
56.     </bean>  
57.     <!--异步监听 -->  
58.     <bean id="myMessageListener" class="springs.activemq.Service.MyMessageListener">  
59.     </bean>  
60.     <bean id="jmsContainer"  
61.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
62.         <property name="connectionFactory" ref="jmsFactory" />  
63.         <property name="destination" ref="destination" />  
64.         <property name="messageListener" ref="myMessageListener" />  
65.     </bean>  
66. </beans>  

发现没，这个配置文件和上面的不一样，就是添加了异步监听即一个监听类和一个jmsContainer类！

2、消息生产者：

[java]  view plain  copy

1. package springs.activemq.Service;  
2.   
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.Session;  
6. import javax.jms.TextMessage;  
7.   
8. import org.springframework.context.ApplicationContext;  
9. import org.springframework.context.support.ClassPathXmlApplicationContext;  
10. import org.springframework.jms.core.JmsTemplate;  
11. import org.springframework.jms.core.MessageCreator;  
12.   
13. public class QueueProducer {  
14.     // 负责消息的发送和接收可以理解为MessageProducer 和MessageConsummer的组合。  
15.     private static JmsTemplate jt = null;  
16.   
17.     public static void main(String[] args) {  
18.         ApplicationContext ctx = new ClassPathXmlApplicationContext(  
19.                 "config/ApplicationContext.xml");  
20.         // 获取JmsTemplate对象  
21.         jt = (JmsTemplate) ctx.getBean("jmsTemplate");  
22.         // 调用方法，发送消息  
23.         jt.send(new MessageCreator() {  
24.             // 消息的产生，返回消息发送消息  
25.             public Message createMessage(Session s) throws JMSException {  
26.                 TextMessage msg = s  
27.                         .createTextMessage("Spring send msg ----> Hello activeMQ4");  
28.                 return msg;  
29.             }  
30.         });  
31.         System.out.println("end!");  
32.     }  
33. }  

3、消息消费者：

这里的消息消费者和之前同步方式不一样，这里的消息是在MessageListener类onMessage方法中处理，那消息是怎么监听的那，这个我们已经在配置文件中配置了。

[java]  view plain  copy

1. package springs.activemq.Service;  
2.   
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.MessageListener;  
6. import javax.jms.TextMessage;  
7.   
8. public class MyMessageListener implements MessageListener {  
9.     public void onMessage(Message arg0) {  
10.         // TODO Auto-generated method stub  
11.         try {  
12.             String message = ((TextMessage) arg0).getText();  
13.             System.out.println("textmessage:" + message);  
14.         } catch (JMSException e) {  
15.             // TODO Auto-generated catch block  
16.             e.printStackTrace();  
17.         }  
18.     }  
19.   
20. }  

发现没，这个和我们之前的例子的异步监听的监听类是一样的，在这里spring已经给我们留了入口，我们只需要写这个监听类，并把它给消息接收类，当有消息的时候我们就能得知，不用向之前的一样自己写消息接收类了！

上面的配置是对queue队列的，其实topic的也很简单，就是修改目的地就ok了，但是要注意这里要修改两处：

Topic的异步监听配置文件：

[html]  view plain  copy

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:tx="http://www.springframework.org/schema/tx"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.                   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
8.                   http://www.springframework.org/schema/context  
9.                   http://www.springframework.org/schema/context/spring-context-3.2.xsd  
10.                   http://www.springframework.org/schema/aop   
11.                   http://www.springframework.org/schema/aop/spring-aop.xsd        
12.                   http://www.springframework.org/schema/task  
13.                  http://www.springframework.org/schema/task/spring-task-3.2.xsd  
14.                  http://www.springframework.org/schema/tx   
15.                  http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
16.   
17.     <!--ActiveMQ相关配置 -->  
18.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
19.         destroy-method="stop">  
20.         <property name="connectionFactory">  
21.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
22.                 <!--消息服务连接信息 -->  
23.                 <property name="brokerURL">  
24.                     <value>tcp://127.0.0.1:61616</value>  
25.                 </property>  
26.                 <property name="userName">  
27.                     <value>admin</value>  
28.                 </property>  
29.                 <property name="password">  
30.                     <value>admin</value>  
31.                 </property>  
32.             </bean>  
33.         </property>  
34.         <!--最大连接数，因为上面是使用了pool -->  
35.         <property name="maxConnections" value="100"></property>  
36.     </bean>  
37.     <!-- queue目的地配置 -->  
38.     <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
39.         <constructor-arg index="0" value="spring-queue" />  
40.     </bean>  
41.     <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
42.     <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">  
43.         <constructor-arg index="0" value="spring-topic" />  
44.     </bean>  
45.   
46.     <!-- spring 使用jmsTemplate来实现消息的发送和接受 -->  
47.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
48.         <property name="connectionFactory" ref="jmsFactory"></property>  
49.         <!--目的地的设置，使用spring来使用activemq时，使用queue还是topic很方便，在这里引用不同地址就ok了 -->  
50.         <property name="defaultDestination" ref="destinationTopic"></property>  
51.         <!--转换器，我们自己可以继承重写这个类的方法 ，这里使用spring提供的默认方法 -->  
52.         <property name="messageConverter">  
53.             <bean  
54.                 class="org.springframework.jms.support.converter.SimpleMessageConverter" />  
55.         </property>  
56.     </bean>  
57.     <!--异步监听 -->  
58.     <bean id="myMessageListener" class="springs.activemq.Service.MyMessageListener">  
59.     </bean>  
60.     <bean id="jmsContainer"  
61.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
62.         <property name="connectionFactory" ref="jmsFactory" />  
63.         <property name="destination" ref="destinationTopic" />  
64.         <property name="messageListener" ref="myMessageListener" />  
65.     </bean>  
66. </beans>  

消息生产者和消息消费者的配置都是一样的没什么变化！

除了上面的配置，下面还有一种配置方式，这种配置方式相比上面的分开了一步步的配置，比较清晰，配置如下：

[html]  view plain  copy

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:tx="http://www.springframework.org/schema/tx"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.                   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
8.                   http://www.springframework.org/schema/context  
9.                   http://www.springframework.org/schema/context/spring-context-3.2.xsd  
10.                   http://www.springframework.org/schema/aop   
11.                   http://www.springframework.org/schema/aop/spring-aop.xsd        
12.                   http://www.springframework.org/schema/task  
13.                  http://www.springframework.org/schema/task/spring-task-3.2.xsd  
14.                  http://www.springframework.org/schema/tx   
15.                  http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
16.   
17.   
18.     <!--第三方工厂,也是具体实现连接的 -->  
19.     <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
20.         <property name="brokerURL" value="tcp://127.0.0.1:61616" />  
21.         <property name="userName" value="admin"></property>  
22.         <property name="password" value="admin"></property>  
23.     </bean>  
24.     <!-- ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory   
25.         可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗,要依赖于 activemq-pool包 -->  
26.     <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">  
27.         <property name="connectionFactory" ref="targetConnectionFactory" />  
28.         <property name="maxConnections" value="100" />  
29.     </bean>  
30.   
31.     <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
32.     <bean id="connectionFactory"  
33.         class="org.springframework.jms.connection.SingleConnectionFactory">  
34.         <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
35.         <property name="targetConnectionFactory" ref="pooledConnectionFactory" />  
36.     </bean>  
37.   
38.     <!-- queue目的地配置 -->  
39.     <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
40.         <constructor-arg index="0" value="spring-queue" />  
41.     </bean>  
42.     <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
43.     <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">  
44.         <constructor-arg index="0" value="spring-topic" />  
45.     </bean>  
46.   
47.     <!-- spring 使用jmsTemplate来实现消息的发送和接受 -->  
48.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
49.         <property name="connectionFactory" ref="connectionFactory"></property>  
50.         <property name="defaultDestination" ref="destination"></property>  
51.         <property name="messageConverter">  
52.             <bean  
53.                 class="org.springframework.jms.support.converter.SimpleMessageConverter" />  
54.         </property>  
55.     </bean>  
56.     <!--异步监听 -->  
57.     <bean id="myMessageListener" class="springs.activemq.Service.MyMessageListener">  
58.     </bean>  
59.     <bean id="jmsContainer"  
60.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
61.         <property name="connectionFactory" ref="connectionFactory" />  
62.         <property name="destination" ref="destination" />  
63.         <property name="messageListener" ref="myMessageListener" />  
64.     </bean>  
65. </beans>  

ok 这样queue的同步，异步接收都ok了，下一篇我们看看topic的持久化订阅！

项目源码下载：点击打开链接

引用地址：https://blog.csdn.net/qh_java/article/details/61932295