JMS与MQ详解（有项目）

《一》m2mGW项目

1.ActiveMQ概述

    企业消息软件从80年代起就存在，它不只是一种应用间消息传递风格，也是一种集成风格。因此，消息传递可以满足应用间的通知和互相操作。但是开源的解决方案是到最近10年才出现的。Apache ActiveMQ就是其中一种。它使应用间能以异步，松耦合方式交流。ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。

‍   ActiveMQ是Apache软件基金下的一个开源软件，它遵循JMS规范（JavaMessage Service），是消息驱动中间件软件（MOM）。它为企业消息传递提供高可用，出色性能，可扩展，稳定和安全保障。ActiveMQ使用Apache许可协议。因此，任何人都可以使用和修改它而不必反馈任何改变。这对于商业上将ActiveMQ用在重要用途的人尤为关键。MOM的工作是在分布式的各应用之间调度事件和消息，使之到达指定的接收者。所以高可用，高性能，高可扩展性尤为关键。

2.ActiveMQ特性

⒈支持多种语言客户端,如:Java,C,C++,C#,Ruby,Perl,Python,PHP。应用协议有 OpenWire,Stomp REST,WS Notification,XMPP,AMQP。

⒉ 完全支持JMS1.1和J2EE1.4规范,它们包括同步和异步消息传递，一次和只有一次的消息传递，对于预订者的持久消息等等。依附于JMS规范意味着，不论JMS消息提供者是谁，同样的基本特性（持久化，XA消息，事务)都是有效的。

⒊ 对spring的支持，ActiveMQ可以很容易内嵌到使用Spring的系统里面去。

⒋ 通过了常见J2EE服务器（如 Geronimo,JBoss 4,GlassFish,WebLogic)的测试，其中通过JCA 1.5 resource adaptors的配置，可以让ActiveMQ可以自动的部署到任何兼容J2EE 1.4 商业服务器上。

⒌ ActiveMQ提供各种连接选择，包括HTTP，HTTPS，IP多点传送，SSL，STOMP，TCP，UDP，XMPP等。大量的连接协议支持使之具有更好的灵活性。很多现有的系统使用一种特定协议并且不能改变，所以一个支持多种协议的消息平台降低了使用的门槛。虽然连接很重要，但是和其他容器集成也同样重要。

6.ActiveMQ提供多种持久性方案可供选择，也可以完全按自己需求定制验证和授权。例如，ActiveMQ通过KahaDB提供自己的超快速消息持久方案（ultra-fast message persistence），但也支持标准的JDBC方案。ActiveMQ可以通过配置文件提供简单的验证和授权，也提供标准的JAAS登陆模块。

7.ActiveMQ是为开发者设计的。它并不需要专门的管理工具，因为它提供各种易用且强大的管理特性。有很多方法去监控ActiveMQ的各个方面，可以通过JMX使用JConsole或ActiveMQ web console；可以运行ActiveMQ消息报告；可以用命令行脚本；可以通过日志。

8.代理器集群（Broker clustering）----为了利于扩展，多个ActiveMQ broker能够联合工作。这个方式就是network of brokers并且能支持多种拓扑结构;支持客户端-服务器，点对点。

9.支持Ajax, 支持与Axis的整合

3.ActiveMQ优势

1.与OpenJMS、JbossMQ等开源jms provider相比，ActiveMQ有Apache的支持，持续发展的优势明显。

2.速度很快，JBossMQ的十倍(没有测试)

3.提高系统资源的利用率，主要是任务的派发不是24小时平均的，而是高峰时期任务量很多，比如1秒1000多个，有的时候很低，比如十几秒钟才来一个。应用服务通过JMS队列一个一个的取任务，做完一个再领一个，使系统资源的运用趋于平均。而JMS，比如JMS接收消息的效率是很高的，比如ActiveMQ，在赛扬（2.40GHz）机器上能够达到2000/s，消息大小为1-2k。好一些的服务器可以达到2万以上/秒。

4.ActiveMQ安装

首先去http://activemq.apache.org/download.html 下载最新版本ActiveMQ 5.8.0 Release， 解压apache-activemq-5.8.0-bin.zip(或者apache-activemq-5.8.0-bin.tar.gz)

目录如下：

+bin (windows下面的bat和unix/Linux下面的sh)

+conf (activeMQ配置目录，包含最基本的activeMQ配置文件）

+data （默认是空的）

+docs (只有index.html）

+example （几个例子)

+lib (activemMQ使用到的lib)

+webapps(后台管理页面)

+webapps-demo(后台管理消息发送页面)

+activemq-all-5.8.0.jar (java开发的jar包)

-LICENSE.txt

-NOTICE.txt

-README.txt

-user-guide.html

你可以使用bin\activemq.bat(activemq)启动。

启动ActiveMQ以后，登陆：http://localhost:8161/admin/ 默认用户/密码为admin/admin。

注意:

⒈ 这个仅仅是最基础的ActiveMQ的配置，很多地方都没有配置因此不要直接使用这个配置用于生存环境。

⒉ 有的时候由于端口被占用，导致ActiveMQ错误，ActiveMQ可能需要以下端口1099(JMX),61616（默认的TransportConnector)。

⒊ 如果没有物理网卡，或者MS的LoopBackAdpater Multicast会报一个错误

5.运行附带的示例程序 

1、Queue消息示例：

* 启动Queue消息消费者

cd example

ant consumer

* 启动Queue消息生产者

cd example

ant producer 
     简要说明：生产者（producer）发消息，消费者（consumer）接消息，发送/接收2000个消息后自动关闭

2、Topic消息示例：

* 启动Topic消息消费者

cd example

ant topic-listener

* 启动Topic消息生产者

cd example

ant topic-publisher 
     简要说明：重复10轮，publisher每轮发送2000个消息，并等待获取listener的处理结果报告，然后进入下一轮      发送，最后

统计全局发送时间。

3、Queue消息和Topic消息发送之后，可以通过后台点击Queues和Topics查看发送消息具体信息。

6.ActiveMQ类别及开发流程

1)、Point-to-Point (点对点)消息模式开发流程 ：
       1、生产者（producer）开发流程（ProducerTool.java）：

1.1 创建Connection： 根据url，user和password创建一个jms Connection。

1.2 创建Session： 在connection的基础上创建一个session，同时设置是否支持事务和ACKNOWLEDGE标识。

1.3 创建Destination对象： 需指定其对应的主题（subject）名称，producer和consumer将根据subject来发送/接收对应的消息。

1.4 创建MessageProducer： 根据Destination创建MessageProducer对象，同时设置其持久模式。

1.5 发送消息到队列（Queue）： 封装TextMessage消息，使用MessageProducer的send方法将消息发送出去。

2、消费者（consumer）开发流程（ConsumerTool.java）：

2.1 实现MessageListener接口： 消费者类必须实现MessageListener接口，然后在onMessage()方法中监听消息的到达并处理。

2.2 创建Connection： 根据url，user和password创建一个jms Connection，如果是durable模式，还需要给connection设置一个clientId。

2.3 创建Session和Destination： 与ProducerTool.java中的流程类似，不再赘述。

2.4 创建replyProducer【可选】：可以用来将消息处理结果发送给producer。

2.5 创建MessageConsumer：  根据Destination创建MessageConsumer对象。

2.6 消费message：  在onMessage()方法中接收producer发送过来的消息进行处理，并可以通过replyProducer反馈信息给producer

1. if (message.getJMSReplyTo() != null) {
2. replyProducer.send(message.getJMSReplyTo(),
3. session.createTextMessage("Reply: " + message.getJMSMessageID()));

2)、Publisher/Subscriber(发布/订阅者)消息模式开发流程

1、订阅者（Subscriber）开发流程（TopicListener.java）：

1.1 实现MessageListener接口： 在onMessage()方法中监听发布者发出的消息队列，并做相应处理。

1.2 创建Connection： 根据url，user和password创建一个jms Connection。

1.3 创建Session： 在connection的基础上创建一个session，同时设置是否支持事务和ACKNOWLEDGE标识。

1.4 创建Topic：  创建2个Topic， topictest.messages用于接收发布者发出的消息，topictest.control 用于向发布者发送消息，实现双方的交互。

1.5 创建consumer和producer对象：根据topictest.messages创建consumer，根据topictest.control创建 producer。

1.6 接收处理消息：在onMessage()方法中，对收到的消息进行处理，可直接简单在本地显示消息，或者根 据消息内容不同处理对应的业务逻辑（比如：数据库更新、文件操作等等），并且可以使用producer对象将处理结果返回给发布者。

2、发布者（Publisher）开发流程（TopicPublisher.java）：

2.1 实现MessageListener接口：在onMessage()方法中接收订阅者的反馈消息。

2.2 创建Connection： 根据url，user和password创建一个jms Connection。

2.3 创建Session： 在connection的基础上创建一个session，同时设置是否支持事务和ACKNOWLEDGE标识。

