分布式--ActiveMQ 消息中间件

Posted 2021-04-10 凌浩雨

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了分布式--ActiveMQ 消息中间件相关的知识，希望对你有一定的参考价值。

1. Spring+ActiveMQ

1). 导包

Spring包：spring-aop-5.0.5.RELEASE.jar、spring-context-5.0.5.RELEASE.jar、spring-core-5.0.5.RELEASE.jar
ActiveMQ包：activemq-all-5.15.3.jar
commons: commons-pool2-2.5.0.jar

图1.png

2). 项目配置

I. 配置ConnectionFactory
ConnectionFactory是用于产生到JMS服务器的链接的，Spring为我们提供了多个ConnectionFactory，有SingleConnectionFactory和CachingConnectionFactory。

SingleConnectionFactory对于建立JMS服务器链接的请求会一直返回同一个链接，并且会忽略Connection的close方法调用。
CachingConnectionFactory继承了SingleConnectionFactory，所以它拥有SingleConnectionFactory的所有功能，同时它还新增了缓存功能，它可以缓存Session、MessageProducer和MessageConsumer。

ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。

 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:context="http://www.springframework.org/schema/context"
 4    xmlns:jms="http://www.springframework.org/schema/jms"
 5    xsi:schemaLocation="http://www.springframework.org/schema/beans  
 6     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
 7     http://www.springframework.org/schema/context  
 8     http://www.springframework.org/schema/context/spring-context-3.0.xsd  
 9    http://www.springframework.org/schema/beans 
10    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
11    http://www.springframework.org/schema/jms 
12    http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">
13
14    <!-- 自动扫描和管理Bean配置 -->
15    <context:component-scan base-package="com.mazaiting"/>  
16
17    <!-- 真正可以产生Connection的ConnectionFactory，由对应的JMS服务厂商提供 -->
18    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
19        <property name="brokerURL" value="tcp://localhost:61616"/>
20    </bean>
21
22    <!--  ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。 -->
23    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
24        <property name="connectionFactory" ref="targetConnectionFactory"/>
25        <!-- 最大连接数 -->
26        <property name="maxConnections" value="10"/>
27    </bean>
28
29    <!-- Spring 用于管理真正的ConnectionFactory的ConnectionFactory -->
30    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
31        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
32        <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>
33    </bean>
34</beans>

II. 配置生产者
生产者负责产生消息并发送到JMS服务器，这通常对应的是我们的一个业务逻辑服务实现类。通常是利用Spring为我们提供的JmsTemplate类来实现的，所以配置生产者其实最核心的就是配置进行消息发送的JmsTemplate。对于消息发送者而言，在定义JmsTemplate的时候需要往里面注入一个Spring提供的ConnectionFactory对象。

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>

利用JmsTemplate进行消息发送的时候，我们需要知道消息发送的目的地，即destination。在Jms中有一个用来表示目的地的Destination接口，它里面没有任何方法定义，只是用来做一个标识而已。当我们在使用JmsTemplate进行消息发送时没有指定destination的时候将使用默认的Destination。默认Destination可以通过在定义jmsTemplate bean对象时通过属性defaultDestination或defaultDestinationName来进行注入，defaultDestinationName对应的就是一个普通字符串。在ActiveMQ中实现了两种类型的Destination，一个是点对点的ActiveMQQueue，另一个就是支持订阅/发布模式的ActiveMQTopic。

1    <!-- 队列目的地，点对点 -->
2    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
3        <constructor-arg value="queue"/>
4    </bean>
5
6    <!-- 主题目的地，一对多 -->
7    <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
8        <constructor-arg value="topic"/>
9    </bean>

III. 配置消费者
生产者往指定目的地Destination发送消息后，接下来就是消费者对指定目的地的消息进行消费了。通过Spring为我们封装的消息监听容器MessageListenerContainer, 负责接收信息，并把接收到的信息分发给真正的MessageListener进行处理。每个消费者对应每个目的地都需要有对应的MessageListenerContainer。通过在配置MessageConnectionFactory的时候往里面注入一个ConnectionFactory来实现的,在配置一个MessageListenerContainer的时候有三个属性必须指定，一个是表示从哪里监听的ConnectionFactory；一个是表示监听什么的Destination；一个是接收到消息以后进行消息处理的MessageListener。Spring一共为我们提供了两种类型的MessageListenerContainer，SimpleMessageListenerContainer和DefaultMessageListenerContainer。
SimpleMessageListenerContainer会在一开始的时候就创建一个会话session和消费者Consumer，并且会使用标准的JMS MessageConsumer.setMessageListener()方法注册监听器让JMS提供者调用监听器的回调函数。它不会动态的适应运行时需要和参与外部的事务管理。兼容性方面，它非常接近于独立的JMS规范，但一般不兼容Java EE的JMS限制。
大多数情况下我们还是使用的DefaultMessageListenerContainer，跟SimpleMessageListenerContainer相比，DefaultMessageListenerContainer会动态的适应运行时需要，并且能够参与外部的事务管理。它很好的平衡了对JMS提供者要求低、先进功能如事务参与和兼容Java EE环境。

 1    <!-- 队列目的地，点对点 -->
 2    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
 3        <constructor-arg value="queue"/>
 4    </bean>
 5    <!-- 消息监听器 -->
 6    <bean id="consumerMessageListener" class="com.mazaiting.jms.listener.ConsumerMessageListener"/>
 7    <!-- 消息监听容器 -->
 8    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
 9        <property name="connectionFactory" ref="connectionFactory"/>
