版权声明：文章为作者自己原创文章，转载请注明出处。 https://blog.csdn.net/qq_37128049/article/details/84950701
今日目标
1. 理解消息中间件，JMS等概念
2. 掌握JMS点对点与发布订阅模式的收发消息
3. 掌握SpringJms
4. 完成商品详细页静态化
5. 完成商品审核发送消息的功能
前述：
1. 什么是消息中间件
- 消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有 Producer（生产者）、Consumer（消费者）；
- 简单来讲，它相当于一个菜鸟驿站，快递员将快递放到菜鸟驿站里，你可以今天也可以明天去取，因为有这样一个中转的地方能存储快递；
2. 什么是中间件？
* 中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。中间件位于客户机/ 服务器的操作系统之上，管理计算机资源和网络通讯。是连接两个独立应用程序或独立系统的软件。相连接的系统，即使它们具有不同的接口，但通过中间件相互之间仍能交换信息。执行中间件的一个关键途径是信息传递。通过中间件，应用程序可以工作于多平台或OS环境。
3. 中间件的通用特点： 【之前的注册中心也是一个中间件】
1. 满足大量应用的需要；
2. 运行于多种硬件和OS平台；
3. 支持分布计算，提供跨网络、硬件和OS平台的透明性的应用或服务的交互；
4. 支持标准的协议；
5. 支持标准的接口。‘
4. 消息中间件解决了哪些问题？
* 它解决了模块与模块之间的异步调用关系；[不必实时启动服务]
* 解耦合
* 提高运行的性能 [数据是存在内存中，读取非常快]
5. 常见的消息中间件产品？
1. ActiveMQ
ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现。我们在本次课程中介绍 ActiveMQ 的使用。
2. RabbitMQ
AMQP 协议的领导实现，支持多种场景。淘宝的 MySQL 集群内部有使用它进行通讯，OpenStack 开源云平台的通信组件，最先在金融行业得到运用。
3. ZeroMQ
史上最快的消息队列系统
4. Kafka
Apache 下的一个子项目 。特点：高吞吐，在一台普通的服务器上既可以达到 10W/s的吞吐速率；完全的分布式系统。适合处理海量数据。
6. 消息中间件适合哪些地方？
* 执行时间可能比较长，不需要实时返回数据的地方【只需要调用，不需要结果】；
JSM
1. JMS简介：
1. 每个语言都有类似的消息中间件，在java语言中，我们使用的是JMS消息中间件；
2. JMS（Java Messaging Service）是 Java 平台上有关面向消息中间件的技术规范，它便于消息系统中的 Java 应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。
3. JMS 本身只定义了一系列的接口规范，是一种与厂商无关的 API，用来访问消息收发系统。它类似于 JDBC(java Database Connectivity)：这里，JDBC 是可以用来访问许多不同关系数据库的 API，而 JMS 则提供同样与厂商无关的访问方法，以访问消息收发服务。许多厂商目前都支持 JMS，包括 IBM 的 MQSeries、BEA 的 Weblogic JMS service 和 Progress 的SonicMQ，这只是几个例子。 JMS 使您能够通过消息收发服务（有时称为消息中介程序或路由器）从一个 JMS 客户机向另一个 JML 客户机发送消息。消息是 JMS 中的一种类型对象，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的元数据组成。消息主体则携带着应用程序的数据或有效负载。
2. JSM的正文格式：
* JMS 定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。
· TextMessage--一个字符串对象
· MapMessage--一套名称-值对
· ObjectMessage--一个序列化的 Java 对象 【实现了可序列化接口的】
· BytesMessage--一个字节的数据流
· StreamMessage -- Java 原始值的数据流
3. JMS的消息传递类型
1. 点对点：一个生产者和一个消费者一一对应
2. 发布/订阅模式：即一个生产者产生消息并进行发送后，可以由多个消费者进行接收
4. 下载安装：
1. 下载
官方网站下载：http://activemq.apache.org/
2. 安装（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 目录赋权
chmod 777 apache-activemq-5.12.0
4. 进入 apache-activemq-5.12.0\bin 目录
5. 赋与执行权限
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. 启动
./activemq start
6. 测试
假设服务器地址为 192.168.25.135 ，打开浏览器输入地址
http://192.168.25.135:8161/ 即可进入 ActiveMQ 管理页面
7. 登录：
输入用户名和密码 均为 admin
8. 界面释义：
* 列表各列信息含义如下：
Number Of Pending Messages ： 等待消费的消息 这个是当前未出队列的数量。
Number Of Consumers ： 消费者 这个是消费者端的消费者数量
Messages Enqueued ： 进入队列的消息 进入队列的总数量,包括出队列的。
Messages Dequeued ： 出了队列的消息 可以理解为是消费这消费掉的数量。
入门Demo
1. 点对点模式：
1. 概述：
点对点的模式主要建立在一个队列上面，当连接一个列队的时候，发送端不需要知道接收端是否正在接收，可以直接向 ActiveMQ 发送消息，发送的消息，将会先进入队列中，如果有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存在 activemq 服务器，直到接收端接收消息，点对点的消息模式可以有多个发送端，多个接收端，但是一条消息，只会被一个接收端给接收到，哪个接收端先连上 ActiveMQ，则会先接收到，而后来的接收端则接收不到那条消息。
2. 消息生产者
1. 创建工程 jmsDemo ，引入依赖
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-client</artifactId>
<version>5.13.4</version>
</dependency>
2. 创建类 QueueProducer main 方法代码如下：
//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();
3. 注意：
上述代码中第 4 步创建 session 的两个参数：
第 1 个参数 是否使用事务
第 2 个参数 消息的确认模式
AUTO_ACKNOWLEDGE = 1 自动确认
CLIENT_ACKNOWLEDGE = 2 客户端手动确认
DUPS_OK_ACKNOWLEDGE = 3 自动批量确认
SESSION_TRANSACTED = 0 事务提交并确认
4. 运行后通过 ActiveMQ 管理界面查询
3. 消息消费者
1. 创建类 QueueConsumer ，main 方法代码如下：
//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.创建消息消费
MessageConsumer consumer = session.createConsumer(queue);
//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. 运行测试
同时开启 2 个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现只有一个消费者会接收到消息。
2. 发布/订阅模式
1. 消息生产者， 创建类 TopicProducer ，main 方法代码如下：
//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. 消息消费者：创建类 TopicConsumer ,main 方法代码如下：
//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();
3. 运行测试
同时开启 2 个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现
每个消费者会接收到消息。
3. 区别特点：
1. 一对一的消息队列方式，即便当时没有收到，后来才启动了服务，也能收到之前的信息，它是一对一的，只能有一个人收到消息；
2. 广播订阅机制则类似于广播电台，只有打开了接收信息的服务才能接收到信息，如果后面才打开是收不到以前的信息，它是实时的，它是一对多的，只要打开服务的都能收到消息；
Spring JMS 点对点：
1. 注意：
* 在发送信息中的sendTextMessage(String text),该text变量必须用final来修饰；即：sendTextMessage(final String text)
2. 点对点生产者：
1. pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<packaging>jar</packaging>
<groupId>cn.itcast.demo</groupId>
<artifactId>springjms_producer</artifactId>
<version>1.0-SNAPSHOT</version>
<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>
</project>
2. QueueProducer.java:
package cn.itcast.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
@Component
public class QueueProducer {
@Autowired
private JmsTemplate jmsTemplate;
@Autowired
private Destination queueTextDestination;
/*
*
* 发送文本信息
* */
public void sendTextMessage(final String text){
jmsTemplate.send(queueTextDestination, new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage(text);
}
});
}
}
3. resources/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.25.128: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>
2. 点对点消费者：
1. pom.xml: 与生产者一样
2. resources/applicationContext-activemq-consumer-queue.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.25.128: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. MyMessageListener.java:
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 {
public void onMessage(Message message) {
TextMessage textMessage=(TextMessage)message;
try {
System.out.println("接收到消息:"+textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
4. 测试：
1. 生产者： test.java:
package cn.itcast;
import cn.itcast.demo.QueueProducer;
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(locations = "classpath:applicationContext-activemq-producer.xml")
public class test {
@Autowired
private QueueProducer queueProducer;
@Test
public void testSendMessage(){
queueProducer.sendTextMessage("hello,world");
}
}
2. 消费者： TestQueue.java:
package cn.itcast.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.IOException;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext-activemq-consumer-queue.xml")
public class TestQueue {
@Test
public void testQueue(){
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. 总结：
1. 生产者:配置好pom.xml，和resources环境后再配置发送信息的QueueProducer,可运行test生产者测试类，然后查看http://192.168.25.128:8161中是否已经有其记录
2. 先配置好pom.xml,resources环境后再配置接收信息的MyMessageListener.java,然后运行测试类即可接收到生产者发送的信息；
实战总结
1. 点对点：
1. 搜索服务如何使用JMS中间件？在搜索服务中我们只需要搜索一次即可，即点对点，所以我们可以使用队列的方式使用JMS消息中间件实现解耦合和异步调用；
2. 如何实现？
1. 生产者：首先导入相关依赖包，导入配置文件xml:设置好ip地址，队列名称等,然后可以在商品审核通过后使用消息中间件导入索引库；导入索引库是将商品的详细信息存入solr库以便于快捷查找；
2. 消费者：导入相关依赖包，导入配置文件，设置好ip地址，队列名称，以及监听类名称等，然后创建监听类，监听生产者是否发送信息，若发送了接收过来值并注入操作存储索引库的类调用存储方法，或者删除方法即可；
2. 订阅模式：
1. 在集群中，可以使用订阅模式，这样每个服务器都能收到相同的信息并进行部署；
2. 消费者：导入相关依赖，xml配置文件，并配置好ip，订阅等配置；在Controller.java中的生成商品详细页的方法可以使用订阅模式，因为它后面会用集群实现，遍历id数组，然后调用jmsTemplate.send方法发送id值；
3. 生产者：导入activeMQ和jms依赖，然后导入xml配置文件，配置ip地址，队列名称，id值，监听器名称等...然后写监听类监听到的值然后调用注入的类调用相关方法实现操作；
3. 注意：
1. 因为使用了消息中间件，所以消息的通知是通过avtiveMQ来进行的，不通过dubbox,所以相关dubbox可以解除依赖，不解除依赖即为无用代码；
2. 删除dubbox后，注解service会失效，可以不使用dubbox的service注解，使用spring的注解4
3. 在注入Destination的时候，如果只有一个的话不用考虑名称，如果有多个的话，命名规格必须跟xml文件中配置的id值一样；
4. 一个队列或者订阅消息只代表一个操作，如果即要添加，又要实现删除操作，是需要创建两个队列或者两个订阅消息的配置的；
5. JMS是一个规范，它没有实现类，都是一套接口，而ActiveMQ是根据jMS规范而开发出的一套产品！规范只有一个，但类似产品有几个，它们使用方式基本一样，只是相关工厂可能不同；