2.4 创建Topic： 创建2个Topic，topictest.messages用于向订阅者发布消息，topictest.control用于接 收订阅者反馈的消息。这2个topic与订阅者开发流程中的topic是一一对应的。

2.5 创建consumer和producer对象： 根据topictest.messages创建publisher； 根据topictest.control 创建consumer，同时监听订阅者反馈的消息。

2.6 给所有订阅者发送消息，并接收反馈消息：  示例代码中，一共重复10轮操作。 每轮先向所有订阅者 发送2000个消息； 然后堵塞线程，开始等待； 最后通过onMessage()方法，接收到订阅者反馈的“REPORT”类信息后，才print反馈信息并解除线程堵塞，进入下一轮。 
             注：可同时运行多个订阅者测试查看此模式效果

7.Eclipse代码开发

1.建立一个Web Probject 项目,将activemq-all-5.8.0.jar放在lib里面

2.Queue（点对点）方式：生产者

1. package jms;
2. import javax.jms.Connection;
3. import javax.jms.ConnectionFactory;
4. import javax.jms.DeliveryMode;
5. import javax.jms.Destination;
6. import javax.jms.MessageProducer;
7. import javax.jms.Queue;
8. import javax.jms.Session;
9. import javax.jms.TextMessage;
10. import org.apache.activemq.ActiveMQConnection;
11. import org.apache.activemq.ActiveMQConnectionFactory;
12. //Queue（点对点）方式  生存者Producer
13. public class QueueProducer {
14. private static String user = ActiveMQConnection.DEFAULT_USER;
15. private static String password =ActiveMQConnection.DEFAULT_PASSWORD;
16. private static String url =  "tcp://localhost:61616";
17. public static void main(String[] args)throws Exception {
18. // ConnectionFactory ：连接工厂，JMS 用它创建连接
19. ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(user,password,url);
20. // Connection ：JMS 客户端到JMS Provider 的连接
21. Connection connection = connectionFactory.createConnection();
22. // Connection 启动
23. connection.start();
24. System.out.println("Connection is start...");
25. // Session： 一个发送或接收消息的线程
26. Session session = connection.createSession(Boolean.TRUE,Session.AUTO_ACKNOWLEDGE);
27. // Queue ：消息的目的地;消息发送给谁.
28. Queue  destination = session.createQueue("example.A");
29. // MessageProducer：消息发送者
30. MessageProducer producer = session.createProducer(destination);
31. // 设置不持久化，此处学习，实际根据项目决定
32. producer.setDeliveryMode(DeliveryMode.PERSISTENT);
33. // 构造消息，此处写死，项目就是参数，或者方法获取
34. sendMessage(session, producer);
35. session.commit();
36. connection.close();
37. System.out.println("send text ok.");
38. }
39. public static void sendMessage(Session session, MessageProducer producer)
40. throws Exception {
41. for (int i = 1; i <= 100; i++) {//有限制,达到1000就不行
42. TextMessage message = session.createTextMessage("ActiveMq 发送的消息" + i);
43. // 发送消息到目的地方
44. System.out.println("发送消息：" + "ActiveMq 发送的消息" + i);
45. producer.send(message);
46. }
47. }
48. }

3.Queue（点对点）方式：消费者

1. package jms;
2. import javax.jms.Connection;
3. import javax.jms.ConnectionFactory;
4. import javax.jms.Destination;
5. import javax.jms.JMSException;
6. import javax.jms.Message;
7. import javax.jms.MessageConsumer;
8. import javax.jms.MessageListener;
9. import javax.jms.Queue;
10. import javax.jms.Session;
11. import javax.jms.TextMessage;
12. import org.apache.activemq.ActiveMQConnection;
13. import org.apache.activemq.ActiveMQConnectionFactory;
14. //Queue（点对点）方式  消费这Consumer
15. public class QueueConsumer {
16. private static String user = ActiveMQConnection.DEFAULT_USER;
17. private static String password =ActiveMQConnection.DEFAULT_PASSWORD;
18. private static String url = "tcp://localhost:61616";
19. public static void main(String[] args) throws Exception{
20. // ConnectionFactory ：连接工厂，JMS 用它创建连接
21. ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(user,password,url);
22. // Connection ：JMS 客户端到JMS Provider 的连接
23. Connection connection = connectionFactory.createConnection();
24. connection.start();
25. // Session： 一个发送或接收消息的线程
26. final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
27. // Destination ：消息的目的地;消息发送给谁.
28. Queue destination=session.createQueue("example.A");
29. // 消费者，消息接收者
30. MessageConsumer consumer = session.createConsumer(destination);
31. consumer.setMessageListener(new MessageListener(){//有事务限制
32. @Override
33. public void onMessage(Message message) {
34. try {
35. TextMessage textMessage=(TextMessage)message;
36. System.out.println(textMessage.getText());
37. } catch (JMSException e1) {
38. e1.printStackTrace();
39. }
40. try {
41. session.commit();
42. } catch (JMSException e) {
43. e.printStackTrace();
44. }
45. }
46. });
47. /*  另外一种接受方式
48. *    while (true) {
49. //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
50. TextMessage message = (TextMessage) consumer.receive(100000);
51. if (null != message) {
52. System.out.println("收到消息" + message.getText());
53. } else {
54. break;
55. }
56. }*/
57. }
58. }

4.Topic（发布/订阅）方式：发布者

1. package jms;
2. import java.util.Date;
3. import javax.jms.Connection;
4. import javax.jms.ConnectionFactory;
5. import javax.jms.DeliveryMode;
6. import javax.jms.JMSException;
7. import javax.jms.MapMessage;
8. import javax.jms.MessageProducer;
9. import javax.jms.Queue;
10. import javax.jms.Session;
11. import javax.jms.TextMessage;
12. import javax.jms.Topic;
13. import org.apache.activemq.ActiveMQConnection;
14. import org.apache.activemq.ActiveMQConnectionFactory;
15. //Topic（发布/订阅）方式  发布者Publisher
16. public class TopicPublisher {
17. private static String user = ActiveMQConnection.DEFAULT_USER;
18. private static String password =ActiveMQConnection.DEFAULT_PASSWORD;
19. private static String url =  "tcp://localhost:61616";
20. public static void main(String[] args)throws Exception {
21. // ConnectionFactory ：连接工厂，JMS 用它创建连接
22. ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(user,password,url);
23. // Connection ：JMS 客户端到JMS Provider 的连接
24. Connection connection = connectionFactory.createConnection();
25. // Connection 启动
26. connection.start();
27. System.out.println("Connection is start...");
28. // Session： 一个发送或接收消息的线程
29. Session session = connection.createSession(Boolean.TRUE,Session.AUTO_ACKNOWLEDGE);
30. // Topicr ：消息的目的地;消息发送给谁.
31. Topic  destination = session.createTopic("example.A");
32. // MessageProducer：消息发送者
33. MessageProducer producer = session.createProducer(destination);
34. // 设置不持久化，此处学习，实际根据项目决定
35. producer.setDeliveryMode(DeliveryMode.PERSISTENT);
36. // 构造消息，此处写死，项目就是参数，或者方法获取
37. sendMessage(session, producer);
38. session.commit();
39. connection.close();
40. System.out.println("send text ok.");
41. }
42. public static void sendMessage(Session session, MessageProducer producer)
43. throws Exception {
44. for (int i = 1; i <= 100; i++) {//有限制,达到1000就不行
45. TextMessage message = session.createTextMessage("ActiveMq 发送的消息" + i);
46. // 发送消息到目的地方
47. System.out.println("发送消息：" + "ActiveMq 发送的消息" + i);
48. producer.send(message);
49. }
50. }
51. }

5.Topic（发布/订阅）方式：订阅者

1. package jms;
2. import javax.jms.Connection;
3. import javax.jms.ConnectionFactory;
4. import javax.jms.JMSException;
5. import javax.jms.Message;
6. import javax.jms.MessageConsumer;
7. import javax.jms.MessageListener;
8. import javax.jms.Session;
9. import javax.jms.TextMessage;
10. import javax.jms.Topic;
11. import org.apache.activemq.ActiveMQConnection;
12. import org.apache.activemq.ActiveMQConnectionFactory;
13. //Topic（发布/订阅）方式  订阅者TopicSubscriber
14. public class TopicSubscriber {
15. private static String user = ActiveMQConnection.DEFAULT_USER;
16. private static String password =ActiveMQConnection.DEFAULT_PASSWORD;
17. private static String url = "tcp://localhost:61616";
18. public static void main(String[] args) throws Exception{
19. // ConnectionFactory ：连接工厂，JMS 用它创建连接
20. ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(user,password,url);
21. // Connection ：JMS 客户端到JMS Provider 的连接
22. Connection connection = connectionFactory.createConnection();
23. connection.start();
24. // Session： 一个发送或接收消息的线程
25. final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
26. // Destination ：消息的目的地;消息发送给谁.
27. Topic destination=session.createTopic("example.A");
28. // 消费者，消息接收者
29. MessageConsumer consumer = session.createConsumer(destination);
30. consumer.setMessageListener(new MessageListener(){//有事务限制
31. @Override
32. public void onMessage(Message message) {
33. try {
34. TextMessage textMessage=(TextMessage)message;
35. System.out.println(textMessage.getText());
36. } catch (JMSException e1) {
37. e1.printStackTrace();
38. }
39. try {
40. session.commit();
41. } catch (JMSException e) {
42. e.printStackTrace();
43. }
44. }
45. });
46. /*  另外一种接受方式
47. *    while (true) {
48. //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
49. TextMessage message = (TextMessage) consumer.receive(100000);
50. if (null != message) {
51. System.out.println("收到消息" + message.getText());
52. } else {
53. break;
54. }
55. }*/
56. }
57. }

