Spring 集成 ActiveMQ 配置（二）

 

从上一篇开始说起

 

上一篇从零开始学 Java - Spring 集成 ActiveMQ 配置（一）文章中讲了我关于消息队列的思考过程，现在这一篇会讲到 ActivMQ 与 Spring 框架的整合配置，以及我们的多队列配置、断线重连机制，当然还有的生产者及消费监听者的具体代码实现。

ActiveMQ 是 Apache 出品，最流行的、能力强劲的开源消息总线。ActiveMQ 是一个完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现，可以很容易内嵌到使用Spring的系统里面去，所以我们选择它。

一些基础的准备工作

先去官网下载服务器端的安装包，地址：http://activemq.apache.org/activemq-5130-release.html，根据自己系统下来，并进行安装，这里不再赘述，安装完成后，一般可以打开一个这样的界面：

接着，找到我们需要的 jar 包。其实刚刚下载的文件中就有，我们只需要导入到我们的项目中即可，当然，你也可以从我的示例项目中获得：https://github.com/mafly/SpringDemo/blob/master/WebContent/WEB-INF/lib/

开始写代码吧

一、建立cn.mayongfa.activemq包。
1.新建MessageSender.java消息发送类

1. /**
2. * ActiveMQ 消息生产类
3. *
4. * @author Mafly
5. *
6. */
7. @Component
8. public class MessageSender {
9.  
10. private Logger log = Logger.getLogger(MessageSender.class);
11.  
12. @Autowired
13. private JmsTemplate jmsTemplate;
14.  
15. private String Queue = "default_queue";
16.  
17. private String GoldQueue = "gold_queue";
18.  
19. private Gson gson = new Gson();
20.  
21. /**
22. * 用户登录消息
23. */
24. public void userLogin(long id, String username) {
25. Map<String, Object> map = new HashMap<String, Object>();
26. map.put("userid", id);
27. map.put("username", username);
28.  
29. System.out.println("发送了一条消息。");
30. // 发送到金币队列
31. sendMessage(gson.toJson(map), 1);
32. }
33.  
34. /**
35. * 发送到消息队列
36. *
37. * @param messgae
38. * @param type
39. * 类型，0:默认队列 1：金币队列 ...
40. */
41. public void sendMessage(final String messgae, int type) {
42. try {
43. String destination = this.Queue;
44. if (type == 1) {
45. destination = GoldQueue;
46. }
47. jmsTemplate.send(destination, new MessageCreator() {
48. @Override
49. public Message createMessage(Session session) throws JMSException {
50. TextMessage textMessage = session.createTextMessage(messgae);
51. return textMessage;
52. }
53. });
54. } catch (Exception e) {
55. log.error("", e);
56. }
57. }
58. }

这个类是用来往消息队列发送信息的。

2.新建ConsumerMessageListener.java消息监听类，继承于MessageListener

1. /**
2. * 消费者监听类
3. *
4. * @author Mafly
5. */
6. @Component
7. public class ConsumerMessageListener implements MessageListener {
8.  
9. private Logger log = Logger.getLogger(ConsumerMessageListener.class);
10.  
11. @Override
12. public void onMessage(Message arg0) {
13. // 监听发送到消息队列的文本消息，作强制转换。
14. TextMessage textMessage = (TextMessage) arg0;
15. try {
16. System.out.println("接收到的消息内容是：" + textMessage.getText());
17.  
18. // TODO: 你喜欢的任何事情...
19.  
20. } catch (JMSException e) {
21. log.error("", e);
22. }
23.  
24. }
25.  
26. }

这个类就是具体的消息消费类，我们就可以在这实现具体的业务逻辑处理了。

3.新建ActiveMQTransportListener.java消息传输监听类，继承于TransportListener

