ActiveMQ和spring整合

最新推荐文章于 2022-12-24 13:27:39 发布

ytlizhen1

最新推荐文章于 2022-12-24 13:27:39 发布

阅读量845

点赞数

ActiveMQ 是Apache出品，是最流行和最强大的开源消息总线。同时完全支持 JMS 1.1和J2EE 1.4规范。

ActiveMQ 特性

支持多种编程语言和协议编写客户端。
在JMS客户端和消息代理完全支持企业集成模式
完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务)。
对Spring的支持, ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性。
测试通过常见的J2EE服务器。如：Geronimo, JBoss 4, GlassFish, WebLogic。
支持多种传送协议：in-VM, TCP, SSL, NIO, UDP, JGroups,JXTA。
支持通过JDBC和journal提供高速的消息持久化。
从设计上保证了高性能的集群,客户端-服务器,点对点。
支持Ajax
支持与Axis的整合
可以很容易得调用内嵌JMS provider,进行测试。

通过网络搜索及个人理解，整理出ActiveMQ与Spring整合的文章。

相关jar包

activemq-core-5.5.1.jar
geronimo-j2ee-management_1.1_spec-1.0.1.jar
geronimo-jms_1.1_spec-1.1.1.jar
geronimo-jta_1.0.1B_spec-1.0.1.jar
kahadb-5.5.1.jar
xbean-spring-3.7.jar
commons-beanutils.jar
commons-codec.jar
commons-collections.jar
commons-fileupload.jar
commons-httpclient.jar
commons-io.jar
commons-lang.jar
commons-logging.jar
commons-validator.jar
dom4j-1.6.1.jar
javaee.jar
jsf-api.jar
jsf-impl.jar
jstl.jar
log4j-1.2.15.jar
slf4j-api-1.5.8.jar
slf4j-log4j12-1.5.8.jar
aspectjrt.jar
aspectjweaver.jar
spring.jar

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:amq="http://activemq.apache.org/schema/core"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-2.5.xsd
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util-2.5.xsd
       http://www.springframework.org/schema/jee
       http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
       http://activemq.apache.org/schema/core
       http://activemq.apache.org/schema/core/activemq-core-5.5.0.xsd">

　　<!-- Annotation Config -->
　　<context:annotation-config/>

　　<!-- Compoent Scan -->
　　<context:component-scan base-package="com.uu.web.*"/>

　　<!-- Property Placeholder -->
　　<context:property-placeholder location="classpath:config.properties"/>
    
　　<!-- Aop Config -->
　　<aop:aspectj-autoproxy/>
　　<!-- 
　　<bean id="mysql-ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
　　　　<property name="driverClassName" value="${dirver}"/>
　　　　<property name="url" value="${url}"/>
　　　　<property name="username" value="${username}"/>
　　　　<property name="password" value="${password}"/>
　　</bean>
　　-->
　　<!-- 
　　　　使用spring的listenerContainer 消息用持久化保存，服务器重启不会丢失
　　　　也可以配置在${ACTIVEMQ_HOME}/conf/activemq.xml内
　　　　消息的保存方式文件持久化和数据库持久化
　　　　此配置是文件持久化
　　-->
　　<!-- Embedded ActiveMQ Broker -->
　　<amq:broker useJmx="false" persistent="true">
　　　　<amq:persistenceAdapter>
　　　　　　<amq:amqPersistenceAdapter directory="G:/amq"/>
　　　　　　<!-- 使用数据库持久化 -->
　　　　　　<!--<amq:jdbcPersistenceAdapter dataSource="#mysql-ds" />-->
　　　　</amq:persistenceAdapter>
　　　　<amq:transportConnectors>
　　　　　　<amq:transportConnector uri="tcp://localhost:61616" />
　　　　</amq:transportConnectors>
　　</amq:broker>
    
　　<!--ActiveMQ connectionFactory  -->
　　<amq:connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost" />
    
　　<!-- ActiveMQ destinations  -->
　　<!-- 
　　　　TOPIC：发布订阅消息
　　　　　　　　无状态，不保证每条消息被消费
　　　　　　　　只有监听该TOPIC地址才能收到消息并消费，否则该消息将会丢失
　　　　　　　　一对多的发布接受策略，可以同时消费多个消息
　　-->
　　<amq:topic name="TOPIC" physicalName="JMS-TOPIC" />

    <!--
　　　　QUEUE：　点对点
　　　　　　　　　消息数据被持久化，每条消息都能被消费
　　　　　　　　　没有监听QUEUE地址也能被消费，数据不会丢失
　　　　　　　　　一对一的发布接受策略，保证数据完整
    -->
    <amq:queue name="QUEUE" physicalName="JMS-QUEUE" />
    
　　<!-- ConnectionFactory -->
　　<bean id="singleConnectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory" destroy-method="destroy">
　　　　<property name="targetConnectionFactory" ref="jmsConnectionFactory"/>
　　</bean>
    
　　<!-- 添加事务 -->
　　<bean id="jmsTransactionManager" class="org.springframework.jms.connection.JmsTransactionManager" >
　　　　<property name="connectionFactory" ref="singleConnectionFactory"/>
　　</bean>
    