10        <property name="destination" ref="queueDestination"/>
11        <property name="messageListener" ref="consumerMessageListener"/>
12    </bean>

IV. 完整配置文件

 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:context="http://www.springframework.org/schema/context"
 4    xmlns:jms="http://www.springframework.org/schema/jms"
 5    xsi:schemaLocation="http://www.springframework.org/schema/beans  
 6     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
 7     http://www.springframework.org/schema/context  
 8     http://www.springframework.org/schema/context/spring-context-3.0.xsd  
 9    http://www.springframework.org/schema/beans 
10    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
11    http://www.springframework.org/schema/jms 
12    http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">
13
14    <!-- 自动扫描和管理Bean配置 -->
15    <context:component-scan base-package="com.mazaiting"/>  
16
17    <!-- 真正可以产生Connection的ConnectionFactory，由对应的JMS服务厂商提供 -->
18    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
19        <property name="brokerURL" value="tcp://localhost:61616"/>
20    </bean>
21
22    <!--  ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。 -->
23    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
24        <property name="connectionFactory" ref="targetConnectionFactory"/>
25        <!-- 最大连接数 -->
26        <property name="maxConnections" value="10"/>
27    </bean>
28
29    <!-- Spring 用于管理真正的ConnectionFactory的ConnectionFactory -->
30    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
31        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
32        <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>
33    </bean>
34
35    <!-- Spring 提供的JMS工具类，它可以进行消息的发送、接收等 -->
36    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
37        <!-- 这个ConnectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
38        <property name="connectionFactory" ref="connectionFactory"/>
39    </bean>
40
41    <!-- 队列目的地，点对点 -->
42    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
43        <constructor-arg value="queue"/>
44    </bean>
45    <!-- 消息监听器 -->
46    <bean id="consumerMessageListener" class="com.mazaiting.jms.listener.ConsumerMessageListener"/>
47    <!-- 消息监听容器 -->
48    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
49        <property name="connectionFactory" ref="connectionFactory"/>
50        <property name="destination" ref="queueDestination"/>
51        <property name="messageListener" ref="consumerMessageListener"/>
52    </bean>
53
54    <!-- 主题目的地，一对多 -->
55    <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
56        <constructor-arg value="topic"/>
57    </bean>
58
59</beans>

3). 创建Java代码

I. 在com.mazaiting.jms.service包下创建ProducerService接口

1public interface ProducerService {
2    public void sendMessage(Destination destination, final String message);
3}

II. 在com.mazaiting.jms.service.impl包下创建ProducerServiceImpl类

 1@Service
 2public class ProducerServiceImpl implements ProducerService{
 3    private JmsTemplate jmsTemplate;
 4
 5    /**
 6     * 发送消息
 7     * @param destination 目的地
 8     * @param message 消息
 9     * @throws JmsException 
10     */
11    @Override
12    public void sendMessage(Destination destination, final String message) {
13        System.out.println("-------------生产者发送消息---------------");
14        System.out.println("-------------生产者发了一个消息：" + message);
15        jmsTemplate.send(destination, new MessageCreator() {
16
17            @Override
18            public Message createMessage(Session session) throws JMSException {
19                return session.createTextMessage(message);
20            }
21        });
22    }
23
24    public JmsTemplate getJmsTemplate() {
25        return jmsTemplate;
26    }
27
28    @Resource
29    public void setJmsTemplate(JmsTemplate jmsTemplate) {
30        this.jmsTemplate = jmsTemplate;
31    }
32}

III. 在com.mazaiting.jms.listener下创建ConsumerMessageListener类

 1public class ConsumerMessageListener implements MessageListener{
 2
 3    @Override
 4    public void onMessage(Message message) {
 5        // 判断是否为纯文本消息
 6        if (message instanceof TextMessage) {
 7            TextMessage textMessage = (TextMessage) message;
 8            System.out.println("接收到纯文本消息：");
 9            try {
10                System.out.println("消息的内容是： " + textMessage.getText());
11            } catch (JMSException e) {
12                e.printStackTrace();
13            }
14        }
15    }
16}

IV. 在com.mazaiting.jms包下创建ProducerConsumerTest测试类

 1public class ProducerConsumerTest {
 2    private ApplicationContext context;
 3    private ProducerService producerService;
 4    private Destination destination;
 5    @Before
 6    public void onInit() {
 7        context = new ClassPathXmlApplicationContext("classpath:bean.xml");
 8        producerService = (ProducerService) context.getBean("producerServiceImpl");
 9        destination = (Destination) context.getBean("queueDestination");
10    }
11
12    @Test
13    public void sendTest() {
14        for (int i = 0; i < 2; i++) {
15            producerService.sendMessage(destination, "你好，生产者！ 这是消息" + (i+1));
16        }
17    }
18}