Queue（点对点）方式和Topic（发布/订阅）方式 的运行结果最明显的区别是：在Queue（点对点）方式中先运行生产者,再运行消费者,消费者还能接受到消息；

而Topic（发布/订阅）方式就不同了，先运行发布者，再运行订阅者，订阅者收到的消息

可能没有或者是不完全的。

《二》

在上一章( Java中间件JMS之ActiveMQ入门http://blog.csdn.NET/dengwanchuan/article/details/10241345)说到ActiveMQ能与spring进行整合,ActiveMQ与Spring进行整合有一定的好处,首先是可配置化,然后是能使用Spring的aop,tx等特性进行项目开发.

一.准备工作

我使用的是spring版本是4.0.0.M2，其他版本的也可以，只是配置不同，去Spring官网下载zip包，解开后将dist目录下的所有jar包（根据自己选择）拷贝到项目lib目录下并加入项目项目中的lib中，一般jms所需要的Spring的jar有:

二.代码开发

1.在src目录下新建applicationContext.xml文件并输入一下内容：

1. <?xml version="1.0" encoding="GBK"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans.xsd">
6. </beans>

2.引入spring,打开web.xml并将其内容修改为以下内容：

1. <?xml version="1.0" encoding="GBK"?>
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
6. <context-param>
7. <param-name>contextConfigLocation</param-name>
8. <param-value>classpath*:applicationContext*.xml</param-value>
9. </context-param>
10. <servlet>
11. <servlet-name>spring</servlet-name>
12. <servlet-class>
13. org.springframework.web.servlet.DispatcherServlet
14. </servlet-class>
15. <load-on-startup>1</load-on-startup>
16. </servlet>
17. <servlet-mapping>
18. <servlet-name>spring</servlet-name>
19. <url-pattern>/</url-pattern>
20. </servlet-mapping>
21. <welcome-file-list>
22. <welcome-file>index.jsp</welcome-file>
23. </welcome-file-list>
24. </web-app>

3.配置JMSTemplate模板

类似于jdbcTemplate，首先要配置一个ConnectionFactory，之后要开始配置JmsTemplate模板了。最后是配置消息目标了。消息分为队列(Queue)和主题(Topic)两大类。在applicationContext.xml中加入如下内容：

1. <!-- 配置JMS连接工厂 -->
2. <bean id="connectionFactory"
3. class="org.apache.activemq.ActiveMQConnectionFactory">
4. <property name="brokerURL" value="tcp://localhost:61616" />
5. </bean>
6. <!-- 发送消息的目的地（队列） -->
7. <bean id="queueDest"
8. class="org.apache.activemq.command.ActiveMQQueue">
9. <!-- 设置消息队列的名字 -->
10. <constructor-arg index="0" value="myQueue" />
11. </bean>
12. <!-- 配置Jms模板  -->
13. <bean id="jmsQueueTemplate"
14. class="org.springframework.jms.core.JmsTemplate">
15. <property name="connectionFactory" ref="connectionFactory" />
16. <property name="defaultDestination" ref="queueDest" />
17. <!--<property name="receiveTimeout" value="10000" />  -->
18. </bean>
19. <!-- 发送消息的目的地（主题） -->
20. <bean id="topicDest"
21. class="org.apache.activemq.command.ActiveMQTopic">
22. <!-- 设置消息队列的名字 -->
23. <constructor-arg index="0" value="myTopic" />
24. </bean>
25. <!-- 配置TopicJms模板  -->
26. <bean id="jmsTopicTemplate"
27. class="org.springframework.jms.core.JmsTemplate">
28. <property name="connectionFactory" ref="connectionFactory" />
29. <property name="defaultDestination" ref="topicDest" />
30. <!-- 配置是否为发布订阅者模式，默认为false -->
31. <property name="pubSubDomain" value="true"/>
32. <!--<property name="receiveTimeout" value="10000" />  -->
33. </bean>

receiveTimeout表示接收消息时的超时时间，设置的为10秒，因为如果不设置的话，加入接收消息时是阻塞着的，那么将一直阻塞下去。配置完成了。但是我不建议设置这个时间,如果到达设置时间之后,生产者没有运行,消费者接受到Message对象为null,测试可能会出现异常，而且消费者将停止接受消息.那么如何使用JmsTemplate发送消息呢?

spring的beanfactory得到一个jmsTemplate的实例和消息目标的实例，发送消息，够简单的吧。首先我们还从queue方式开始。下面我们就来编写具体代码。

4、编写Point-to-Point (点对点)代码

新建生产者类QueueProducerService.java，代码如下：

1. package jms.mq.spring;
2. import java.util.Date;
3. import javax.jms.Destination;
4. import javax.jms.JMSException;
5. import javax.jms.Message;
6. import javax.jms.Session;
7. import javax.jms.TextMessage;
8. import org.springframework.jms.core.JmsTemplate;
9. import org.springframework.jms.core.MessageCreator;
10. public class QueueProducerService{
11. JmsTemplate jmsTemplate;
12. Destination destination;
13. public void send() {
14. MessageCreator messageCreator = new MessageCreator() {
15. public Message createMessage(Session session) throws JMSException {
16. TextMessage message = session.createTextMessage();
17. message.setText("QueueProducerService发送消息"+new Date());
18. return message;
19. }
20. };
21. jmsTemplate.send(this.destination,messageCreator);
22. }
23. public void setJmsTemplate(JmsTemplate jmsTemplate) {
24. this.jmsTemplate = jmsTemplate;
25. }
26. public void setDestination(Destination destination) {
27. this.destination = destination;
28. }
29. }

生产者编写完了，下面我们来编写消费者，上面说了，发送消息的时候，spring的beanfactory得到一个jmsTemplate的实例和消息目标的实例，然后发送，那么接受的时候肯定也是得到一个jmsTemplate的实例和消息目标的实例，然后接受，下面我们来看具体代码。

新建一个消费者类QueueConsumerService.java，具体代码如下：

1. package jms.mq.spring;
2. import javax.jms.Destination;
3. import javax.jms.JMSException;
4. import javax.jms.TextMessage;
5. import org.springframework.jms.core.JmsTemplate;
6. public class QueueConsumerService{
7. JmsTemplate jmsTemplate;
8. Destination destination;
9. public void receive() {
10. TextMessage message = (TextMessage) jmsTemplate.receive();
11. try {
12. System.out.println("QueueConsumerService收到消息："+message.getText());
13. } catch (JMSException e) {
14. e.printStackTrace();
15. }
16. }
17. public void setJmsTemplate(JmsTemplate jmsTemplate) {
18. this.jmsTemplate = jmsTemplate;
19. }
20. public void setDestination(Destination destination) {
21. this.destination = destination;
22. }
23. }

代码编写完毕，下面要进行bean的配置，在applicationContext.xml中加入如下代码实例化对象和依赖注入:

1. <bean id="queueProducerService" class="jms.mq.spring.QueueProducerService">
2. <property name="jmsTemplate" ref="jmsQueueTemplate" />
3. <property name="destination" ref="queueDest" />
4. </bean>
5. <bean id="queueConsumerService" class="jms.mq.spring.QueueConsumerService">
6. <property name="jmsTemplate" ref="jmsQueueTemplate" />
7. <property name="destination" ref="queueDest" />
8. </bean>

需要的业务代码都已编写完毕，下面编写测试代码。新建一个生产者的测试类QueueProducerTest.java。具体代码如下：

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class QueueProducerTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void send() {
7. QueueProducerService producerService = (QueueProducerService) appContext.getBean("queueProducerService");
8. producerService.send();
9. }
10. /**
11. * @param args
12. */
13. public static void main(String[] args) {
14. send();
15. }
16. }

再建一个消费者的测试类，QueueConsumerTest.java，具体代码如下：

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class QueueConsumerTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void receive() {
7. QueueConsumerService consumerService = (QueueConsumerService) appContext.getBean("queueConsumerService");
8. consumerService.receive();
9. }
10. public static void main(String[] args) {
11. receive();
12. }
13. }

5、运行point-point(点对点)程序

