JMS —— ActiveMQ 消息中间件

前言：

    我们通过一张图来梳理，为什么要在项目中使用消息中间件   

    

    通过这张项目结构图我们可以看出，运营商后台的调用关系最多，用到了商家商品服务、广告内容服务、搜索服务、页面生成服务，这种模块之间的依赖也称为耦合，而耦合越多之后的维护工作就越困难。那么如何改善系统模块调用关系减少模块之间的耦合呢？jdk中默认存在一种JMS, 就是消息中间件，很好的解决了这种文件。

1. JMS简介：

1.1 什么是JMS

    JMS（Java Messaging Service）是Java平台上有关面向消息中间件的技术规范(技术规范 也就是指接口，在jdk 中已经存在了，就像虽然没有连接数据库，但是数据库的JDBC在jdk中已经存在，只是没有数据库驱动而已)，它便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。

    JMS本身只定义了一系列的接口规范，是一种与厂商无关的 API，用来访问消息收发系统。它类似于 JDBC(java Database Connectivity)：这里，JDBC 是可以用来访问许多不同关系数据库的 API，而 JMS 则提供同样与厂商无关的访问方法，以访问消息收发服务。许多厂商目前都支持 JMS，包括 IBM 的 MQSeries、BEA的 Weblogic JMS service和 Progress 的 SonicMQ，这只是几个例子。 JMS 使您能够通过消息收发服务（有时称为消息中介程序或路由器）从一个 JMS 客户机向另一个 JML 客户机发送消息。消息是 JMS 中的一种类型对象，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的元数据组成。消息主体则携带着应用程序的数据或有效负载。

    JMS 定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。

    ①TextMessage : 一个字符串对象 

    ②MapMessage :一套键值对

    ③ObjectMessage ：一个序列化的java对象

    ④BytesMessage : 一个字节的数据流

    ⑤streamMessage :  java 原始值的数据流

1.2 JMS消息传递类型

    对于消息传递有两种类型:

    一是 点对点：即一个生产者和一个消费者 ，一 一对应关系，就好比两个人 窃窃私语，第三个人是收不到消息的；

一条信息只能被一个消费者消费，且消费完后，这条信息就会被自动释放掉。 Consumer 相对于 Queue 是主动去拿消息。

   

    二是 发布/订阅模式，即一个生产者生产信息并进行发送后，可以有多个消费者进行接收。类似于(大喇叭)广播，Topic中的消息主动推送到 Consumer ，即 Consumer 相对于 Queue 是被动的获取消息。

2. 消息中间件

2.1 什么是消息中间件

        消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有Producer（生产者）、Consumer（消费者）消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有Producer（生产者）、Consumer（消费者）。

      常见的消息中间件产品：

       (1)ActiveMQ

       ActiveMQ是apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS 1.1 和 J2EE 1.4 规范的 JMS Provider 实现。注意：以下的案例都是基于 ActiveMQ 这款消息中间件产品进行开发介绍的。

       (2)RabbitMQ

        AMQP 协议的领导实现，支持多种场景。淘宝的MySQL集群内部有使用它进行通讯，OpenStack 开源云平台的通信组件，最先在金融行业得到应用。

       (3)ZeroMQ

        史上最快的消息队列系统

       (4)Kafka

        Apache 下的一个子项目。特点：高吞吐，在一台普通的服务器上既可以达到10w/s 的吞吐速度，完全的分布式系统。适合处理海量数据。

2.2 对(前言)中的关系图进行改造

    通过引入消息中间件 ActiveMQ，使得运营商系统 与 搜索服务、页面生成服务 解除耦合关系。这个时候 不启动搜索服务 和 页面生成服务的情况下，依然可以起到运营商后台。

    但是，需要注意的是，消息中间件最主要的两个作用就是 ：异步调用 和 解耦合。

   ①异步调用：就是后台发送消息到 中间件 ，而 服务层 检查到 中间件里面的消息以后 才会进行消费消息。

   ②ActiveMQ：类似于一个数据库，存放的数据就是生产者 生产的消息(文本类型，Map类型等)，但是没有数据库那种表结构。

                         它也可以进行持久化 到磁盘。但是 消息中间件的 吞吐量(单位时间内存储的数据量) 要比数据库大很多。

    那么什么情况下可以进行异步调用呢？

    

2.3 ActiveMQ 下载 与 安装