V. 测试

先运行activemq.bat文件
在运行测试方法

图2.png

2. 消息监听器(MessageListener)

pring整合JMS的应用中我们在定义消息监听器的时候一共可以定义三种类型的消息监听器，分别是MessageListener、SessionAwareMessageListener和MessageListenerAdapter。

1). MessageListener

MessageListener是最原始的消息监听器，它是JMS规范中定义的一个接口。其中定义了一个用于处理接收到的消息的onMessage方法，该方法只接收一个Message参数。

 1public class ConsumerMessageListener implements MessageListener{
 2
 3    @Override
 4    public void onMessage(Message message) {
 5        // 判断是否为纯文本消息
 6        if (message instanceof TextMessage) {
 7            TextMessage textMessage = (TextMessage) message;
 8            System.out.println("接收到纯文本消息：");
 9            try {
10                System.out.println("消息的内容是： " + textMessage.getText());
11            } catch (JMSException e) {
12                e.printStackTrace();
13            }
14        }
15    }
16
17}

2). SessionAwareMessageListener

SessionAwareMessageListener是Spring为我们提供的，它不是标准的JMS MessageListener。MessageListener的设计只是纯粹用来接收消息的，假如我们在使用MessageListener处理接收到的消息时我们需要发送一个消息通知对方我们已经收到这个消息了，那么这个时候我们就需要在代码里面去重新获取一个Connection或Session。SessionAwareMessageListener的设计就是为了方便我们在接收到消息后发送一个回复的消息，它同样为我们提供了一个处理接收到的消息的onMessage方法，但是这个方法可以同时接收两个参数，一个是表示当前接收到的消息Message，另一个就是可以用来发送消息的Session对象。
I. 定义ConsumerSessionAwareMessageListener

 1public class ConsumerSessionAwareMessageListener implements SessionAwareMessageListener<TextMessage>{
 2    private Destination destination;
 3    @Override
 4    public void onMessage(TextMessage message, Session session) throws JMSException {
 5        System.out.println("收到一条消息");
 6        System.out.println("消息的内容是： " + message.getText());
 7        // 创建消息生产者
 8        MessageProducer producer = session.createProducer(destination);
 9        // 创建文本消息
10        Message textMessage = session.createTextMessage("ConsumerSessionAwareMessageListener...");
11        // 发送消息
12        producer.send(textMessage);
13    }
14    public Destination getDestination() {
15        return destination;
16    }
17    public void setDestination(Destination destination) {
18        this.destination = destination;
19    }
20}

II. 在Spring的配置文件中配置该消息监听器将处理来自一个叫sessionAwareQueue的目的地的消息，并且往该MessageListener中通过set方法注入其属性destination的值为queueDestination。这样当我们的SessionAwareMessageListener接收到消息之后就会往queueDestination发送一个消息。
bean.xml文件中添加配置

 1    <!-- SessionAwareQueue目的地 -->
 2    <bean id="sessionAwareQueue" class="org.apache.activemq.command.ActiveMQQueue">
 3        <constructor-arg value="sessionAwareQueue"/>
 4    </bean>
 5    <!-- 可以获取session的MessageListener -->
 6    <bean id="consumerSessionAwareMessageListener" class="com.mazaiting.jms.listener.ConsumerSessionAwareMessageListener">
 7        <property name="destination" ref="queueDestination"/>
 8    </bean>
 9    <!-- 消息监听容器 -->
10    <bean id="sessionAwareListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
11        <property name="connectionFactory" ref="connectionFactory"/>
12        <property name="destination" ref="sessionAwareQueue"/>
13        <property name="messageListener" ref="consumerSessionAwareMessageListener"/>
14    </bean>

III. 测试类

 1public class ProducerConsumerTest {
 2    private ApplicationContext context;
 3    private ProducerService producerService;
 4    private Destination destination;
 5    @Before
 6    public void onInit() {
 7        context = new ClassPathXmlApplicationContext("classpath:bean.xml");
 8        producerService = (ProducerService) context.getBean("producerServiceImpl");
 9//        destination = (Destination) context.getBean("queueDestination");
10        destination = (Destination) context.getBean("sessionAwareQueue");
11    }
12
13    @Test
14    public void sendTest() {
15        for (int i = 0; i < 2; i++) {
16            producerService.sendMessage(destination, "你好，生产者！ 这是消息" + (i+1));
17        }
18    }
19
20    @Test
21    public void sessionAwareMessageListenerTest() {
22        producerService.sendMessage(destination, "测试SessionAwareMessageListener");
23    }
24}

IV. 测试

3). MessageListenerAdapter

MessageListenerAdapter类实现了MessageListener接口和SessionAwareMessageListener接口，它的主要作用是将接收到的消息进行类型转换，然后通过反射的形式把它交给一个普通的Java类进行处理。
MessageListenerAdapter会把接收到的消息做如下转换：