所有代码都编写完了，我们来看一下我们的劳动成果。运行生产者测试类。控制台打印出如下内容，画线标注的就是我们发送的内容：

6、编写Publisher/Subscriber(发布/订阅者)代码

新建发布者TopicPublisherService.java，内容如下：

1. package jms.mq.spring;
2. import java.util.Date;
3. import javax.jms.Destination;
4. import javax.jms.JMSException;
5. import javax.jms.MapMessage;
6. import javax.jms.Message;
7. import javax.jms.Session;
8. import javax.jms.TextMessage;
9. import org.springframework.jms.core.JmsTemplate;
10. import org.springframework.jms.core.MessageCreator;
11. import jms.spring.QueueProducerService;
12. public class TopicPublisherService{
13. JmsTemplate jmsTemplate;
14. Destination destination;
15. public void send() {
16. MessageCreator messageCreator = new MessageCreator() {
17. public Message createMessage(Session session) throws JMSException {
18. TextMessage message = session.createTextMessage();
19. message.setText("QueueProducerService发送消息"+new Date());
20. return message;
21. }
22. };
23. jmsTemplate.send(this.destination,messageCreator);
24. }
25. public void setJmsTemplate(JmsTemplate jmsTemplate) {
26. this.jmsTemplate = jmsTemplate;
27. }
28. public void setDestination(Destination destination) {
29. this.destination = destination;
30. }
31. }

再新建一个订阅者TopicSubscriberService.java,代码如下。

1. package jms.mq.spring;
2. import javax.jms.Destination;
3. import javax.jms.JMSException;
4. import javax.jms.TextMessage;
5. import org.springframework.jms.core.JmsTemplate;
6. import jms.spring.QueueConsumerService;
7. public class TopicSubscriberService{
8. JmsTemplate jmsTemplate;
9. Destination destination;
10. public void receive() {
11. TextMessage message = (TextMessage) jmsTemplate.receive();
12. try {
13. System.out.println("QueueConsumerService收到消息："+message.getText());
14. } catch (JMSException e) {
15. e.printStackTrace();
16. }
17. }
18. public void setJmsTemplate(JmsTemplate jmsTemplate) {
19. this.jmsTemplate = jmsTemplate;
20. }
21. public void setDestination(Destination destination) {
22. this.destination = destination;
23. }
24. }

在配置文件中applicationContext.xml增加如下配置：

1. <span style="white-space:pre">  </span><bean id="topicPublisherService" class="jms.mq.spring.TopicPublisherService">
2. <property name="jmsTemplate" ref="jmsTopicTemplate"/>
3. <property name="destination" ref="topicDest"/>
4. </bean>
5. <bean id="topicSubscriberService" class="jms.mq.spring.TopicSubscriberService">
6. <property name="jmsTemplate" ref="jmsTopicTemplate"/>
7. <property name="destination" ref="topicDest"/>
8. </bean>

编写测试程序发布者测试类，TopicPublisherTest.java

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class TopicPublisherTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void send() {
7. TopicPublisherService topicPublisherService = (TopicPublisherService) appContext.getBean("topicPublisherService");
8. topicPublisherService.send();
9. }
10. public static void main(String[] args) {
11. send();
12. }
13. }

编写测试程序订阅者测试类，TopicSubscriberTest.java

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class TopicSubscriberTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void receive() {
7. TopicSubscriberService topicSubscriberService = (TopicSubscriberService) appContext.getBean("topicSubscriberService");
8. topicSubscriberService.receive();
9. }
10. public static void main(String[] args) {
11. receive();
12. }
13. }

7.Publisher/Subscriber(发布/订阅者)程序

先运行订阅者，再运行发布者，可以看到订阅者能打印信息；但是反之就不行，这就是Publisher/Subscriber(发布/订阅者)的特性;

跟Point-Point(点对点)对比的话,不管运行生存者还是消费者，都会打印信息,可以阅读前一章http://blog.csdn.net/dengwanchuan/article/details/10241345了解这两种模式的区别和联系。

附加完整的applicationContext.xml配置文件

1. <?xml version="1.0" encoding="GBK"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans.xsd">
6. <!-- 配置JMS连接工厂 -->
7. <bean id="connectionFactory"
8. class="org.apache.activemq.ActiveMQConnectionFactory">
9. <property name="brokerURL" value="tcp://localhost:61616" />
10. </bean>
11. <!-- 发送消息的目的地（队列） -->
12. <bean id="queueDest"
13. class="org.apache.activemq.command.ActiveMQQueue">
14. <!-- 设置消息队列的名字 -->
15. <constructor-arg index="0" value="myQueue" />
16. </bean>
17. <!-- 配置Jms模板  -->
18. <bean id="jmsQueueTemplate"
19. class="org.springframework.jms.core.JmsTemplate">
20. <property name="connectionFactory" ref="connectionFactory" />
21. <property name="defaultDestination" ref="queueDest" />
22. <!--<property name="receiveTimeout" value="10000" />  -->
23. </bean>
24. <!-- 发送消息的目的地（主题） -->
25. <bean id="topicDest"
26. class="org.apache.activemq.command.ActiveMQTopic">
27. <!-- 设置消息队列的名字 -->
28. <constructor-arg index="0" value="myTopic" />
29. </bean>
30. <!-- 配置TopicJms模板  -->
31. <bean id="jmsTopicTemplate"
32. class="org.springframework.jms.core.JmsTemplate">
33. <property name="connectionFactory" ref="connectionFactory" />
34. <property name="defaultDestination" ref="topicDest" />
35. <!-- 配置是否为发布订阅者模式，默认为false -->
36. <property name="pubSubDomain" value="true"/>
37. <!--<property name="receiveTimeout" value="10000" />  -->
38. </bean>
39. <bean id="queueProducerService" class="jms.mq.spring.QueueProducerService">
40. <property name="jmsTemplate" ref="jmsQueueTemplate" />
41. <property name="destination" ref="queueDest" />
42. </bean>
43. <bean id="queueConsumerService" class="jms.mq.spring.QueueConsumerService">
44. <property name="jmsTemplate" ref="jmsQueueTemplate" />
45. <property name="destination" ref="queueDest" />
46. </bean>
47. <bean id="topicPublisherService" class="jms.mq.spring.TopicPublisherService">
48. <property name="jmsTemplate" ref="jmsTopicTemplate"/>
49. <property name="destination" ref="topicDest"/>
50. </bean>
51. <bean id="topicSubscriberService" class="jms.mq.spring.TopicSubscriberService">
52. <property name="jmsTemplate" ref="jmsTopicTemplate"/>
53. <property name="destination" ref="topicDest"/>
54. </bean>
55. </beans>

《三》

对于让spring管理监听的实现方式有两种方法，一种是自己写监听器，然后交给spring的监听适配器管理，再由监听容器管理监听适配器，另一种是写一个实现MessageListener接口的类。第一种在第一章涉及到，但是没有交给spring托管.其实实现的方法很简单，在j2ee mvc模式中,用到spring的aop特性.这章讲第

二种方法，这样消费者可以时时接受到生产者的消息，订阅者可以时时接受到发布者的消息.不用循环接受。

1.Queue（点对点）方式

消费者QueueConsumerMessageListener类，具体如下：

1. package jms.mq.spring;
2. import javax.jms.JMSException;
3. import javax.jms.Message;
4. import javax.jms.MessageListener;
5. import javax.jms.TextMessage;
6. public class QueueConsumerMessageListener implements MessageListener{
7. public void onMessage(Message msg) {
8. if(msg instanceof TextMessage){
9. TextMessage textMessage = (TextMessage) msg;
10. try {
11. System.out.println("--队列 MessageListener收到信息："+textMessage.getText());
12. } catch (JMSException e) {
13. e.printStackTrace();
14. }
15. }
16. }
17. }

2.Topic（发布/订阅）方式

订阅者实现类TopicSubscriberMessageListener类,具体如下:

1. package jms.mq.spring;
2. import javax.jms.JMSException;
3. import javax.jms.Message;
4. import javax.jms.MessageListener;
5. import javax.jms.TextMessage;
6. public class TopicSubscriberMessageListener implements MessageListener{
7. public void onMessage(Message msg) {
8. if(msg instanceof TextMessage){
9. TextMessage textMessage = (TextMessage) msg;
10. try {
11. System.out.println("--订阅者 MessageListener收到信息："+textMessage.getText());
12. } catch (JMSException e) {
13. e.printStackTrace();
14. }
15. }
16. }
17. }

3.修改配置文件