2.3.1 下载

    官方网站下载：http://activemq.apache.org/

2.3.1 安装 (Linux)

    (1) 将 apache-activemq-5.12.0-bin.tar.gz 上传至服务器

    (2) 解压此文件

tar -zxvf apache-activemq-5.12.0-bin.tar.gz

    (3) 为 apache-activemq-5.12.0 赋权

    注意：如果 apache-activemq-5.12.0 有执行权限，则 此步可以省略

chmod 777 apache-activemq-5.12.0

    赋予执行权限的操作：

    先进入 apache-activemq-5.12.0\bin目录

chmod 755 activemq  --------------------------------------  知识点小贴士    -------------------------- linux 命令chmod 755的意思 chmod是Linux下设置文件权限的命令，后面的数字表示不同用户或用户组的权限。 一般是三个数字： 第一个数字表示文件所有者的权限 第二个数字表示与文件所有者同属一个用户组的其他用户的权限 第三个数字表示其它用户组的权限。       权限分为三种：读（r=4），写（w=2），执行（x=1） 。 综合起来还有可读可执行（rx=5=4+1）、可读可写（rw=6=4+2）、可读可写可执行(rwx=7=4+2+1)。       所以，chmod 755 设置用户的权限为：  1.文件所有者可读可写可执行                                    --7 2.与文件所有者同属一个用户组的其他用户可读可执行 --5  3.其它用户组可读可执行                                          --5

    (4) 启动 activemq     提示：先进入 apache-activemq-5.12.0\bin 目录

./activemq start

    如果提示下面的内容，表示已经正常启动

        

    (5) 打开浏览器进行访问 ActiveMQ 管理页面

    根据自己 安装activemq 所在的虚拟机地址，在浏览器中 进行访问ActiveMQ

    本人所安装ActiveMQ 的虚拟机地址：192.168.181.180

    在浏览器中输入：192.168.181.180:8161   即可进入 ActiveMQ 管理页面

   

    注意事项1：

        端口号：ActiveMQ 默认有两个端口号：8161  和 61616

        区别：8161 端口：是 mq 自带的管理后台的端口；

                   61616端口：是 mq 服务端默认的端口，是给 java 用的 tcp 端口

    注意事项2：

        如果是一台新的虚拟机，要正确安装 jdk 和 .ssh 无秘登录 以及 hostname , hosts 否则会报下面的错误

    

    (6) 登录 ActiveMQ

    进入管理页

    

    输入用户名 和 密码 ，用户名和密码都是admin

    

    进入 主界面

    

    点对点 队列模式

    列表各列信息含义如下： 同下 发布订阅 的 主题模式

    Number Of Pending Messages  ：等待消费的消息 这个是当前未出队列的数量。

    Number Of Consumers  ：消费者 这个是消费者端的消费者数量

    Messages Enqueued  ：进入队列的消息  进入队列的总数量,包括出队列的。

    Messages Dequeued  ：出了队列的消息  可以理解为是消费这消费掉的数量。

    发布订阅 主题模式

    

3. JMS 入门小 Demo

    编写JMS 原生 代码实现 过程：

3.1 点对点模式

    点对点的模式主要建立在一个队列上面，当连接一个列队的时候，发送端不需要知道接收端是否正在接收，可以直接向ActiveMQ发送消息，发送的消息，将会先进入队列中，如果有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存在activemq服务器，直到接收端接收消息，点对点的消息模式可以有多个发送端，多个接收端，但是一条消息，只会被一个接收端给接收到，哪个接收端先连上ActiveMQ，则会先接收到，而后来的接收端则接收不到那条消息。

    发送端也称 生产者 ，即：生产消息 并把消息 发送到消息中间件。

    接收端也称 消费者，即：监听 消息中间件中 是否有消息更新，一旦发现有新的消息 就会进行消费。

额外扩展： 监听  和  阻塞的 区别：

    监听：属于异步，后台 到 服务层 不再是一条线式的走法，而是通过 消息中间件 作为一个站点，连接到 后台 和 服务层；

    阻塞：属于同步，后台 到 服务层 就是直接依赖调用，中间没有任何的站点。

3.1.1 消息生产者

    (1) 创建工程(jar)，引入依赖

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-client</artifactId>
    <version>5.13.4</version>
</dependency>

    (2) 创建类 QueueProducer

package cn.itcast.queueProducer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;

