学习品优购总结[十三](消息中间件解决方案JMS)

目前为止已经创建了多个服务，模块之间的依赖（耦合）变得越来越多，随着耦合的增多，项目维护起来就非常困难了。所以需要使用消息中间件来解决此难题。

什么是消息中间件

消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有Producer（生产者）、Consumer（消费者）。
常见的消息中间件产品：
（1）ActiveMQ（2）RabbitMQ（3）ZeroMQ（4）Kafka（5）RocketMQ：阿里消息中间件
为什么使用消息中间件：
通过消息中间件处理耦合：
消息中间件是什么

JMS

JMS（Java Messaging Service）是Java平台上有关面向消息中间件的技术规范，便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。JMS本身只定义了一系列的接口规范，是一种与厂商无关的 API，用来访问消息收发系统。它类似于 JDBC(java Database Connectivity)。
JMS 定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。

    · TextMessage--一个字符串对象
    · MapMessage--一套名称-值对
    · ObjectMessage--一个序列化的 Java 对象
    · BytesMessage--一个字节的数据流
    · StreamMessage -- Java 原始值的数据流

知道了消息的格式后，还需要知道消息是按照什么方式进行传递的
（1）点对点：哪个消费者先开服务，就从是哪个消费者接收消息（2）发布/订阅

ActiveMQ下载与安装

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

JMS入门Demo

引入依赖：

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

1.点对点
主要建立在一个队列上面，发送端并不知道接收端是否正在等待接收也可以直接向ActiveMQ发送消息，发送的消息会先进入队列中，如果有接收端在监听那么直接会发向接收端，如果没有接收端正在接收，那么就会暂时保存在ActiveMQ服务器中直到接收端接收消息，点对点也可以有多个接收端和多个发送端但是一条消息只会被一个接收端接收到，哪个接收端先连接上ActiveMQ哪一个接收端就会先接收到，后面的都接收不到。
(1)消息生产者

	//1.创建连接工厂
	ConnectionFactory connectionFactory=new ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
	//2.获取连接
	Connection connection = connectionFactory.createConnection();
	//3.启动连接
	connection.start();
	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式)
	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);		
	//5.创建队列对象
	Queue queue = session.createQueue("test-queue");
	//6.创建消息生产者
	MessageProducer producer = session.createProducer(queue);
	//7.创建消息
	TextMessage textMessage = session.createTextMessage("欢迎来到神奇的品优购世界");
	//8.发送消息
	producer.send(textMessage);
	//9.关闭资源
	producer.close();
	session.close();
	connection.close();

注：
第1个参数 是否使用事务
第2个参数 消息的确认模式
AUTO_ACKNOWLEDGE = 1 自动确认
CLIENT_ACKNOWLEDGE = 2 客户端手动确认
DUPS_OK_ACKNOWLEDGE = 3 自动批量确认
SESSION_TRANSACTED = 0 事务提交并确认
（2）消息消费者

	//1.创建连接工厂，ActiceMQ的传输协议是tcp协议，所以需要加上tcp://
	ConnectionFactory connectionFactory=new ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
	//2.获取连接
	Connection connection = connectionFactory.createConnection();
	//3.启动连接
	connection.start();
	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式)
	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
	//5.创建队列对象，与创建者的队列名称必须一样
	Queue queue = session.createQueue("test-queue");
	//6.创建消息消费
	MessageConsumer consumer = session.createConsumer(queue);
	//7.监听消息，通过匿名内部类实现方法接收消息并转换为Text类型的消息
	consumer.setMessageListener(new MessageListener() {
		public void onMessage(Message message) {
			TextMessage textMessage=(TextMessage)message;
			try {
				System.out.println("接收到消息："+textMessage.getText());
			} catch (JMSException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	});	
	//8.等待键盘输入，可以将方法暂停执行
	System.in.read();	
	//9.关闭资源
	consumer.close();
	session.close();
	connection.close();

同时开启2个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现只有一个消费者会接收到消息。
2.发布/订阅模式
（1） 消息生产者

	//1.创建连接工厂
	ConnectionFactory connectionFactory=new ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
	//2.获取连接
	Connection connection = connectionFactory.createConnection();
	//3.启动连接
	connection.start();
	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式)
	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
	//5.创建主题对象
	Topic topic = session.createTopic("test-topic");
	//6.创建消息生产者
	MessageProducer producer = session.createProducer(topic);
	//7.创建消息
	TextMessage textMessage = session.createTextMessage("欢迎来到神奇的品优购世界");
	//8.发送消息
	producer.send(textMessage);
	//9.关闭资源
	producer.close();
	session.close();
	connection.close();

（2）消息消费者

	//1.创建连接工厂
	ConnectionFactory connectionFactory=new ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
	//2.获取连接
	Connection connection = connectionFactory.createConnection();
	//3.启动连接
	connection.start();
	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式)
	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
	//5.创建主题对象
	//Queue queue = session.createQueue("test-queue");
	Topic topic = session.createTopic("test-topic");
	//6.创建消息消费
	MessageConsumer consumer = session.createConsumer(topic);
	
	//7.监听消息
	consumer.setMessageListener(new MessageListener() {
		public void onMessage(Message message) {
			TextMessage textMessage=(TextMessage)message;
			try {
				System.out.println("接收到消息："+textMessage.getText());
			} catch (JMSException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	});
	//8.等待键盘输入
	System.in.read();
	//9.关闭资源
	consumer.close();
	session.close();
	connection.close();	

同时开启2个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现每个消费者会接收到消息。

Spring整合JMS

1.点对点模式
（1）消息生产者
配置文件：

<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供，指定ActiveMQ的安装地址和端口-->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
    <property name="brokerURL" value="tcp://192.168.25.135: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>      
<!--这个是队列目的地，点对点的文本信息，指定队列的名称为queue_text-->  
<bean id="queueTextDestination" class="org.apache.activemq.command.ActiveMQQueue">  
    <constructor-arg value="queue_text"/>  
</bean>

创建生产者类

	@Autowired
	private JmsTemplate jmsTemplate;

	@Autowired
	private Destination queueTextDestination;
	
	public void sendTextMessage(final String text){//匿名内部类使用外部变量，外部变量需要指定为final修饰
		jmsTemplate.send(queueTextDestination, new MessageCreator() {			
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(text);
			}
		});		
	}

（2）创建消费者
配置文件：

	 <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
	    <property name="brokerURL" value="tcp://192.168.25.135: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>

监听类：

    public class MyMessageListener implements MessageListener {
    	public void onMessage(Message message) {
    	TextMessage textMessage=(TextMessage)message;		
    		try {
    			System.out.println("接收到消息："+textMessage.getText());
    		} catch (JMSException e) {
    			e.printStackTrace();
    		}
    	}
    }

2.发布/订阅模式
（1）消息生产者

<!--这个是订阅模式  文本信息-->  
<bean id="topicTextDestination" class="org.apache.activemq.command.ActiveMQTopic">  
    <constructor-arg value="topic_text"/>  
</bean>
//将队列模式的此处替换为下面配置，在生产者类中只需要将queueTextDestination替换为topicTextDestination

（2）消息消费者

 	<!--这个是队列目的地，点对点的  文本信息-->  
	<bean id="topicTextDestination" class="org.apache.activemq.command.ActiveMQTopic">  
	    <constructor-arg value="topic_text"/>  
	</bean>  

注：测试的时候监听类需要System.in.read();等待键盘输入。