1. < !-- 实现接口的方式 -->
2. <bean id="queueConsumerMessageListener" class="jms.mq.spring.QueueConsumerMessageListener">
3. </bean>
4. <!-- 新增一个队列地址名字不能跟上面的重复 -->
5. <bean id="queueConsumerMessageListenerDest" class="org.apache.activemq.command.ActiveMQQueue">
6. <constructor-arg index="0" value="myMessageListenerQueue" />
7. </bean>
8. <bean id="myMsgQueuelistenerContainer"
9. class="org.springframework.jms.listener.DefaultMessageListenerContainer">
10. <property name="connectionFactory" ref="connectionFactory" />
11. <property name="destination" ref="queueConsumerMessageListenerDest" />
12. <property name="messageListener" ref="queueConsumerMessageListener" />
13. <property name="receiveTimeout" value="10000" />
14. </bean>
15. <bean id="topicSubscriberMessageListener" class="jms.mq.spring.TopicSubscriberMessageListener"></bean>
16. <bean id="topicSubscriberMessageListenerDest" class="org.apache.activemq.command.ActiveMQTopic">
17. <constructor-arg index="0" value="myMessageListenerTopic" />
18. </bean>
19. <bean id="myMsgTopiclistenerContainer"
20. class="org.springframework.jms.listener.DefaultMessageListenerContainer">
21. <property name="connectionFactory" ref="connectionFactory" />
22. <property name="destination" ref="topicSubscriberMessageListenerDest" />
23. <property name="messageListener" ref="topicSubscriberMessageListener" />
24. <property name="pubSubDomain" value="true" />
25. <property name="receiveTimeout" value="10000" />
26. </bean>

顺便将上一章的配置也改一下

1. < bean id="queueProducerService" class="jms.mq.spring.QueueProducerService">
2. <property name="jmsTemplate" ref="jmsQueueTemplate" />
3. <!--<property name="destination" ref="queueDest" /> -->
4. <property name="destination" ref="queueConsumerMessageListenerDest" />
5. </bean>
6. <bean id="queueConsumerService" class="jms.mq.spring.QueueConsumerService">
7. <property name="jmsTemplate" ref="jmsQueueTemplate" />
8. <property name="destination" ref="queueDest" />
9. </bean>
10. <bean id="topicPublisherService" class="jms.mq.spring.TopicPublisherService">
11. <property name="jmsTemplate" ref="jmsTopicTemplate" />
12. <!-- <property name="destination" ref="topicDest" /> -->
13. <property name="destination" ref="topicSubscriberMessageListenerDest" />
14. </bean>
15. <bean id="topicSubscriberService" class="jms.mq.spring.TopicSubscriberService">
16. <property name="jmsTemplate" ref="jmsTopicTemplate" />
17. <property name="destination" ref="topicDest" />
18. </bean>

注意是修改 bean id为queueProducerService和的topicPublisherService的destination

4.运行

Queue（点对点）方式,只运行QueueProducerTest.java,结果如下

Topic（发布/订阅）方式,只运行TopicPublisherTest.java,结果如下

ok,如果Queue（点对点）方式和Topic（发布/订阅）方式运行的结果如上图所示，说明你成功了.

《四》

前几章都是直接发送MapMessage类型的数据,拿前面的例子来讲,如果生产者发送的是TextMessage，消费者也是必须TextMessage;如果我们自己要发送的数据不是TextMessage类型,而消费者还是TextMessage的，那该怎么办？难道每次接受后都要增加一个转换方法么？其实spring早就考虑到这种情况了。转化器在很多组件中都是必不缺少的东西Spring的MessageConverter接口提供了对消息转换的支持。

1、转换类的相关代码POJO

新建一个类MsgPoJo，就是一个简单的Pojo类。具体代码如下：

1. package jms.mq.spring;
2. import java.io.Serializable;
3. public class MsgPoJo implements Serializable{
4. private String id;
5. private String text;
6. public String getId() {
7. return id;
8. }
9. public void setId(String id) {
10. this.id = id;
11. }
12. public String getText() {
13. return text;
14. }
15. public void setText(String text) {
16. this.text = text;
17. }
18. }

2.转换类的实现

新建一个类MsgConverter.java，实现MessageConverter接口。生成的代码如下

1. package jms.mq.spring;
2. import javax.jms.JMSException;
3. import javax.jms.Message;
4. import javax.jms.Session;
5. import javax.jms.TextMessage;
6. import org.springframework.jms.support.converter.MessageConversionException;
7. import org.springframework.jms.support.converter.MessageConverter;
8. public class MsgConverter implements MessageConverter{
9. @Override
10. public Object fromMessage(Message message) throws JMSException,
11. MessageConversionException {
12. if (!(message instanceof TextMessage)) {
13. throw new MessageConversionException("Message is not TextMessage");
14. }
15. System.out.println("--转换接收的消息--");
16. TextMessage textMessage = (TextMessage) message;
17. MsgPoJo msgPojo = new MsgPoJo();
18. String[] texts=textMessage.getText().split(",");
19. msgPojo.setId(texts[0]);
20. msgPojo.setText(texts[1]);
21. return msgPojo;
22. }
23. @Override
24. public Message toMessage(Object object, Session session) throws JMSException,
25. MessageConversionException {
26. if (!(object instanceof MsgPoJo)) {
27. throw new MessageConversionException("obj is not MsgPojo");
28. }
29. System.out.println("--转换发送的消息--");
30. MsgPoJo msgPojo = (MsgPoJo) object;
31. TextMessage textMessage = session.createTextMessage();
32. textMessage.setText(msgPojo.getId()+","+msgPojo.getText());
33. return  textMessage;
34. }
35. }

代码很简单就是做些转换，有fromMessage和toMessage两个方法,真好对应发送转换toMessage和接受转换fromMessage。此时，发送和接收消息要换成template.convertAndSend(message)；template.receiveAndConvert()。接下来我做一些配置，让spring知道我们的转换类。修改applicationContext.xml中jms模版配置的代码，修改后的代码如下：

1. <!-- 类转换 -->
2. <bean id="msgConverter" class="jms.mq.spring.MsgConverter"></bean>
3. <!-- 配置Jms模板 -->
4. <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
5. <property name="connectionFactory" ref="connectionFactory" />
6. <property name="defaultDestination" ref="queueDest" />
7. <!--<property name="receiveTimeout" value="10000" /> -->
8. <!-- 类转换 -->
9. <property name="messageConverter" ref="msgConverter"></property>
10. </bean>

注意:如果你有队列监听容器配置,配置jmsQueueTemplate和jmsTopicTemplate可能与队列容器配置冲突。

3、业务相关代码和配置

在QueueProducerService.java增加convertAndSend()方法并在其实现类中实现，实现类的代码如下：

1. package jms.mq.spring;
2. import java.util.Date;
3. import javax.jms.Destination;
4. import javax.jms.JMSException;
5. import javax.jms.Message;
6. import javax.jms.Session;
7. import javax.jms.TextMessage;
8. import org.springframework.jms.core.JmsTemplate;
9. import org.springframework.jms.core.MessageCreator;
10. public class QueueProducerService{
11. JmsTemplate jmsTemplate;
12. Destination destination;
13. public void send() {
14. MessageCreator messageCreator = new MessageCreator() {
15. public Message createMessage(Session session) throws JMSException {
16. TextMessage message = session.createTextMessage();
17. message.setText("QueueProducerService发送消息"+new Date());
18. return message;
19. }
20. };
21. jmsTemplate.send(this.destination,messageCreator);
22. }
23. public void convertAndSend(){
24. MsgPoJo msgPojo = new MsgPoJo();
25. msgPojo.setId("1");
26. msgPojo.setText("first msg");
27. System.out.println("--发送消息：msgPojo.id为"+msgPojo.getId()+"；msgPojo.text为"+msgPojo.getText());
28. jmsTemplate.convertAndSend(this.destination, msgPojo);
29. }
30. public void setJmsTemplate(JmsTemplate jmsTemplate) {
31. this.jmsTemplate = jmsTemplate;
32. }
33. public void setDestination(Destination destination) {
34. this.destination = destination;
35. }
36. }

同样在QueueConsumerService.java中增加receiveAndConvert()方法并在其实现类中实现，实现类的代码如下：

1. package jms.mq.spring;
2. import javax.jms.Destination;
3. import javax.jms.JMSException;
4. import javax.jms.TextMessage;
5. import org.springframework.jms.core.JmsTemplate;
6. public class QueueConsumerService{
7. JmsTemplate jmsTemplate;
8. Destination destination;
9. public void receive() {
10. TextMessage message = (TextMessage) jmsTemplate.receive();
11. try {
12. System.out.println("QueueConsumerService收到消息："+message.getText());
13. } catch (JMSException e) {
14. e.printStackTrace();
15. }
16. }
17. public void receiveAndConvert() {
18. MsgPoJo msgPojo = (MsgPoJo)jmsTemplate.receiveAndConvert();
19. if(msgPojo!=null){
20. System.out.println("--收到消息：msgPojo.id为"+msgPojo.getId()+";msgPojo.text为"+msgPojo.getText());
21. }
22. }
23. public void setJmsTemplate(JmsTemplate jmsTemplate) {
24. this.jmsTemplate = jmsTemplate;
25. }
26. public void setDestination(Destination destination) {
27. this.destination = destination;
28. }
29. }