public class QueueProducer {
	static MessageProducer producer;
	static Connection connection;
	static Session session;
	
	public static void main(String[] args) {
		try {
			//1.创建一个连接工厂
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.181.180:61616");
			
			//2.创建一个连接对象
			connection = connectionFactory.createConnection();
			
			//3.开启连接
			connection.start();
			
			//4.根据连接对象获得session会话对象
			//参数1:是否开启事务； 参数2: 消息的确认类型
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			
			//5.通过session对象创建目标地点; 参数:中间件的名称
			Destination queue = session.createQueue("queue-text");
			
			//6.通过session对象创建生产者对象
			producer = session.createProducer(queue);
			
			//7.通过session对象创建message
			Message message = session.createTextMessage("欢迎来到神器的品优购世界");
			
			//8.通过生产者发送信息
			producer.send(message);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//9.关闭流
			try {
				producer.close();
				session.close();
				connection.close();
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}
}

   上述代码中，第四步创建 session 的两个参数：

    第一个参数 是否使用事务

    第二个参数 消息的确认模式

        AUTO_ACKNOWLEDGE = 1    自动确认；第一个参数是 false 的情况下 有效   (这种情况最常用)

        CLIENT_ACKNOWLEDGE = 2    客户端手动确认；第一个参数是 false 的情况下 有效

        DUPS_OK_ACKNOWLEDGE = 3    自动批量确认；第一个参数是 false 的情况下 有效

        SESSION_TRANSACTED = 0    事务提交并确认； 第一个参数是 true 的情况下 有效；对于事务性，如果消息中间件接收数据失败，会触发消息重试机制，消息再次向消息中间件发送。

注意：如果使用事务 true，当一个事务被提交的时候 session.commit 才会进行确认，忽略第二个参数

           如果没有使用事务，消息何时确认取决于创建会话的应答模式：

               ①自动确认，receive 方法返回 或者 onMessage 返回，消息自动确认；

               ②客户端确认，需要调用message.acknowledge()

               ③延迟批量确认

     消息确认模式图：3，5，6

    (3) 运行后通过 ActiveMQ 管理界面查询

3.1.2  消息消费者

    (1) 创建类 QueueConsumer

package cn.itcast.queueConsumer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class QueueConsumer {
	static MessageConsumer messageConsumer;
	static Session session;
	static Connection connection;
	public static void main(String[] args) {
		try {
			//1.创建连接工厂
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.181.180:61616");
			
			//2.创建连接对象
			Connection connection = connectionFactory.createConnection();
			
			//3.开启连接
			connection.start();
			
			//4.通过连接对象创建session对象
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			
			//5.通过session对象创建目标地点
			Destination queue = session.createQueue("queue-text");
			
			//6.通过session对象创建消费
			messageConsumer = session.createConsumer(queue);
			
			//7.通过消费者进行监听  消费消息
			messageConsumer.setMessageListener(new MessageListener() {
				
				@Override
				public void onMessage(Message message) {
					TextMessage textMessage = (TextMessage) message;
					try {
						String text = textMessage.getText();
						System.out.println(text);
					} catch (JMSException e) {
						e.printStackTrace();
					}
				}
			});
			
		} catch (JMSException e) {
			e.printStackTrace();
		}finally {
			try {
				// 等待键盘输入内容
				System.in.read();
				
				//9.关闭流
				messageConsumer.close();
				session.close();
				connection.close();;
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

    (2)执行后，控制台输出结果如下：

    (3) 当同时开启 两 个消费者，再次运行生产者，观察每个消费者控制台的输出，会发现只有一个消费者会接收到消息

    

3.2 发布/订阅模式

3.2.1消息生产者

    创建类 TopicProducer

package cn.itcast.topicProducer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class TopicProducer {
	static MessageProducer producer;
	static Session session;
	static Connection connection;
	
	public static void main(String[] args) {
		try {
			//1.创建连接工厂
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.181.180:61616");
			//2.创建连接对象
			connection = connectionFactory.createConnection();
			//3.开启连接
			connection.start();
			//4.通过连接创建session对象
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			//5.通过session对象创建目标地点
			Destination topic = session.createTopic("topic-text");
			//6.通过session对象创建生产者
			producer = session.createProducer(topic);
			//7.通过session对象创建message
			TextMessage message = session.createTextMessage("欢迎来到王者荣耀");
			//8.通过生产者发送信息message
			producer.send(message);
			
		} catch (JMSException e) {
			e.printStackTrace();
		}finally {
			//9.关闭流
			try {
				producer.close();
				session.close();
				connection.close();
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}
}

3.2.1 消息消费者

    创建类 TopicConsumer

package cn.itcast.topicConsumer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class TopicConsumer {
	static MessageConsumer consumer;
	static Session session;
	static Connection connection;
	public static void main(String[] args) {
		try {
			//1.创建连接工厂
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.181.180:61616");
			//2.创建连接对象
			connection = connectionFactory.createConnection();
			//3.开启连接
			connection.start();
			//4.通过连接对象创建session对象
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			//5.通过session对象创建目标地点
			Destination topic = session.createTopic("topic-text");
			//6.通过session对象创建消费者
			consumer = session.createConsumer(topic);
			//7.通过消费者监听   消费消息
			consumer.setMessageListener(new MessageListener() {
				
				@Override
				public void onMessage(Message message) {
					TextMessage textMessage = (TextMessage) message;
					try {
						String text = textMessage.getText();
						System.out.println(text);
					} catch (JMSException e) {
						e.printStackTrace();
					}
				}
			});
		} catch (JMSException e) {
			e.printStackTrace();
		}finally {
			try {
				//键盘输入为停止
				System.in.read();
				//8.关闭流
				consumer.close();
				session.close();
				connection.close();
			} catch (Exception e) {
				e.printStackTrace();
			}	
		}
	}
}

    (3)当开启 两 个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现每个消费者都会接收到消息

4. Spring 整合 JMS

4.1 点对点模式

4.1.1 消息生产者

    (1) 创建一个maven 工程(jar)，在 pom 文件中引入 SpringJms、ActiveMQ 以及单元测试相关的依赖

<properties>		
	<spring.version>4.2.4.RELEASE</spring.version>
</properties>
  
<dependencies>
	<!-- Spring -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
		<version>${spring.version}</version>
	</dependency>		
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jms</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.apache.activemq</groupId>
		<artifactId>activemq-all</artifactId>
		<version>5.11.2</version>
	</dependency>  	  	
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.9</version>
	</dependency>
</dependencies>

<build>
	<plugins>			
		<!-- java编译插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.2</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
				<encoding>UTF-8</encoding>
			</configuration>
		</plugin>
	</plugins>
</build>

    (2) 在resource 下创建 spring 配置文件 applicationContext-jms-producer.xml (生产者所需要的 bean)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context   
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms.xsd">
		
	<context:component-scan base-package="cn.itcast.demo"/>
   
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
	    <property name="brokerURL" value="tcp://192.168.181.180:61616"/>  
	</bean>
	   
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
	<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
	    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
	</bean>  
		   
    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->  
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
	    <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	</bean>      
    <!--这个是队列目的地，点对点的  文本信息-->  
	<bean id="queueSmsDestination" class="org.apache.activemq.command.ActiveMQQueue">  
	    <constructor-arg value="sms"/>  
	</bean>    
	
</beans>

    (3) 创建一个包：cn.itcast.demo    在此包下 创建一个生产者类：QueueProducer

package cn.itcast.demo;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

@Component
public class QueueProducer {
	@Autowired
	private JmsTemplate jmsTemplate;//注入jms模板
	@Autowired
	private Destination queueTextDestination;//注入目的地点
	
	public void sendTextMessage(String text) {
		//bean中已配置tcp协议
		//参数1:目的地点 ；参数2:创建消息
		jmsTemplate.send(queueTextDestination,new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(text);
			}
		});
	}
}

    (4) 单元测试，进行发送消息

package cn.itcast.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-activemq-producer.xml")
public class TestQueueProducer {
	//需要注入一个生产者，进行发送信息
	@Autowired
	private QueueProducer queueProducer;
	
	@Test
	public void testName() throws Exception {
		queueProducer.sendTextMessage("王者荣耀欢迎你的加入");
	}
}

 4.1.2消息消费者

    (1) 创建一个maven 工程 (jar)，在 pom 文件中引入 依赖，与 消息生产者 工程的pom依赖一样

    (2) 创建配置文件 applicationContext-activemq-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context   
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms.xsd">
	
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
	    <property name="brokerURL" value="tcp://192.168.181.180:61616"/>  
	</bean>
	   
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
	<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
	    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
	</bean>  
	
    <!--这个是队列目的地，点对点的  文本信息-->  
	<bean id="queueTextDestination" class="org.apache.activemq.command.ActiveMQQueue">  
	    <constructor-arg value="queue_text"/>  
	</bean>    
	
	<!-- 我的监听类 -->
	<bean id="myMessageListener" class="cn.itcast.demo.MyMessageListener"></bean>
	<!-- 消息监听容器 -->
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="queueTextDestination" />
		<property name="messageListener" ref="myMessageListener" />
	</bean>
	
</beans>

    (3) 编写 消费者(监听者)类

package cn.itcast.demo;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class MyMessageListener implements MessageListener{

	@Override
	public void onMessage(Message message) {
		TextMessage textMessage =(TextMessage) message;
		try {
			String text = textMessage.getText();
			System.out.println(text);
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}
	
}

    (4) 创建测试类 ，进行消费信息

package cn.itcast.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-activemq-consumer.xml")
public class TestMessageListener {
	@Test
	public void testName() throws Exception {
		System.in.read();
	}
}

4.2 发布/订阅模式

4.2.1 消息生产者

    (1) 创建一个 maven 工程，在 pom 文件中添加依赖 ，同上

    (2) 创建配置文件 applicationContext-activemq-producer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context   
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms.xsd">
		
		
	<context:component-scan base-package="cn.itcast.demo"></context:component-scan>     
	
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
	    <property name="brokerURL" value="tcp://192.168.181.180:61616"/>  
	</bean>
	   
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
	<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
	    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
	</bean>  
		   
    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->  
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
	    <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	</bean>      
    <!--这个是队列目的地，点对点的  文本信息-->
<!-- 
	<bean id="queueTextDestination" class="org.apache.activemq.command.ActiveMQQueue">  
	    <constructor-arg value="queue_text"/>  
	</bean>    
 -->	
	<!--这个是订阅模式  文本信息-->  
	<bean id="topicTextDestination" class="org.apache.activemq.command.ActiveMQTopic">  
	    <constructor-arg value="topic_text"/>  
	</bean>
 
	
</beans>

    (3) 创建生产者 类

package cn.itcast.demo;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

@Component
public class TopicProducer {
	@Autowired
	private JmsTemplate jmsTemplate;
	
	@Autowired
	private Destination topicTextDestination;
	
	public void sendTextMessage(String text) {
		jmsTemplate.send(topicTextDestination, new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(text);
			}
		});
	}
}

    (4) 编写 测试类 进行生产消息

package cn.itcast.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-activemq-producer.xml")
public class TestProducer {
	//需要一个生产者进行发送信息
	@Autowired
	private TopicProducer topicProducer;
	
	@Test
	public void testName() throws Exception {
		topicProducer.sendTextMessage("王者荣耀等你归来");
	}
}

4.2.1 消息消费者

    (1) 创建一个maven 工程，在 pom 文件里面添加依赖，同上

    (2) 创建一个配置文件 applicationContext-activemq-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context   
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms.xsd">
	
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
	    <property name="brokerURL" value="tcp://192.168.181.180:61616"/>  
	</bean>
	   
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
	<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
	    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
	</bean>  
	
    <!--这个是订阅模式  文本信息-->  
	<bean id="topicTextDestination" class="org.apache.activemq.command.ActiveMQTopic">  
	    <constructor-arg value="topic_text"/>  
	</bean>    
	
	<!-- 我的监听类 -->
	<bean id="myMessageListener" class="cn.itcast.demo.MyMessageListener"></bean>
	<!-- 消息监听容器 -->
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="topicTextDestination" />
		<property name="messageListener" ref="myMessageListener" />
	</bean>
	
</beans>

    (3) 创建一个 消费者(监听者) 类 ，可以同 topic 的点对点模式 公有一个监听者，也可以重写写一个新的，根据你的性格来

package cn.itcast.demo;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class MyMessageListener implements MessageListener{

	@Override
	public void onMessage(Message message) {
		TextMessage textMessage = (TextMessage) message;
		try {
			String text = textMessage.getText();
			System.out.println(text);
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}
}

    (4) 编写测试类 用于 消费 消息中间件中的数据

package cn.itcast.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-activemq-consumer.xml")
public class TestMessageListener {
	@Test
	public void testName() throws Exception {
		System.in.read();
	}
}