TextMessage转换为String对象；
BytesMessage转换为byte数组；
MapMessage转换为Map对象；
ObjectMessage转换为对应的Serializable对象。

I. 创建ConsumerListener

1public class ConsumerListener {
2    public void handleMessage(String message) {
3        System.out.println("ConsumerListener通过handleMessage发送到一个纯文本消息，消息内容是：" + message);
4    }
5
6    public void receiveMessage(String message) {
7        System.out.println("ConsumerListener通过receiveMessage接收到一个纯文本消息，消息内容是：" + message);
8    }
9}

II. bean.xml添加配置

 1    <!-- 测试消息监听适配器的队列目的地-MessageListenerAdapter -->
 2    <bean id="adapterQueue" class="org.apache.activemq.command.ActiveMQQueue">
 3        <constructor-arg>
 4            <value>adapterQueue</value>
 5        </constructor-arg>
 6    </bean>
 7    <!-- 适配器 -->
 8    <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
 9        <property name="delegate">
10            <bean class="com.mazaiting.jms.listener.ConsumerListener"/>
11        </property>
12        <property name="defaultListenerMethod" value="receiveMessage"/>
13    </bean>
14    <!-- 或者使用此方式配置适配器 -->
15<!--     <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
16        <constructor-arg>
17            <bean class="com.mazaiting.jms.listener.ConsumerListener"/>
18        </constructor-arg>
19    </bean> -->
20    <!-- 消息监听适配器对应的监听容器 -->
21    <bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
22        <property name="connectionFactory" ref="connectionFactory"/>
23        <property name="destination" ref="adapterQueue"/>
24        <property name="messageListener" ref="messageListenerAdapter"/>
25    </bean>

III. 测试代码

 1public class ProducerConsumerTest {
 2    private ApplicationContext context;
 3    private ProducerService producerService;
 4    private Destination destination;
 5    @Before
 6    public void onInit() {
 7        context = new ClassPathXmlApplicationContext("classpath:bean.xml");
 8        producerService = (ProducerService) context.getBean("producerServiceImpl");
 9//        destination = (Destination) context.getBean("queueDestination");
10//        destination = (Destination) context.getBean("sessionAwareQueue");
11        destination = (Destination) context.getBean("adapterQueue");
12    }
13
14    @Test
15    public void messageListenerAdapterTest() {
16        producerService.sendMessage(destination, "测试MessageListenerAdapter");
17    }
18}

IV. 结果

V. 如果我们不指定MessageListenerAdapter的defaultListenerMethod属性，运行上述代码时控制台会输出如下结果：

4). MessageListenerAdapter除了会自动的把一个普通Java类当做MessageListener来处理接收到的消息，另一个主要的功能是可以自动的发送返回消息。

方式一：
I. 修改生产者ProducerServiceImpl代码

 1@Service
 2public class ProducerServiceImpl implements ProducerService{
 3    @Autowired
 4    private JmsTemplate jmsTemplate;
 5
 6    @Autowired
 7    @Qualifier("responseQueue")
 8    private Destination responseDestination;
 9
10    /**
11     * 发送消息
12     * @param destination 目的地
13     * @param message 消息
14     * @throws JmsException 
15     */
16    @Override
17    public void sendMessage(Destination destination, final String message) {
18        System.out.println("-------------生产者发送消息---------------");
19        System.out.println("-------------生产者发了一个消息：" + message);
20        jmsTemplate.send(destination, new MessageCreator() {
21
22            @Override
23            public Message createMessage(Session session) throws JMSException {
24                TextMessage textMessage = session.createTextMessage(message);
25                textMessage.setJMSReplyTo(responseDestination);
26                return textMessage;
27            }
28        });
29    }
30}

II. 创建ResponseQueueListener

 1public class ResponseQueueListener implements MessageListener{
 2
 3    @Override
 4    public void onMessage(Message message) {
 5        if (message instanceof TextMessage) {
 6            TextMessage textMessage = (TextMessage) message;
 7            try {
 8                System.out.println("发送到responseQueue的一个文本消息，内容是： " + textMessage.getText());
 9            } catch (JMSException e) {
10                e.printStackTrace();
11            }
12        }
13    }
14
15}

III. bean.xml添加配置

 1    <!-- 用于测试消息回复 -->
 2    <bean id="responseQueue" class="org.apache.activemq.command.ActiveMQQueue">
 3        <constructor-arg>
 4            <value>responseQueue</value>
 5        </constructor-arg>
 6    </bean>
 7    <!-- responseQueue对应的监听器 -->
 8    <bean id="responseQueueListener" class="com.mazaiting.jms.listener.ResponseQueueListener"/>
 9    <!-- responseQueue对应的监听容器 -->
10    <bean id="responseQueueMessageListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
11        <property name="connectionFactory" ref="connectionFactory"/>
12        <property name="destination" ref="responseQueue"/>
13        <property name="messageListener" ref="responseQueueListener"/>
14    </bean>