修改我们的两个测试类，增加对转换方法的调用，不再赘述，直接上代码：

QueueConsumerTest.java测试类

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class QueueConsumerTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void receive() {
7. QueueConsumerService consumerService = (QueueConsumerService) appContext.getBean("queueConsumerService");
8. consumerService.receive();
9. }
10. private static void receiveAndConvert() {
11. QueueConsumerService consumerService = (QueueConsumerService) appContext.getBean("queueConsumerService");
12. consumerService.receiveAndConvert();
13. }
14. public static void main(String[] args) {
15. //receive();
16. receiveAndConvert();
17. }
18. }

QueueProducerTest.java测试类

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class QueueProducerTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void send() {
7. QueueProducerService producerService = (QueueProducerService) appContext.getBean("queueProducerService");
8. producerService.send();
9. }
10. private static void convertAndSend() {
11. QueueProducerService producerService = (QueueProducerService) appContext.getBean("queueProducerService");
12. producerService.convertAndSend();
13. }
14. public static void main(String[] args) {
15. //send();
16. convertAndSend();
17. }
18. }

代码编写完毕，我们看一下我们的劳动成果。首先运行生产者类和消费者控制台信息如下：

收到的内容与发的内容相同，说明转换成功了。如果这一部分的程序使用的队列跟上面的一样，那你会发现发送的时候打印出的信息不值上面的一个，还包括一个接收的信息，这是为什么呢？了解spring原理的人应该知道，spring是把所有类都加载到内容中，当然也包括我们上门写的按个实现MessageListener的一个消费者类，他们也在运行，如果监听的地址跟你送的地址正好相同的话，他也有可能收到这个信息。所以在测试的时候要注意修改配置文件。

1. <bean id="queueProducerService" class="jms.mq.spring.QueueProducerService">
2. <property name="jmsTemplate" ref="jmsQueueTemplate" />
3. <property name="destination" ref="queueDest" />
4. </bean>
5. <bean id="queueConsumerService" class="jms.mq.spring.QueueConsumerService">
6. <property name="jmsTemplate" ref="jmsQueueTemplate" />
7. <property name="destination" ref="queueDest" />
8. </bean>

4、监听器上的使用方式

我再来学习一下跟监听器联合使用的方式，只在发布订阅者模式上演示一下。我们先来修改发布者的实现方式，在发布者中增加convertAndSend方法并在其实现类中实现,订阅者监听器没有类转换,不用修改，发布者修改后的代码如下：

1. package jms.mq.spring;
2. import java.util.Date;
3. import javax.jms.Destination;
4. import javax.jms.JMSException;
5. import javax.jms.MapMessage;
6. import javax.jms.Message;
7. import javax.jms.Session;
8. import javax.jms.TextMessage;
9. import org.springframework.jms.core.JmsTemplate;
10. import org.springframework.jms.core.MessageCreator;
11. import jms.spring.QueueProducerService;
12. public class TopicPublisherService{
13. JmsTemplate jmsTemplate;
14. Destination destination;
15. public void send() {
16. MessageCreator messageCreator = new MessageCreator() {
17. public Message createMessage(Session session) throws JMSException {
18. TextMessage message = session.createTextMessage();
19. message.setText("QueueProducerService发送消息"+new Date());
20. return message;
21. }
22. };
23. jmsTemplate.send(this.destination,messageCreator);
24. }
25. public void convertAndSend(Object obj) {
26. System.out.println("--发送PoJo对象...");
27. jmsTemplate.convertAndSend(destination, obj);
28. }
29. public void setJmsTemplate(JmsTemplate jmsTemplate) {
30. this.jmsTemplate = jmsTemplate;
31. }
32. public void setDestination(Destination destination) {
33. this.destination = destination;
34. }
35. }

发布订阅者配置文件如下

1. <!-- 配置TopicJms模板 -->
2. <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
3. <property name="connectionFactory" ref="connectionFactory" />
4. <property name="defaultDestination" ref="topicDest" />
5. <!-- 配置是否为发布订阅者模式，默认为false -->
6. <property name="pubSubDomain" value="true" />
7. <!--<property name="receiveTimeout" value="10000" /> -->
8. <property name="messageConverter" ref="msgConverter"></property>
9. </bean>

1. <bean id="topicPublisherService" class="jms.mq.spring.TopicPublisherService">
2. <property name="jmsTemplate" ref="jmsTopicTemplate" />
3. <!-- <property name="destination" ref="topicDest" /> -->
4. <property name="destination" ref="topicSubscriberMessageListenerDest" />
5. </bean>
6. <bean id="topicSubscriberService" class="jms.mq.spring.TopicSubscriberService">
7. <property name="jmsTemplate" ref="jmsTopicTemplate" />
8. <property name="destination" ref="topicDest" />
9. </bean>

修改上面的发布测试类，修改增加对新增方法的调用，修改后的内容如下：

1. package jms.mq.spring;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. public class TopicPublisherTest {
5. private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
6. private static void send() {
7. TopicPublisherService topicPublisherService = (TopicPublisherService) appContext.getBean("topicPublisherService");
8. topicPublisherService.send();
9. }
10. private static void convertAndSend() {
11. TopicPublisherService topicPublisherService = (TopicPublisherService) appContext.getBean("topicPublisherService");
12. MsgPoJo msgPoJo = new MsgPoJo();
13. msgPoJo.setId("1");
14. msgPoJo.setText("测试内容");
15. topicPublisherService.convertAndSend(msgPoJo);
16. }
17. public static void main(String[] args) {
18. //send();
19. convertAndSend();
20. }
21. }

运行发布测试类,运行结果如下：

写在到这里,ActiveMQ与spring整合就讲完了，主要讲了ActiveMQ与spring的简单整合,监听器和类转换这些主要功能.

呵呵，写到不好,请大家不要拍砖。

《五》

前面几章讲了ActiveMQ以及ActiveMQ与spring的整合,这是jms的ActiveMQ实现。但是jms到底是什么呢。如果开始就讲解这些理论比较强的东西，可能比较难理解，但是现在结合前面几章的实例对比就比较容易上手了。

1、.JMS 的概念

JMS(Java Message Service)，即 Java 消息服务，是一组 Java 应用程序接口，用以提供创建、发接、接收、读取消息的服务。SUN 只提供接口，由不同的厂商根据该接口提供自己的实现。

2、.JMS 的目标

   更好地理解 JMS 有助于了解 JMS 规范的制定者设置的目标。现在，市场上有许多企业消息产品，生产这些产品的几家公司也参与了 JMS 的开发。

现有的这些系统的能力和功能各不相同。这些制定者知道如果 JMS 结合所有现有系统的所有功能，那么它会变得过于复杂。同样，他们相信，他们也不能让 JMS 只局限于所有系统共有的那些特性。

制定者相信，让 JMS 包括实现“高级的企业应用程序”所需要的所有功能是很重要的。

JMS 规范中声明， JMS 的目标是：

• 定义一组消息公用概念和实用工具。
• 最少化程序员使用消息时必须学习的概念。
• 最大化消息应用程序的可移植性。
• 最小化实现一个提供者所需的工作量。
• 为点对点和 pub/sub 域 提供客户机接口。“域”是用于在前面讨论的消息模型的 JMS 术语。（注意：提供者不需要实现两个域。）

3、.JMS 中间件

  1).IBM MQ 系列产品提供的服务使得应用程序可以使用消息队列进行交流，通过一系列基于 Java 的 API 提供了 MQseries 在 Java 中应用开发的方法。它支持点到点和发布/订阅两种消息模式。

  2).WebLogic是BEA公司实现的基于工业标准的J2EE应用服务器，支持大多数企业级JavaAPI，它完全兼容 JMS 规范，支持点到点和发布/订阅消息模式，它支持消息的多点广播、持久消息存储的文件和数据库、XML 消息，以及动态创建持久队列和主题。

  3).JBoss 是 JBoss 公司开发的一个免费开源的应用服务器，它提供了 EJB 运行的环境，并能够结合 EJB 进行 JMS 消息的收取，支持点到点模型和发布/订阅模型。

  4).ActiveMQ 是一个基于 Apache 2.0 Licenced 发布的开放源代码的 JMS 产品，它能够提供点到点消息模式和发布/订阅消息模式，支持 JBoss、Geronimo 等开源应用服务器，支持 Spring 框架的消息驱动，新增了一个 P2P 传输层，可以用于创建可靠的 P2P JMS 网络连接，拥有消息持久化、事务、集群支持等 JMS 基础设施服务。

  5).OpenJMS 是一个开源的 JMS 规范的实现，它支持点对点模型和发布/订阅模型，支持同步与异步消息发送、可视化管理界面，支持 Applet，能够与 Jakarta Tomcat 这样的 Servlet容器结合，支持 RMI、TCP、HTTP 与 SSL 协议。

4、.JMS特性