　　<!--  Spring JmsTemplate config -->
　　<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
　　　　<!--  lets wrap in a pool to avoid creating a connection per send -->
　　　　<property name="connectionFactory" ref="singleConnectionFactory"/>
　　　　<!-- custom MessageConverter -->
　　　　<property name="messageConverter" ref="defaultMessageConverter" />
　　　　<property name="sessionTransacted" value="true"/>
　　</bean>

　　<!-- converter  -->
　　<bean id="defaultMessageConverter" class="com.uu.activemq.DefaultMessageConverter" />
    
　　<!-- 生产消息配置 -->
　　<!-- POJO which send Message uses  Spring JmsTemplate -->
　　<bean id="topicMessageProducer" class="com.uu.activemq.TopicMessageProducer">
　　　　<property name="template" ref="jmsTemplate" />
　　　　<property name="destination" ref="TOPIC" />
　　</bean>
　　<bean id="queueMessageProducer" class="com.uu.activemq.QueueMessageProducer">
　　　　<property name="template" ref="jmsTemplate" />
　　　　<property name="destination" ref="QUEUE" />
　　</bean>
    
　　<!-- 消费消息 配置 -->
　　<!--  Message Driven POJO (MDP) -->
　　<!-- consumer1 for topic -->
　　<bean id="topicConsumer" class="com.uu.activemq.TopicConsumer" />

　　<!-- consumer for queue -->
　　<bean id="queueConsumer" class="com.uu.activemq.QueueConsumer" />
    
　　<!-- Message Listener for  -->
　　<bean id="topicListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
　　　　<constructor-arg ref="topicConsumer" />
　　　　<!--  指定消费消息的方法 -->
　　　　<property name="defaultListenerMethod" value="receive" />
　　　　<!-- custom MessageConverter define -->
　　　　<property name="messageConverter" ref="defaultMessageConverter" />
　　</bean>
　　<bean id="queueListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
　　　　<constructor-arg ref="queueConsumer" />
　　　　<!--  指定消费消息的方法 -->
　　　　<property name="defaultListenerMethod" value="receive" />
　　　　<!-- custom MessageConverter define -->
　　　　<property name="messageConverter" ref="defaultMessageConverter" />
　　</bean>
    
　　<!--  listener container，MDP无需实现接口 -->
　　<bean id="topicListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
　　　　<property name="connectionFactory" ref="jmsConnectionFactory" />
　　　　<property name="destination" ref="TOPIC" />
　　　　<property name="messageListener" ref="topicListener" />
　　</bean>
　　<bean id="queueListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
　　　　<property name="connectionFactory" ref="jmsConnectionFactory" />
　　　　<property name="destination" ref="QUEUE" />
　　　　<property name="messageListener" ref="queueListener" />
　　　　<property name="transactionManager" ref="jmsTransactionManager"/>
　　　　<property name="sessionTransacted" value="true"/>
　　　　<property name="concurrentConsumers" value="5"/>
　　</bean>
</beans>

消息转换类

DefaultMessageConverter.java

 1 package com.uu.activemq;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.IOException;
 6 import java.io.ObjectInputStream;
 7 import java.io.ObjectOutputStream;
 8 import java.util.HashMap;
 9 
10 import javax.jms.JMSException;
11 import javax.jms.Message;
12 import javax.jms.ObjectMessage;
13 import javax.jms.Session;
14 
15 import org.apache.activemq.command.ActiveMQObjectMessage;
16 import org.apache.commons.logging.Log;
17 import org.apache.commons.logging.LogFactory;
18 import org.springframework.jms.support.converter.MessageConverter;
19 
20 /**
21  * 消息转换类
22  */
23 @SuppressWarnings("unchecked")
24 public class DefaultMessageConverter implements MessageConverter {
25     
26     private static final Log log = LogFactory.getLog(DefaultMessageConverter.class);
27 
28     public Message toMessage(Object obj, Session session) throws JMSException {
29         if (log.isDebugEnabled()) {
30             log.debug("toMessage(Object, Session) - start");
31         }
32 
33         // check Type
34         ActiveMQObjectMessage objMsg = (ActiveMQObjectMessage) session.createObjectMessage();
35         HashMap<String, byte[]> map = new HashMap<String, byte[]>();
36         try {
37             // POJO must implements Seralizable
38             ByteArrayOutputStream bos = new ByteArrayOutputStream();
39             ObjectOutputStream oos = new ObjectOutputStream(bos);
40             oos.writeObject(obj);
41             map.put("POJO", bos.toByteArray());
42             objMsg.setObjectProperty("Map", map);
43 
44         } catch (IOException e) {
45             log.error("toMessage(Object, Session)", e);
46         }
47         return objMsg;
48     }
49 
50     
51     public Object fromMessage(Message msg) throws JMSException {
52         if (log.isDebugEnabled()) {
53             log.debug("fromMessage(Message) - start");
54         }
55 
56         if (msg instanceof ObjectMessage) {
57             HashMap<String, byte[]> map = (HashMap<String, byte[]>) ((ObjectMessage) msg).getObjectProperty("Map");
58             try {
59                 // POJO must implements Seralizable
60                 ByteArrayInputStream bis = new ByteArrayInputStream(map.get("POJO"));
61                 ObjectInputStream ois = new ObjectInputStream(bis);
62                 Object returnObject = ois.readObject();
63                 return returnObject;
64             } catch (IOException e) {
65                 log.error("fromMessage(Message)", e);
66 
67             } catch (ClassNotFoundException e) {
68                 log.error("fromMessage(Message)", e);
69             }
70 
71             return null;
72         } else {
73             throw new JMSException("Msg:[" + msg + "] is not Map");
74         }
75     }
76 }