IV. 修改ConsumerListener

 1public class ConsumerListener {
 2    public void handleMessage(String message) {
 3        System.out.println("ConsumerListener通过handleMessage发送到一个纯文本消息，消息内容是：" + message);
 4    }
 5
 6    public String receiveMessage(String message) {
 7        System.out.println("ConsumerListener通过receiveMessage接收到一个纯文本消息，消息内容是：" + message);
 8        return "这是ConsumerListener对象的receiveMessage方法的返回值。";
 9    }
10}

V. 执行测试方法messageListenerAdapterTest

图6.png

方式二：通过MessageListenerAdapter的defaultResponseDestination属性来指定。
I. 创建DefaultResponseQueueListener

 1public class DefaultResponseQueueListener implements MessageListener{
 2
 3    @Override
 4    public void onMessage(Message message) {
 5        if (message instanceof TextMessage) {
 6            TextMessage textMessage = (TextMessage) message;
 7            try {
 8                System.out.println("DefaultResponseQueueListener接收到发送到defaultResponseQueue的一个文本消息，内容是：" + textMessage.getText());
 9            } catch (JMSException e) {
10                e.printStackTrace();
11            }  
12        }
13    }
14
15}

II. bean.xml添加配置

 1    <!-- 适配器 -->
 2    <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
 3        <property name="delegate">
 4            <bean class="com.mazaiting.jms.listener.ConsumerListener"/>
 5        </property>
 6        <property name="defaultListenerMethod" value="receiveMessage"/> 
 7        <!-- 添加配置 -->
 8        <property name="defaultResponseDestination" ref="defaultResponseQueue"/>
 9    </bean>
10
11    <!-- 默认的消息回复队列 -->
12    <bean id="defaultResponseQueue" class="org.apache.activemq.command.ActiveMQQueue">
13        <constructor-arg>
14            <value>defaultResponseQueue</value>
15        </constructor-arg>
16    </bean>
17    <!-- defaultResponseQueue对应的监听器 -->
18    <bean id="defaultResponseQueueListener" class="com.mazaiting.jms.listener.DefaultResponseQueueListener"/>
19    <!-- defaultResponseQueue对应的监听容器 -->
20    <bean id="defaultResponseQueueMessageListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
21        <property name="connectionFactory" ref="connectionFactory"/>
22        <property name="destination" ref="defaultResponseQueue"/>
23        <property name="messageListener" ref="defaultResponseQueueListener"/>
24    </bean>

III. 执行测试方法messageListenerAdapterTest

图7.png

5). 消息转换器MessageConverter

MessageConverter的作用主要有两方面，一方面它可以把我们的非标准化Message对象转换成我们的目标Message对象，这主要是用在发送消息的时候；另一方面它又可以把我们的Message对象转换成对应的目标对象，这主要是用在接收消息的时候。
I. 创建邮件对象

 1/**
 2 * 邮件 Bean
 3 * @author mazaiting
 4 */
 5public class Email implements Serializable{
 6    private static final long serialVersionUID = 1L;
 7    private String receiver;
 8    private String title;
 9    private String content;
10
11    public Email(String receiver, String title, String content) {
12        this.receiver = receiver;
13        this.title = title;
14        this.content = content;
15    }
16    public String getReceiver() {
17        return receiver;
18    }
19    public void setReceiver(String receiver) {
20        this.receiver = receiver;
21    }
22    public String getTitle() {
23        return title;
24    }
25    public void setTitle(String title) {
26        this.title = title;
27    }
28    public String getContent() {
29        return content;
30    }
31    public void setContent(String content) {
32        this.content = content;
33    }
34    @Override
35    public String toString() {
36        StringBuilder builder = new StringBuilder();
37        builder.append("Email [receiver=");
38        builder.append(receiver);
39        builder.append(", title=");
40        builder.append(title);
41        builder.append(", content=");
42        builder.append(content);
43        builder.append("]");
44        return builder.toString();
45    }   
46}

II. 创建服务接口ProducerService ，并实现