在 JMS 之前，每一家 MOM 厂商都用专有 API 为应用程序提供对其产品的访问，通常可用于许多种语言，其中包括 Java 语言。JMS 通过 MOM 产品为 Java 程序提供了一个发送和接收消息的标准的、便利的方法。用 JMS 编写的程序可以在任何实现 JMS 标准的 MOM 上运行。JMS 是由 Sun Microsystems 开发的，它为 Java 程序员提供一种访问企业消息系统的方法，即 面向消息的中间件 （MOM）。MOM 通过中间媒介以间接方式在应用程序之间异步传送数据，用这种方法提供一种以松散耦合的灵活方式集成应用程序的机制。

要执行并测试这些程序，需要访问 JMS 的供应商实现。大多数 Java 2 Enterprise Edition （J2EE）供应商都会提供 JMS 的一种实现(也就是上面说的JMS中间件)。要想获得设置 JMS 运行时程序和执行程序的有关信息，请参阅供应商文档。

它为 Java 程序提供一种访问 企业消息系统 的方法。在讨论 JMS 之前，我们分来析一下企业消息系统。

企业消息系统，即 面向消息的中间件（MOM），提供了以松散耦合的灵活方式集成应用程序的一种机制。它们提供了基于 存储和转发 的应用程序之间的异步数据发送，即应用程序彼此不直接通信，而是与作为中介的 MOM 通信。

MOM 提供了有保证的消息发送（至少是在尽可能地做到这一点），应用程序开发人员无需了解远程过程调用（PRC）和网络/通信协议的细节。

 1)消息灵活性

MOM 将消息路由给应用程序 B，这样，消息就可以存在于完全不同的计算机上，MOM 负责处理网络通信。如果网络连接不可用， MOM 会存储消息，直到连接变得可用时，再将消息转发给应用程序 B。

灵活性的另一方面体现在，当应用程序 A 发送其消息时，应用程序 B 甚至可以不处于执行状态。MOM 将保留这个消息，直到应用程序 B 开始执行并试着检索消息为止。这还防止了应用程序 A 因为等待应用程序 B 检索消息而出现阻塞。

这种异步通信要求应用程序的设计与现在大多数应用程序不同，不过，对于时间无关或并行处理，它可能是一个极其有用的方法。

 2)松散耦合

企业消息系统的真正威力在于应用程序的 松散耦合。在前一页的图表中，由应用程序 A 发送消息指定一个特定目标，如“订单处理”。而现在，是由应用程序 B 提供订单处理功能。

但是在将来，我们可以用不同的订单处理程序替换应用程序 B，应用程序 A 将不再是明智之选。替换应用程序将继续发送消息完成“订单处理”，而消息也仍将得到处理。

同样，我们也可以替换应用程序 A，只要替换应用程序继续发送消息进行“订单处理”，订单处理程序就无需知道是否有一个新的应用程序在发送订单。

5.JMS模式

最初，开发企业消息系统是为了实现 点对点模型 （PTP），由一个应用程序生成的每个消息都由另一个应用程序接收。近年来，出现了一种新的模型，叫做 发布与订阅 （或者 pub/sub）。

Pub/sub 用称为 主题（topic） 的内容分层结构代替了 PTP 模型中的惟一目的地，发送应用程序 发布 自己的消息，指出消息描述的是有关分层结构中的一个主题的信息。

希望接收这些消息的应用程序 订阅了 这个主题。订阅包含子主题的分层结构中的主题的订阅者可以接收该主题和其子主题发表的所有消息。

多个应用程序可以就一个主题发布和订阅消息，而应用程序对其他人仍然是匿名的。MOM 起着 代理（broker） 的作用，将一个主题已发表的消息路由给该主题的所有订阅者。

JMS 应用程序由以下元素组成：

• JMS 客户机。 用 JMS API 发送和接收消息的 Java 程序。
• 非 JMS 客户机。 认识到传统程序通常整个 JMS 应用程序的一部分是非常重要的，在规划时必须优先考虑它们的存在。
• 消息。就JMS 应用程序设计而言，通过JMS 和非 JMS 客户机所交换的消息的格式和内容是完整的。
• JMS 提供者。 如前所述，JMS 定义了一组接口，供应者必须提供特定于其 MOM 产品的具体实现。
• 管理对象。 消息系统提供者的管理员创建的、独立于提供者的专有技术的对象。

 

6、.JMS管理对象

MOM 产品的提供者在实现消息时使用的机制和技术有很大不同。为了保持 JMS 客户机的可移植性，实现了 JMS 接口的对象必须与提供者的专有技术隔离。

完成这项任务的机制是 管理对象。这些实现 JMS 接口的对象由提供者的消息系统的管理员创建，并被放置在 JNDI 名字空间中。

然后由 JMS 程序检索这些对象，通过它们实现的 JMS 接口访问这些对象。JMS 提供者必须提供允许创建受管理对象及它们在 JNDI 名字空间中的存放地的工具。

有两种受管理对象：

• ConnectionFactory：用于创建到提供者的底层消息系统的连接。
• Destination：用 JMS 客户机来指定正发送消息的目的地或正接收消息的来源。

尽管受管理对象本身就是特定于提供者实现的类的例子，但可以使用可移植机制（JNDI）检索它们，并且可以通过可移植接口（JMS）访问它们。JMS 程序只需要知道管理对象的 JNDI 名称和 JMS 接口类型即可，无需了解特定于提供者的知识。

7、.JMS接口

JMS 定义了一组封装各种消息概念的高级接口。而这些接口又因为两个消息域——PTP 和 pub/sub——进行了进一步地定义和定制。

高级接口包括：

• ConnectionFactory：一个创建 Connection 的受管理对象。
• Connection：连接到提供者的活动连接。
• Destination：一个封装消息目的地的身份的受管理对象，如消息的来源地和发送地。
• Session：发送和接收消息的单线程环境。为了简化，并且因为 Session 控制事务的缘故，通过多个线程进行并发访问受到了限制。可以将多个 Session 用于多线程应用程序。
• MessageProducer：用于发送消息。
• MessageConsumer：用于接收消息。

下表列出了从每一个高级接口继承的特定于域的接口。

高级接口PTP 域Pub/sub 域

ConnectionFactory	QueueConnectionFactory	TopicConnectionFactory
Connection	QueueConnection	TopicConnection
Destination	Queue	Topic
Session	QueueSession	TopicSession
MessageProducer	QueueSender	TopicPublisher
MessageConsumer	QueueReceiver，QueueBrowser	TopicSubscriber

在 JMS 以前的版本中，高级接口是特定于域的接口的父接口，并且只包含在两个域*有的那些功能。JMS 提供者没有提供高级接口的实现。在 JMS 1.1 中，一些高级接口现在则被认为是“公用接口”，并且它们包含两个域的所有功能； JMS 提供者必须提供这些接口的实现。尽管公用接口仍然是特定于域的接口的父接口，但它们现在是 JMS 客户机编程的首选方法，并且它们提供特定于域的接口只为了后向兼容。

下面重新列出了前一小节中的表，展示了一些公用接口。

JMS 公用接口PTP 域Pub/sub 域

ConnectionFactory	QueueConnectionFactory	TopicConnectionFactory
Connection	QueueConnection	TopicConnection
Destination	Queue	Topic
Session	QueueSession	TopicSession
MessageProducer	QueueSender	TopicPublisher
MessageConsumer	QueueReceiver,QueueBrowser	TopicSubscriber

统一有公用接口的域会导致继承这些方法的一些特定于域的类不再适合它的域。如果在客户机代码中出现这种情况，JMS 提供者需要使用 IllegalStateException。

8、jms开发

一个典型的 JMS 程序要经过以下步骤才能开始产生和使用消息：

1. 通过 JNDI 查询 ConnectionFactory 。
2. 通过 JNDI 查询一个或者多个 Destination。
3. 用 ConnectionFactory 创建一个 Connection。
4. 用 Connection 创建一个或者多个 Session。
5. 用 Session 和 Destination 创建所需要的 MessageProducer 和 MessageConsumer。
6. 启动 Connection。

这时，消息就可以开始流动，应用程序可以根据需要接收、处理和发送消息。 在后面几节中，我们将开发 JMS 程序，您将会看到这些步骤的细节。

9、jms消息

消息系统的核心当然是消息。JMS 为不同类型的内容提供了几种消息类型，但所有消息都是从 Message 接口派生出来的。

Message 分为三个组成部分：

• header 是一组标准字段，客户机和提供者都用它们来标识和路由消息。
• Properties 提供了一个给消息添加可选标题字段的实用工具。如果应用程序需要用标准标题字段没有提供的方法对消息进行归类或分类，那么可以为消息添加一个属性来实现这种归类和分类；提供了 set<Type>Property(...) 和 get<Type>Property(...) 方法来设置和获得各种 Java 类型的属性，其中包括 Object。JMS 定义了提供者可以选择性提供的一组标准属性。
• 消息的 body 包含将 发送到接收应用程序的内容。每一个消息接口都专用于它所支持的内容类型。

 