接受Queue方式消费

QueueConsumer.java

 1 package com.uu.activemq;
 2 
 3 import java.util.Map;
 4 import java.util.Set;
 5 
 6 public class QueueConsumer
 7 {
 8     public void receive(Map<String, Object> message)
 9     {
10         Set<String> set = message.keySet();
11         String str = "";
12         for(String key : set)
13         {
14             str += key + "_" + message.get(key) + ":Queue";
15         }
16         System.out.println(str);
17     }
18 }

接受Topic方式消费

TopicConsumer.java

 1 package com.uu.activemq;
 2 
 3 import java.util.Map;
 4 import java.util.Set;
 5 import java.util.concurrent.ExecutorService;
 6 import java.util.concurrent.Executors;
 7 
 8 /**
 9  * 创建10个线程池
10  * 1.使用线程异步消息处理
11  * 2.不使用线程，那么消息等待上一个消息处理完成后才继续
12  * 注:如果担心据同步问题，那么使用第2种方法
13  */
14 public class TopicConsumer
15 {
16     protected static ExecutorService exec = Executors.newFixedThreadPool(10);
17     
18     public void receive(Map<String, Object> message)
19     {
20         /*exec.submit(new Runnable(){
21             
22             public void run()
23             {
24                 
25             }
26         });*/
27         Set<String> set = message.keySet();
28         String str = "";
29         for(String key : set)
30         {
31             str += key + "_" + message.get(key) + ":Topic";
32         }
33         System.out.println(str);
34     }
35 }

生产Queue方式的消息

QueueMessageProducer.java

 1 package com.uu.activemq;
 2 
 3 import java.util.Map;
 4 
 5 import javax.jms.Queue;
 6 
 7 import org.springframework.jms.core.JmsTemplate;
 8 
 9 public class QueueMessageProducer {
10 
11     private JmsTemplate template;
12 
13     private Queue destination;
14 
15     public void setTemplate(JmsTemplate template) {
16         this.template = template;
17     }
18 
19     public void setDestination(Queue destination) {
20         this.destination = destination;
21     }
22 
23     public void send(Map<String,Object> message) {
24         template.convertAndSend(this.destination, message);
25     }
26 
27 }

生产Topic方式的消息

TopicMessageProducer.java

 1 package com.uu.activemq;
 2 
 3 import java.util.Map;
 4 
 5 import javax.jms.Topic;
 6 
 7 import org.springframework.jms.core.JmsTemplate;
 8 
 9 public class TopicMessageProducer {
10     
11     private JmsTemplate template;
12 
13     private Topic destination;
14 
15     public void setTemplate(JmsTemplate template) {
16         this.template = template;
17     }
18 
19     public void setDestination(Topic destination) {
20         this.destination = destination;
21     }
22 
23     public void send(Map<String,Object> message) {
24         template.convertAndSend(this.destination, message);
25     }
26 }

写一个测试类

 1 package com.uu.activemq;
 2 
 3 import java.util.LinkedHashMap;
 4 import java.util.Map;
 5 
 6 import org.springframework.context.ApplicationContext;
 7 import org.springframework.context.support.FileSystemXmlApplicationContext;
 8 
 9 /**
10  * 解决耗时的数据操作
11  * 发送消息不等待返回，继续执行
12  */
13 public class MainTest
14 {
15     public static void main(String[] args)
16     {
17         ApplicationContext wac = new FileSystemXmlApplicationContext("classpath:spring.xml");
18         
19         TopicMessageProducer topicMessageProducer  = (TopicMessageProducer) wac.getBean("topicMessageProducer");
20         
21         QueueMessageProducer queueMessageProducer  = (QueueMessageProducer) wac.getBean("queueMessageProducer");
22         
23         Map<String, Object> message = new LinkedHashMap<String, Object>();
24         message.put("test", "ActiveMQ");
25         
26         queueMessageProducer.send(message);
27         topicMessageProducer.send(message);
28         System.out.println("完成");
29     }
30 }

结果先输出完成然后输出传递的参数

完成
test_ActiveMQ:Queue
test_ActiveMQ:Topic

ytlizhen1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
ActiveMQ和spring整合

ActiveMQ 是Apache出品，是最流行和最强大的开源消息总线。同时完全支持 JMS 1.1和J2EE 1.4规范。ActiveMQ 特性支持多种编程语言和协议编写客户端。在JMS客户端和消息代理完全支持企业集成模式完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务)。对Spring的支持, ActiveMQ可以很容易内嵌到使用Spring的系统里面去,
复制链接

扫一扫