1. /**
2. * 消息传输监听
3. * @author Mafly
4. *
5. */
6. public class ActiveMQTransportListener implements TransportListener {
7.  
8. private Logger log = Logger.getLogger(ActiveMQTransportListener.class);
9.  
10. /**
11. * 对消息传输命令进行监控
12. * @param command
13. */
14. @Override
15. public void onCommand(Object o) {
16.  
17. }
18.  
19. /**
20. * 对监控到的异常进行触发
21. * @param error
22. */
23. @Override
24. public void onException(IOException error) {
25. log.error("onException -> 消息服务器连接错误......", error);
26. }
27.  
28. /**
29. * 当failover时触发
30. */
31. @Override
32. public void transportInterupted() {
33. log.warn("transportInterupted -> 消息服务器连接发生中断...");
34. //这里就可以状态进行标识了
35.  
36. }
37.  
38. /**
39. * 监控到failover恢复后进行触发
40. */
41. @Override
42. public void transportResumed() {
43. log.info("transportResumed -> 消息服务器连接已恢复...");
44. //这里就可以进行状态标识了
45. }
46. }

这里就可以做消息传输过程中的一些监控及处理，比如常见的异常处理等等。

二、在applicationContext.xml文件中配置
重要的是建完包之后要在applicationContext.xml文件中配置扫描包，完成 Bean 的注入 。就是下面：

1. <context:component-scan base-package="cn.mayongfa.activemq" />

在applicationContext.xml文件中加入 JMS 的配置：

1. <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
2. <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
3. <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
4. <property name="connectionFactory" ref="connectionFactory" />
5. </bean>
6.  
7. <!-- 真正可以产生Connection的ConnectionFactory，由ActiveMQ提供 -->
8. <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
9. <property name="brokerURL" value="failover:tcp://127.0.0.1:61616" />
10. <!-- 消息传输监听器 处理网络及服务器异常 -->
11. <property name="transportListener">
12. <bean class="cn.mayongfa.activemq.ActiveMQTransportListener" />
13. </property>
14. </bean>
15.  
16. <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
17. <bean id="connectionFactory"
18. class="org.springframework.jms.connection.SingleConnectionFactory">
19. <property name="targetConnectionFactory" ref="targetConnectionFactory" />
20. </bean>
21.  
22. <!--这个是队列目的地 -->
23. <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
24. <constructor-arg>
25. <value>default_queue,gold_queue</value>
26. </constructor-arg>
27. </bean>
28. <!-- 消息监听器 -->
29. <bean id="consumerMessageListener" class="cn.mayongfa.activemq.ConsumerMessageListener" />
30. <!-- 消息监听容器 -->
31. <bean id="jmsContainer"
32. class="org.springframework.jms.listener.DefaultMessageListenerContainer">
33. <property name="connectionFactory" ref="connectionFactory" />
34. <property name="destination" ref="queueDestination" />
35. <property name="messageListener" ref="consumerMessageListener" />
36. <!-- 设置固定的线程数 -->
37. <property name="concurrentConsumers" value="2"></property>
38. <!-- 设置动态的线程数 -->
39. <property name="concurrency" value="2-5"></property>
40. </bean>

这里的消息服务器地址及队列名称也可以像缓存一样放在配置文件。当然，你不能忘了把配置文件读取到 Spring 容器中管理。

• queueDestination：这个节点下面的default_queue,gold_queue这就是两个队列的配置了，多队列在这里用逗号分隔配置就可以了。
• failover：从字面意思你应该能明白这个意思，就是启用断线重连机制的。我们也是可以在ActiveMQTransportListener类里边监听到的。

配置完成，代码也写完了，接下来就是调用测试了。

总结一下

这篇文章有了干货，用具体的代码及配置完成了简单的消息队列的发送、监听等等，还有多队列的一些处理，以及断线重连机制。希望我的分享对你有所帮助吧，所有这些配置及代码都可以在我的 GitHub 上关于 Spring 的示例项目看到：https://github.com/mafly/SpringDemo/tree/activemq。

 

 

 

http://blog.mayongfa.cn/