1public interface ProducerService {
2    void sendMessage(Destination destination, Serializable obj);
3}

 1@Service
 2public class ProducerServiceImpl implements ProducerService{
 3
 4    @Autowired
 5    private JmsTemplate jmsTemplate;
 6
 7    @Override
 8    public void sendMessage(Destination destination, Serializable obj) {
 9        // 未使用MessageConverter
10        /*jmsTemplate.send(destination, new MessageCreator() {
11
12            @Override
13            public Message createMessage(Session session) throws JMSException {
14                return session.createObjectMessage(obj);
15            }
16        });*/
17        // 使用MessageConverter, JmsTemplate就会在其内部调用预定的MessageConverter对我们的消息对象进行转换，然后再进行发送。
18        jmsTemplate.convertAndSend(destination, obj);
19    }
20
21}

 1public class EmailMessageConverter implements MessageConverter{
 2
 3    @Override
 4    public Message toMessage(Object object, Session session) throws JMSException {
 5        return session.createObjectMessage((Serializable) object);
 6    }
 7
 8    @Override
 9    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
10        ObjectMessage objMessage = (ObjectMessage) message;
11        return objMessage.getObject();
12    }
13
14}```
15IV. 创建消息监听器ConsumerMessageListener

public class ConsumerMessageListener implements MessageListener{

 1@Override
 2public void onMessage(Message message) {
 3    if (message instanceof ObjectMessage) {
 4        ObjectMessage objMessage = (ObjectMessage) message;
 5        try {
 6            Object obj = objMessage.getObject();
 7            Email email = (Email) obj;
 8            System.out.println("接收到一个ObjectMessage,包含Email对象");
 9            System.out.println(email.toString());
10        } catch (JMSException e) {
11            e.printStackTrace();
12        }
13    }
14}

}

1V. 修改bean-converter.xml文件(由bean.xml文件复制而来，删除了不必要的东西)

 1<!-- 自动扫描和管理Bean配置 -->
 2<context:component-scan base-package="com.mazaiting.jms.converter"/>    
 3
 4<!-- 真正可以产生Connection的ConnectionFactory，由对应的JMS服务厂商提供 -->
 5<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
 6    <property name="brokerURL" value="tcp://localhost:61616"/>
 7    <!-- 如果传输对象，必须设置这句为true -->
 8    <property name="trustAllPackages" value="true"/>
 9</bean>
10
11<!--  ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。 -->
12<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
13    <property name="connectionFactory" ref="targetConnectionFactory"/>
14    <!-- 最大连接数 -->
15    <property name="maxConnections" value="10"/>
16</bean>
17
18<!-- Spring 用于管理真正的ConnectionFactory的ConnectionFactory -->
19<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
20    <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
21    <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>
22</bean>
23
24<!-- 类型转换器 -->
25<bean id="emailMessageConverter" class="com.mazaiting.jms.converter.converter.EmailMessageConverter"/>
26
27<!-- Spring 提供的JMS工具类，它可以进行消息的发送、接收等 -->
28<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
29    <!-- 这个ConnectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
30    <property name="connectionFactory" ref="connectionFactory"/>
31    <!-- 消息转换器 -->
32    <property name="messageConverter" ref="emailMessageConverter"/>
33</bean>
34
35<!-- 队列目的地，点对点 -->
36<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
37    <constructor-arg value="queue"/>
38</bean>
39<!-- 消息监听器 -->
40<bean id="consumerMessageListener" class="com.mazaiting.jms.converter.listener.ConsumerMessageListener"/>
41<!-- 消息监听容器 -->
42<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
43    <property name="connectionFactory" ref="connectionFactory"/>
44    <property name="destination" ref="queueDestination"/>
45    <property name="messageListener" ref="consumerMessageListener"/>
46</bean>
47
48<!-- 测试消息监听适配器的队列目的地-MessageListenerAdapter -->
49<bean id="adapterQueue" class="org.apache.activemq.command.ActiveMQQueue">
50    <constructor-arg>
51        <value>adapterQueue</value>
52    </constructor-arg>
53</bean>
54<!-- 适配器 -->
55<bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
56    <property name="delegate">
57        <bean class="com.mazaiting.jms.listener.ConsumerListener"/>
58    </property>
59    <property name="defaultListenerMethod" value="receiveMessage"/> 
60</bean>
61<!-- 消息监听适配器对应的监听容器 -->
62<bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
63    <property name="connectionFactory" ref="connectionFactory"/>
64    <property name="destination" ref="adapterQueue"/>
65    <property name="messageListener" ref="messageListenerAdapter"/>
66</bean>

1VI. 测试类

public class ProducerConsumerConverterTest {
private ApplicationContext context;
private ProducerService producerService;
private Destination destination;
@Before
public void onInit() {
context = new ClassPathXmlApplicationContext("classpath:bean-converter.xml");
producerService = (ProducerService) context.getBean("producerServiceImpl");
destination = (Destination) context.getBean("queueDestination");
// destination = (Destination) context.getBean("adapterQueue");
}

1@Test
2public void objMessageTest() {
3    Email email = new Email("lisi@xxx.com", "主题", "内容");
4    producerService.sendMessage(destination, email);
5}

}

1VII. 执行测试
2![图8.png](https://upload-images.jianshu.io/upload_images/3110861-42801b74593a4b2d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
3
4VIII. 修改ConsumerMessageListener代码为

1Ⅸ. 执行结果
2![图9.png](https://upload-images.jianshu.io/upload_images/3110861-9b7202609da8c3d7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
3
4Ⅹ. 使用MessageListenerAdapter做消息监听器
5当我们使用MessageListenerAdapter来作为消息监听器的时候，我们可以为它指定一个对应的MessageConverter，这样Spring在处理接收到的消息的时候就会自动地利用我们指定的MessageConverter对它进行转换，然后把转换后的Java对象作为参数调用指定的消息处理方法。
6- 创建ConsumerListener

public class ConsumerListener {
public void receiveMessage(String message) {
System.out.println("ConsumerListener通过receiveMessage接收到一个纯文本消息，消息内容是：" + message);
}

1public void receiveMessage(Email email) {
2    System.out.println("接收到一个包含Email的ObjectMessage。");  
3    System.out.println(email); 
4}

}

1- 修改bean.converter.xml

 1<!-- 测试消息监听适配器的队列目的地-MessageListenerAdapter -->
 2<bean id="adapterQueue" class="org.apache.activemq.command.ActiveMQQueue">
 3    <constructor-arg>
 4        <value>adapterQueue</value>
 5    </constructor-arg>
 6</bean>
 7<!-- 适配器 -->
 8<bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
 9    <property name="delegate">
10        <bean class="com.mazaiting.jms.converter.listener.ConsumerListener"/>
11    </property>
12    <property name="defaultListenerMethod" value="receiveMessage"/> 
13    <!-- 配置消息转换器 -->
14    <property name="messageConverter" ref="emailMessageConverter"/>
15</bean>
16<!-- 消息监听适配器对应的监听容器 -->
17<bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
18    <property name="connectionFactory" ref="connectionFactory"/>
19    <property name="destination" ref="adapterQueue"/>
20    <property name="messageListener" ref="messageListenerAdapter"/>
21</bean>

1- 测试类

public class ProducerConsumerConverterTest {
private ApplicationContext context;
private ProducerService producerService;
private Destination destination;
@Before
public void onInit() {
context = new ClassPathXmlApplicationContext("classpath:bean-converter.xml");
producerService = (ProducerService) context.getBean("producerServiceImpl");
// destination = (Destination) context.getBean("queueDestination");
destination = (Destination) context.getBean("adapterQueue");
}

1@Test
2public void objMessageTest() {
3    Email email = new Email("lisi@xxx.com", "主题", "内容");
4    producerService.sendMessage(destination, email);
5}

}

1- 执行效果
2![图10.png](https://upload-images.jianshu.io/upload_images/3110861-3d4a702aac1a8965.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
3
4###### 6). 事务
5I. 在jmsContainer中添加`sessionTransacted`属性即可

1II. 如果想接收消息和数据库访问处于同一事务中，那么我们就可以配置一个外部的事务管理同时配置一个支持外部事务管理的消息监听容器（如DefaultMessageListenerContainer）。要配置这样一个参与分布式事务管理的消息监听容器，我们可以配置一个JtaTransactionManager，当然底层的JMS ConnectionFactory需要能够支持分布式事务管理，并正确地注册我们的JtaTransactionManager。

 1#### 3. Transport Connectors配置
 2###### 1). Transport Connectors配置
 3ActiveMQ Connecor分为两种：
 4- Transport Connector和Network Connector。transport Connector负责client和broker的连接，称为client-to-broker communication；
 5- Network Connector负责broker和broker之间的连接，称为broker-to-broker communication
 6![图11.png](https://upload-images.jianshu.io/upload_images/3110861-f2bac201c5845ca5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 7
 8- 从broker的角度来看，transport connector是用于接受和监听来自客户端的连接请求的一种机制。可以看到在<transportConnectors>中包含了多个<transportConnector>对象，每一个对象都定义了监听的地址、端口以及使用的协议。不同的<transportConnector>的name和uri属性值必须不同。
 9- 从客户端的角度来看，transportConnector的URI是用于和broker建立连接，以通过该连接来发送和接受消息。
10
11###### 2). Transport Connector的可用协议
12- 传输控制协议  （TCP）
13- New I/O API协议（NIO）
14- 用户数据包协议（UDP）
15- SSL协议（Secure Sockets Layer Protocol）
16- HTTP/HTTPS协议
17- 虚拟机协议（virtual machine protocol， VM）
18I. 传输控制协议  （TCP）
19由于TCP具有可靠传输的特性，它在ActiveMQ中也是最长使用的一种协议。在默认的配置中，TCP连接的端口为61616.TCP Connector的URI的配置语法如下：

1tcp://hostname:port?key=value&key=value

1`tcp://hostname:port`为必须部分，剩余的key/value部分为可选部分，不同的key/value用”&”符号分开,[详细介绍](http://activemq.apache.org/tcp-transport-reference.html)。可选部分用于定义broker的一些额外的行为，如假设我们进行如下配置：