10、header属性

下面列出了 Message 的每一个标题字段的名称、它对应的 Java 类型和字段的描述：

• JMSMessageID——类型为 string

  惟一标识提供者发送的每一条消息。这个字段是在发送过程中由提供者设置的，客户机只能在消息发送后才能确定消息的 JMSMessageID。

• JMSDestination——类型为 Destination

  消息发送的 Destination，在发送过程中由提供者设置。

• JMSDeliveryMode——类型为 int

  包含值 DeliveryMode.PERSISTENT 或者 DeliveryMode.NON_PERSISTENT。持久性消息被传输并且只被传输一次，非持久性消息最多被传输一次。要知道“最多一次”包括根本不传输。非持久性消息在应用程序或者系统出故障时被提供者弄丢。因此要格外小心，确保持久性消息不受故障的影响。这比开销通常被认为是发送持久性消息方面的开销，在决定消息的发送模式时，必须仔细考虑，在可靠性和性能之间进行权衡。

• JMSTimestamp——类型为 long

  提供者发送消息的时间，由提供者在发送过程中设置。

• JMSExpiration——类型为 long

  消息失效的时间。这个值是在发送过程中计算的，是发送方法的生存时间（time-to-live）值和当前时间值的和。提供者不应发送过期的消息。值 0 表明消息不会过期。

• JMSPriority——类型为 int

  消息的优先级，由提供者在发送过程中设置。优先级 0 的优先级最低，优先级 9 的优先级最高。

• JMSCorrelationID——类型为 string

  通常用来链接响应消息与请求消息，由发送消息的 JMS 程序设置。响应来自另一个 JMS 程序的消息的 JMS 程序将正响应消息的 JMSMessageID 拷贝到这个字段中，这样，正作出响应的程序就可以与它所发出的特定请求的响应相 关联。

• JMSReplyTo——类型为 Destination

  请求程序用它来指出回复消息应发送的地方，由发送消息的 JMS 程序设置。

• JMSType——类型为 string

  JMS 程序用它来指出消息的类型。一些提供者维护着一个消息类型仓库，并用该字段引用仓库中的定义类型，在这里，JMS 程序不应该使用这个字段。

• JMSRedelivered——类型为 boolean

  指出消息被过早地发送给了 JMS 程序，程序不知道消息的接收者是谁；由提供者在接收过程中设置。

11、标准属性

下面列表给出了 Message 的每一个标准属性的名称、它对应的 Java 类型和该属性的说明。提供者对标准属性的支持是可选的。JMS 为这些属性和将来 JMS 定义的属性保留了 “JMSX” 属性名。

• JMSXUserID——类型为 string

  发送消息的用户的身份。

• JMSXApplID——类型为 string

  发送消息的应用程序的身份。

• JMSXDeliveryCount——类型为 int

  已经尝试发送消息的次数。

• JMSXGroupID——类型为 string

  该消息所属的消息组的身份。

• JMSXGroupSeq——类型为 int

  该消息在消息组中的序号。

• JMSXProducerTXID——类型为 string

  生成该消息的事务的身份。

• JMSXConsumerTXID——类型为 string

  使用该消息的事务的身份。

• JMSXRcvTimestamp——类型为 long

  JMS 将消息发送给客户的时间。

• JMSXState——类型为 int

  提供者用它来维护消息的消息仓库，通常，它与 JMS 生产者和客户关系不大。

• JMSX_<vendor_name>

  为特定于提供者的属性而保留。

《六》

1、product发送JMS消息

1. public class QueueSend {
2. public static void main(String[] args) throws JMSException {
3. ConnectionFactory connectionfactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
4. //创建与JMS服务的连接:ConnectionFactory被管理的对象，由客户端创建，用来创建一个连接对象
5. Connection connection = connectionfactory.createConnection();//获取连接，connection一个到JMS系统提供者的活动连接
6. Session session =connection.createSession(false,Session.AUTO_ACKNOWLEDGE );//打开会话，一个单独的发送和接受消息的线程上下文
7. QueueSend qs = new QueueSend();
8. qs.sendTextMsg(session,"使用jms发送文本消息","queue.msgText");//发送文本类型的消息
9. MapMessage mapMsg = session.createMapMessage();
10. mapMsg.setString("name", "李寻欢1");
11. mapMsg.setBoolean("IsHero", true);
12. mapMsg.setInt("age", 35);
13. qs.sendMap(session, mapMsg, "queue.msgMap");//发送map类型的消息
14. Person person = new Person("阿飞", 23, "北京.大兴");//发送Object类型消息
15. qs.sendObj(session, person, "queue.msgObj");
16. session.close();
17. connection.close();
18. }
19. /*
20. * 发送文本消息
21. */
22. public void sendTextMsg(Session session,String MsgContent,String name) throws JMSException{
23. Queue queue = new ActiveMQQueue(name);
24. MessageProducer msgProducer = session.createProducer(queue);
25. Message msg = session.createTextMessage(MsgContent);
26. msgProducer.send(msg);
27. System.out.println("文本消息已发送");
28. }
29. /*
30. * 发送MAP类型消息
31. */
32. public void sendMap(Session session,MapMessage map,String name) throws JMSException{
33. Queue queue = new ActiveMQQueue(name);
34. MessageProducer msgProducer = session.createProducer(queue);
35. msgProducer.send(map);
36. System.out.println("Map格式的消息已发送");
37. }
38. /*
39. * 发送Object类型消息
40. */
41. public void sendObj(Session session,Object obj,String name) throws JMSException{
42. Destination  queue = new ActiveMQQueue(name);//分装消息的目的标示
43. MessageProducer msgProducer = session.createProducer(queue);
44. ObjectMessage objMsg=session.createObjectMessage((Serializable) obj);//发送对象时必须让该对象实现serializable接口
45. MessageProducer msgPorducer =session.createProducer(queue);
46. msgPorducer.send(objMsg);
47. System.out.println("Object类型的消息已发送");
48. }
49. }

当消息发送成功时我们可以再web消息管理端看到产生了如下图所示的三条消息。

 2、consumer消费消息

1. public class QueueAccept implements MessageListener{
2. public static void main(String[] args) throws JMSException {
3. ConnectionFactory connectionfactory =null;
4. Connection connection=null;
5. Session session=null;
6. if(connectionfactory==null){
7. connectionfactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
8. }
9. if(connection==null){
10. connection = connectionfactory.createConnection();
11. connection.start();
12. }
13. session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
14. Queue queue = new ActiveMQQueue("queue.msgText");//根据发送的名称接受消息
15. MessageConsumer consumer = session.createConsumer(queue);
16. consumer.setMessageListener(new QueueAccept());//不继承MessageListener时可以用consumer.receive()手动接受消息
17. Queue queue1 = new ActiveMQQueue("queue.msgMap");
18. MessageConsumer consumer1 = session.createConsumer(queue1);
19. consumer1.setMessageListener(new QueueAccept());
20. Queue queue2 = new ActiveMQQueue("queue.msgObj");
21. MessageConsumer consumer2 = session.createConsumer(queue2);
22. consumer2.setMessageListener(new QueueAccept());
23. }
24. public void onMessage(Message message) {
25. /**
26. * 接受文本类型的消息
27. */
28. if(message instanceof TextMessage){ //instanceof 测试它所指向的对象是否是TextMessage类
29. TextMessage text = (TextMessage) message;
30. try {
31. System.out.println("发送的文本消息内容为："+text.getText()); //接受文本消息
32. } catch (JMSException e) {
33. e.printStackTrace();
34. }
35. }
36. /**
37. * 接受Map类型的消息
38. */
39. if(message instanceof MapMessage){
40. MapMessage map = (MapMessage) message;
41. try {
42. System.out.println("姓名："+map.getString("name"));
43. System.out.println("是否是英雄："+map.getBoolean("IsHero"));
44. System.out.println("年龄:"+map.getInt("age"));
45. } catch (JMSException e) {
46. e.printStackTrace();
47. }
48. }
49. if(message instanceof ObjectMessage){
50. ObjectMessage objMsg = (ObjectMessage) message;
51. try {
52. Person person=(Person) objMsg.getObject();
53. System.out.println("用户名："+person.getName()+"年龄:"+person.getAge()+"地址："+person.getAddress());
54. } catch (JMSException e) {
55. e.printStackTrace();
56. }
57. }
58. }

客户端运行后接受到的消息：

    在上边的代码中，我们在发送Object对象时，我们发送的对象需要实现serializable接口。记得刚找工作的时候有一回有个面试官问到，为什么一个类要实现serializable接口，也许许多人新人都不知道为什么，只能按照背的面试题中的答案去说。刚好这个demo中遇到了这个问题，就继续复习一下java的基础吧。一个类只有实现了serializable才是可以序列化的，通俗的讲实现了serializable接口后我们将可以把这个类，在网络上进行发送，或者将这个类存入到硬盘，序列化的目的就是保存一个对象。