1<transportConnector　name=”tcp”uri=”tcp://localhost:61616?trace=true”/>

1则broker会在日志中记录经过这个connector所发送的每一条消息，这对于调试会有很大的帮助。
2II. New I/O API协议（NIO）
3NIO是在Java SE 1.4开始引进的，用于提供一种网络编程和访问现代操作系统的底层I/O.NIO中使用最多的两种特性是selector和non-blocking I/O，它们使得开发人员可以使用相同的资源来处理更多的网络连接（如果不使用NIO技术，系统将无法承受这么多的网络连接）。从客户端的角度来看，NIO transport connector与TCP connector是相同的，这是因为NIO connector实际上采用TCP来传输数据。唯一不同的是，NIO transport connector是利用NIO API实现的。这使得NIO在以下几种情况下更为适合：
4- 大量的客户端需要连接broker。通常，与broker之间的连接数是受操作系统的线程数限制的，由于相比TCP connector而言，NIO connector会占用更少的线程。所以，当TCP connector无法满足要求时，可以考虑使用NIO进行替代。
5- broker之间存在严重的网路阻塞。NIO connector会比TCP connector拥有更好的性能，因为它会使用更少的资源。
6
7NIO的配置语法与TCP的配置相似，只需将tcp替换成nio即可：

1nio://hostname:port?key=value

1NIO的默认监听端口是61618，它也有trace这个可以，用于决定是否记录所有传输的消息。
2III. 用户数据包协议（UDP）
3根据UDP的特性，它一般用于要求传出速率快，且能够忍受丢包发生的情况。你可以使用UDP协议来连接ActiveMQ的UDP connector。它的URI语法与TCP及NIO基本一致：

1udp://hostname:port?key=value

1[详细内容](http://activemq.apache.org/udp-transport-reference.html),通常以下两种情况可以考虑使用UDP：
2- broker有防火墙的保护，只能通过UDP端口来访问；
3- 消息传送对实时性要求非常高，可以通过UDP来尽可能的消除网络延迟；
4
5由于UDP的不可靠特性，所以在使用时，必须考虑丢包时的处理。
6IV. SSL协议（Secure Sockets Layer Protocol）
7当broker暴露于不安全的网络环境，而你的数据需要保密时，可以使用SSL。它是用于通过TCP传输加密数据的一种协议，它通过一对钥匙（公钥和私钥）来保证一条安全通道。ActiveMQ提供SSL connector，它的语法如下：

1ssl://hostname:port?key=value

1由于ssl采用TCP进行传输，它的选项跟TCP是一致的，当然如果你需要更加详细的说明，可以参考：http://activemq.apache.org/ssl-transport-reference.html，另外需要说明的是ssl connector默认监听61617端口。与前3种不同，ssl connector还需要ssl证书来保证其正确运行。JSSE提供了两类文件分别用于存储key和certification，用于存储key的文件称为keystores，存储certification的称为truststores.
2V. HTTP/HTTPS协议
3 有些服务器的防火墙设置了只能提供HTTP访问，这时便是HTTP/HTTPS connector的地盘了。ActiveMQ实现的HTTP/HTTPS协议用于传输XML数据，它们的配置语法分别如下：

1http://hostname:port?key=value
2https://hostname:port?key=value

1还需要添加activem1-optional包.
2VI. 虚拟机协议（virtual machine protocol， VM）
3ActiveMQ还可以嵌入Java应用程序中，这样Java程序与broker之间的连接不会经过网络，而是在同一个JVM中进行，从而可以减少网络传输，大幅提升性能。这种方式成为虚拟机协议。使用VM协议的broker拥有与其它协议相同的功能，VM connector的配置语法如下：

1vm://brokerName?key=value

 1[VM connector详细介绍](http://activemq.apache.org/vm-transport-reference.html)
 2###### 3). network connectors部署集群
 3I. 网络连接模式
 4针对海量消息所要求的横向扩展性和系统的高可用性，ActiveMQ提供了网络连接模式的集群功能。简单的说，就是通过把多个不同的broker实例连接在一起，作为一个整体对外提供服务，从而提高整体对外的消息服务能力。通过这种方式连接在一起的broker实例之间，可以共享队列和消费者列表，从而达到分布式队列的目的。
 5II. 拓扑结构
 6几种不同的ActiveMQ部署拓扑结构（嵌入、主从复制、网络连接）：
 7![图12.png](https://upload-images.jianshu.io/upload_images/3110861-22dc6736335faa3e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 8
 9III. 配置示例
10在activemq.xml的broker节点内添加：

<networkconnectoruri=“static:(tcp: style="font-size: inherit; color: inherit; line-height: inherit;"></networkconnectoruri=“static:(tcp:>

1uri也可以使用其他两种方式：

multicast://default
masterslave:(tcp://host1:61616,tcp://host2:61616,tcp://..)

1IV. 静态URI配置
2使用静态URI方式可以指定多个URL，networkConnector将连接到每一个broker。

```
URI的几个属性：

属性	默认值	描述
initialReconnectDelay	1000	重连之前等待的时间(ms) (如果useExponentialBackOff为 false)
maxReconnectDelay	30000	重连之前等待的最大时间(ms)
useExponentialBackOff	true	每次重连失败时是否增大等待时间
backOffMultiplier	2	增大等待时间的系数

文章中涉及到的网络链接，请点击阅读原文查看。

以上是关于分布式--ActiveMQ 消息中间件的主要内容，如果未能解决你的问题，请参考以下文章

Java中间消息件——ActiveMQ入门级运用

分布式--ActiveMQ 消息中间件

分布式消息通信ActiveMQ

分布式--ActiveMQ 消息中间件

学习dubbo：消息中间件activemq -简介

高并发分布式消息中间件技术ActiveMQ事务