1.目前我们已经完成了商品和搜索系统的开发。我们思考一下,是否存在问题?
- 商品的原始数据保存在数据库中,增删改查都在数据库中完成。
- 搜索服务数据来源是索引库,如果数据库商品发生变化,索引库数据不能及时更新。
2.如果我们在后台修改了商品的价格,搜索页面依然是旧的价格,这样显然不对。该如何解决?这里有两种解决方案:
- 方案1:每当后台对商品做增删改操作,同时要修改索引库数据
- 方案2:搜索服务对外提供操作接口,后台在商品增删改后,调用接口
以上两种方式都有同一个严重问题:就是代码耦合,后台服务中需要嵌入搜索和商品页面服务,违背了微服务的独立
原则。
所以,我们会通过另外一种方式来解决这个问题:消息队列
一:消息中间件简介
1.作用
解耦:
在项目启动之初是很难预测未来会遇到什么困难的,消息中间件在处理过程中插入了一个隐含的,基于数据的接口层,两边都实现这个接口,这样就允许独立的修改或者扩展两边的处理过程,只要两边遵守相同的接口约束即可。
冗余(存储):
在某些情况下处理数据的过程中会失败,消息中间件允许把数据持久化知道他们完全被处理
扩展性:
消息中间件解耦了应用的过程,所以提供消息入队和处理的效率是很容易的,只需要增加处理流程就可以了。
流量控制,削峰:
在访问量剧增的情况下,但是应用仍然需要发挥作用,但是这样的突发流量并不常见。而使用消息中间件采用队列的形式可以减少突发访问压力,不会因为突发的超时负荷要求而崩溃
可恢复性:
当系统一部分组件失效时,不会影响到整个系统。消息中间件降低了进程间的耦合性,当一个处理消息的进程挂掉后,加入消息中间件的消息仍然可以在系统恢复后重新处理
顺序保证:
在大多数场景下,处理数据的顺序也很重要,大部分消息中间件支持一定的顺序性
缓冲:
消息中间件通过一个缓冲层来帮助任务最高效率的执行
异步通信:
通过把把消息发送给消息中间件,消息中间件并不立即处理它,后续在慢慢处理。
2.特点
1)分布式
消息中间件都是分布式的,因此才可以提供异步、解耦等功能。
2)可靠性
基于消息的通信是可靠的,消息不会丢失。大多数消息中间件都提供将消息持久化到磁盘的功能。
3)异步
通过消息中间件,可将远程同步调用拆解成为异步调用。对于不需要获取远程调用结果的应用场景来说,性能提升明 显。
4)松耦合
消息直接由中间件存储和分发。消息生产者只需关注如何将消息发送给消息中介服务器;消费者只需关注如何从中介服务器订阅。生产者和消费者之间是完全解耦的,不需要知道彼此的存在。
5)事件驱动
可以将复杂的应用系统重构成为事件驱动的系统
3.概述
消息队列是典型的:生产者、消费者模型。生产者不断向消息队列中生产消息,消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的,而且只关心消息的发送和接收,没有业务逻辑的侵入,这样就实现了生产者和消费者的解耦。
结合前面所说的问题:
- 商品服务对商品增删改以后,无需去操作索引库,只是发送一条消息,也不关心消息被谁接收。
- 搜索服务服务接收消息,去处理索引库。
如果以后有其它系统也依赖商品服务的数据,同样监听消息即可,商品服务无需任何代码修改。
1)大多应用中,可通过消息服务中间件来提升系统异步通信、扩展解耦能力
2)消息服务中两个重要概念:
消息代理(message broker)和目的地(destination)。当消息发送者发送消息以后,将由消息代理接管,消息代理保证消息传递到指定目的地。
3)消息队列主要有两种形式的目的地
队列(queue):点对点消息通信(point-to-point)
主题(topic):发布(publish)/订阅(subscribe)消息通信
4)点对点式
- 消息发送者发送消息,消息代理将其放入一个队列中,消息接收者从队列中获 取消息内容,消息读取后被移出队列
- 消息只有唯一的发送者和接受者,但并不是说只能有一个接收者
5)发布订阅式
发送者(发布者)发送消息到主题,多个接收者(订阅者)监听(订阅)这个 主题,那么就会在消息到达时同时收到消息
6)JMS(Java Message Service)JAVA消息服务
基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现
7)AMQP(Advanced Message Queuing Protocol)
- 高级消息队列协议,也是一个消息代理的规范,兼容JMS
- RabbitMQ是AMQP的实现
注:JMS和AMQP两者间的区别和联系:
- JMS是定义了统一的接口,来对消息操作进行统一;AMQP是通过规定协议来统一数据交互的格式
- JMS限定了必须使用Java语言;AMQP只是协议,不规定实现方式,因此是跨语言的。
- JMS规定了两种消息模型;而AMQP的消息模型更加丰富
8)Spring支持
- spring-jms提供了对JMS的支持
- spring-rabbit提供了对AMQP的支持
- 需要ConnectionFactory的实现来连接消息代理
- 提供JmsTemplate、RabbitTemplate来发送消息
- @JmsListener(JMS)、@RabbitListener(AMQP)注解在方法上监听消息 代理发布的消息
- @EnableJms、@EnableRabbit开启支持
9)Spring Boot自动配置
- JmsAutoConfiguration
- RabbitAutoConfiguration
10)市面的MQ产品
ActiveMQ、RabbitMQ、RocketMQ、Kafka
二:RabbitMQ简介和概述
1.简介
RabbitMQ是使用Erlang语言开发的开源消息队列系统,基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、安全。AMQP协议更多用在企业系统内对数据一致性、稳定性和可靠性要求很高的场景,对性能和吞吐量的要求还在其次。
优点:由于erlang语言的高并发特性,性能较好;吞吐量到万级,MQ功能比较完备,健壮、稳定、易用、跨平台、支持多种语言,支持AJAX文档齐全,开源提供的管理界面非常棒,用起来很好用,社区活跃度高;更新频率相当高。
缺点:商业版需要收费,学习成本较高。
2.核心概念
1)Message——消息
消息,消息是不具名的,它由消息头和消息体组成。消息体是不透明的,而消息头则由一系列的可选属性组成, 这些属性包括routing-key(路由键)、priority(相对于其他消息的优先权)、delivery-mode(指出该消息可 能需要持久性存储)等。
2)Publisher——生产者
消息的生产者,也是一个向交换器发布消息的客户端应用程序。
3)Exchange——交换器
交换器,用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
Exchange有4种类型:direct(默认),fanout, topic, 和headers,不同类型的Exchange转发消息的策略有所区别
4)Queue——消息队列
消息队列,用来保存消息直到发送给消费者。它是消息的容器,也是消息的终点。一个消息可投入一个或多个队列。消息一直 在队列里面,等待消费者连接到这个队列将其取走。
5)Consumer——消费者
消息的消费者,表示一个从消息队列中取得消息的客户端应用程序。
6)Binding——绑定
绑定,用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则,所以可以将交 换器理解成一个由绑定构成的路由表。
Exchange 和Queue的绑定可以是多对多的关系。
7)Channel——信道
信道,多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接,AMQP 命令都是通过信道 发出去的,不管是发布消息、订阅队列还是接收消息,这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都 是非常昂贵的开销,所以引入了信道的概念,以复用一条 TCP 连接。
8)Virtual Host——虚拟主机
虚拟主机,表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加 密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器,拥 有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础,必须在连接时 指定,RabbitMQ 默认的 vhost 是 / 。
9)Broker——服务器实体
表示消息队列服务器实体
三:docker容器安装RabbitMQ
1.下载
官网下载地址:http://www.rabbitmq.com/download.html
官方文档:https://www.rabbitmq.com/networking.html
2.安装
2.1 docker容器下载RabbitMQ
docker pull rabbitmq:management
2.2 创建实例并启动
docker run -d --name rabbitmq --publish 5671:5671 --publish 5672:5672 --publish 4369:4369 --publish 25672:25672 --publish 15671:15671 --publish 15672:15672 rabbitmq:management
注:
4369 – erlang发现口
5672 --client端通信口,AMQP端口
15672 – 管理界面ui端口,web管理后台端口
25672 – server间内部通信口,集群端口
2.3 修改rabbitMQ为开机自启
docker update rabbitmq --restart=always
2.4 测试页面
在web浏览器中输入地址:http://你虚拟机ip:15672/
输入默认账号: guest : guest
注:如果服务器无法访问15672端口,记得在服务器中开通15672端口权限
2.5 页面参数
overview:概览,各种统计信息,图表,也可以通过export definitions导出配置,转移到其他mq里面
connections:无论生产者还是消费者,都需要与RabbitMQ建立连接后才可以完成消息的生产和消费,在这里可以查看连接情况
channels:通道,建立连接后,会形成通道,消息的投递获取依赖通道。
Exchanges:交换机,用来实现消息的路由
Queues:队列,即消息队列,消息存放在队列中,等待消费,消费后被移除队列。
admin:mq的管理和设置,添加用户信息,分配虚拟主机等
2.6 管理界面-admin
2.6.1. 添加用户
如果不使用guest,我们也可以自己创建一个用户
1、 超级管理员(administrator)
可登陆管理控制台,可查看所有的信息,并且可以对用户,策略(policy)进行操作。
2、 监控者(monitoring)
可登陆管理控制台,同时可以查看rabbitmq节点的相关信息(进程数,内存使用情况,磁盘使用情况等)
3、 策略制定者(policymaker)
可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
4、 普通管理者(management)
仅可登陆管理控制台,无法看到节点信息,也无法对策略进行管理。
5、 其他
无法登陆管理控制台,通常就是普通的生产者和消费者。
2.6.2. 创建Virtual Hosts
虚拟主机:类似于mysql中的database。他们都是以“/”开头
四:RabbitMQ运行机制——Exchange 类型
AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS 存在一些差别,AMQP 中增加了 Exchange 和Binding 的角色。生产者把消息发布到 Exchange 上,消息最终到达队列并被消费者接收,而 Binding 决定交 换器的消息应该发送到那个队列。
Exchange分发消息时根据类型的不同分发策略有区别,目前共四种类型:direct、fanout、topic、headers 。headers 匹配 AMQP 消息的 header 而不是路由键,headers 交换器和 direct 交换器完全一致,但性能差很多,目前几乎用不到了,所以直接 看另外三种类型:
4.1 direct Exchange
消息中的路由键(routing key)如果和Binding 中的 binding key 一致, 交换器 就将消息发到对应的队列中。路由键与队 列名完全匹配,如果一个队列绑定到交换 机要求路由键为“dog”,则只转发 routing key 标记为“dog”的消息,不会转发“dog.puppy”,也不会转发“dog.guard” 等等。它是完全匹配、单播的模式。
4.2 fanout Exchange
每个发到 fanout 类型交换器的消息都 会分到所有绑定的队列上去。fanout 交 换器不处理路由键,只是简单的将队列 绑定到交换器上,每个发送到交换器的 消息都会被转发到与该交换器绑定的所 有队列上。很像子网广播,每台子网内 的主机都获得了一份复制的消息。fanout 类型转发消息是最快的。
4.3 topic Exchange
topic 交换器通过模式匹配分配消息的 路由键属性,将路由键和某个模式进行匹配,此时队列需要绑定到一个模式上。 它将路由键和绑定键的字符串切分成单 词,这些单词之间用点隔开。它同样也 会识别两个通配符:符号“#”和符号“*”。#匹配0个或多个单词,*匹配一 个单词。
4.4 direct直接交换机演示
1)首先创建出四个队列,如下图
2)创建direct类型的交换机
3)将exchange.direct交换机与四个队列进行绑定
4)在交换机里测试给sysg.news发送消息
5)此时消息就接受到了
注:
nack message requeue true : 接收消息,并且不在队列中删除
automatic ack :获取玩消息后,在队列中删除消息,保证消费消息
4.5 fanout交换机演示
1)创建exchange.fanout交换机
2)给交换机绑定如下四个队列
3)给sysg.emps队列发送消息
4)查看哪些队列收到了消息
此时发现四个队列都接受到了消息,所以fanout每个队列都会接收到消息
4.6 topic交换机演示
1)创建exchange.topic交换机
2)给交换机绑定如下四个队列
注:路由键的名称需要特别注意一下,模糊匹配
3)给sysg.newss队列发送消息
4)查看哪些队列收到了消息
前三个包含sysg,第四个包含news。所以四个队列都能接收到消息
五:SpringBoot整合RabbitMQ
5.1.引入pom依赖
<!--引入mq依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
引入依赖后,RabbitAutoConfiguration就会自动生效。给容器中自动引入了RabbitTemplate和AmqpAdmin
5.2 在application.properties文件配置RabbitMQ的连接信息
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
5.3 使用@EnableRabbit注解,开启rabbitmq的相关功能
@EnableRabbit
@SpringBootApplication
public class GulimailOrderApplication {
public static void main(String[] args) {
SpringApplication.run(GulimailOrderApplication.class, args);
}
}
六:测试rabbitmq的使用
6.1 使用AmqpAdmin创建直接交换机
@SpringBootTest
@Slf4j
class GulimailOrderApplicationTests {
@Autowired
private AmqpAdmin amqpAdmin;
@Test
public void createExchange() {
/**
* 全参构造器
* DirectExchange(String name, boolean durable, boolean autoDelete, Map<String, Object> arguments)
* name:交换机名称
* durable:是否持久化
* autoDelete:是否自动删除
* arguments:参数
*/
DirectExchange directExchange = new DirectExchange("hello-java-exchange",true,false);
amqpAdmin.declareExchange(directExchange);
log.info("Exchange[{}]创建成功","hello-java-exchange");
}
}
* DirectExchange(String name, boolean durable, boolean autoDelete, Map<String, Object> arguments)
* name:交换机名称
* durable:是否持久化
* autoDelete:是否自动删除
* arguments:参数
6.2 创建队列
/**
* 创建队列
*/
@Test
public void createQueue(){
/**
* 全参构造器
* Queue(String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
* name:队列名称
* durable:是否持久化
* exclusive:是否排他,队列一般不排他,谁能接受到谁用
* autoDelete:是否自动删除
* arguments:参数
*/
Queue queue = new Queue("hello-java-queue",true,false,false);
amqpAdmin.declareQueue(queue);
log.info("Queue[{}]创建成功","hello-java-queue");
}
* Queue(String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
* name:队列名称
* durable:是否持久化
* exclusive:是否排他,队列一般不排他,谁能接受到谁用
* autoDelete:是否自动删除
* arguments:参数
6.3 将创建好的交换机和队列进行绑定
将exchange指定的交换机和destination目的地进行绑定,使用routingKey作为路由键
/**
* 创建队列和交换机绑定
*/
@Test
public void createBinding(){
/**
* 全参构造器
* Binding(String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map<String, Object> arguments)
* destination:目的地
* destinationType:目的地类型
* exchange:交换机
* routingKey:路由键
* arguments:参数
* 将exchange指定的交换机和destination目的地进行绑定,使用routingKey作为路由键
*/
Binding binding = new Binding("hello-java-queue",
Binding.DestinationType.QUEUE,
"hello-java-exchange",
"hello.java",
null);
amqpAdmin.declareBinding(binding);
log.info("binding[{}]绑定成功","hello-java-binding");
}
* Binding(String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map<String, Object> arguments)
* destination:目的地
* destinationType:目的地类型
* exchange:交换机
* routingKey:路由键
* arguments:参数
6.4 发送消息
1)注入rabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
2)新建rabbitConfig配置类——用来将对象转化为json,进行消息发送
@Configuration
public class MyRabbitConfig {
/**
* 用来将对象转化为json
* @return
*/
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
}
3)发送消息代码编写
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void sendMessageTest(){
OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
reasonEntity.setId(1L);
reasonEntity.setCreateTime(new Date());
reasonEntity.setName("哈哈哈");
//1.发送任意类型的消息,如果发出去的消息是对象,我们会使用序列化机制,将对象写出去,对象必须实现序列化接口
String msg = "Hello World";
//2.发送对象类型的消息转化为json
rabbitTemplate.convertAndSend("hello-java-exchange","hello.java",reasonEntity);
log.info("消息发送完成{}",reasonEntity);
}
七:测试接收消息——@RabbitListener和@RabbitHandler
- @RabbitListener——标注在类和方法上
- @RabbitHandler——标注在方法上
7.1 监听消息——@RabbitListener
监听消息:使用@RabbitListener,必须有@EnableRabbit
/**
* queues:声明需要监听的所有队列
*/
@RabbitListener(queues = {"hello-java-queue"})
public void recieveMessage(Object message){
System.out.println("接收到消息的内容:"+message+"==>类型:" + message.getClass());
}
7.2 传递的参数直接定义为多种类型
参数可以定义为以下类型
* 1、Message message:原生消息的详细信息。头+体
* 2、T<发送消息的类型> OrderReturnReasonEntity content
* 3、 Channel channel:传输数据的通道
/**
* queues:声明需要监听的所有队列
* 参数可以定义为以下类型
* 1、Message message:原生消息的详细信息。头+体
* 2、T<发送消息的类型> OrderReturnReasonEntity content
* 3、 Channel channel:传输数据的通道
*/
@RabbitListener(queues = {"hello-java-queue"})
public void recieveMessage(Message message, OrderReturnReasonEntity content , Channel channel){
byte[] body = message.getBody();
//消息头属性信息
MessageProperties properties = message.getMessageProperties();
System.out.println("接收到消息的内容:"+message+"==>类型:"+message.getClass());
}
7.3 服务启动了多个,同一个消息,只有一个客户端可以接受到
@Test
public void sendMessageTest(){
//1.发送任意类型的消息,如果发出去的消息是对象,我们会使用序列化机制,将对象写出去,对象必须实现序列化接口
String msg = "Hello World";
//2.发送对象类型的消息转化为json
for (int i = 0; i < 10 ; i++) {
OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
reasonEntity.setId(1L);
reasonEntity.setCreateTime(new Date());
reasonEntity.setName("哈哈哈" + i);
rabbitTemplate.convertAndSend("hello-java-exchange","hello.java",reasonEntity);
log.info("消息发送完成{}",reasonEntity);
}
}
7.4 @RabbitHandler和@RabbitListener区别
- @RabbitListener 和 @RabbitHandler 搭配使用
- @RabbitListener 可以标注在类上面,需配合 @RabbitHandler 注解一起使用
- @RabbitListener 标注在类上面表示当有收到消息的时候,就交给 @RabbitHandler 的方法处理,具体使用哪个方法处理,根据 MessageConverter 转换后的参数类型
八:RabbitMQ消息确认机制
8.1 如何避免消息丢失?
1) 消息的丢失,在MQ角度考虑,一般有三种途径:
- 生产者确认发送到MQ服务器(生产者确认机制)
- MQ服务器不丢数据(消息持久化)
- 消费者确认消费掉消息(消费者确认机制)
2) 生产者/消费者保证消息不丢失有两种实现方式:
- 开启事务模式
- 消息确认模式
3) 开启事务会大幅降低消息发送及接收效率,使用的相对较少,因此我们生产环境一般都采取消息确认模式,我们只是讲解消息确认模式及消息持久化
- 生产者的ACK机制。有时,业务处理成功,消息也发了,但是我们并不知道消息是否成功到达了rabbitmq,例如:由于网络等原因导致业务成功而消息发送失败,此时可以使用rabbitmq的发送确认功能,要求rabbitmq显式告知我们消息是否已成功发送。
- 消费者的ACK机制。可以防止消费者丢失消息。
生产者确认机制有很严重的性能问题,如果每秒钟只有几百的消息量,可以使用。所以,我们主要讲了消费者的消息确认机制。
8.2 生产者的确认机制——可靠抵达
1)confirmCallback—— broker服务器接收到消息就会回调
- 在创建 connectionFactory 的时候设置 PublisherConfirms(true) 选项,开启confirmcallback
spring.rabbitmq.publisher-confirms=true #在创建 connectionFactory 的时候设置 PublisherConfirms(true) 选项,开启confirmcallback。
- 设置确认回调
@Configuration
public class MyRabbitConfig {
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* 定制rabbitTemplate
* @post MyRabbitConfig对象创建完成后,执行这个方法
*/
@PostConstruct
public void initRabbitTemplate(){
rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){
/**
* 只要消息抵达broker服务器,就会ack = true
* @param correlationData 当前消息的唯一关联数据,这是消费的唯一id
* @param b 消息是否成功接收到
* @param s 失败的原因
*/
@Override
public void confirm(CorrelationData correlationData, boolean b, String s) {
}
});
}
- 消息只要被 broker 接收到就会执行 confirmCallback,如果是 cluster 模式,需要所有broker 接收到才会调用 confirmCallback。
被 broker 接收到只能表示 message 已经到达服务器,并不能保证消息一定会被投递 到目标 queue 里。所以需要用到接下来的 returnCallback
2)returnCallback——消息正确抵达队列进行回调
- 开启发送端消息抵达队列的确认
spring.rabbitmq.publisher-returns=true #开启发送端消息抵达队列的确认
spring.rabbitmq.template.mandatory=true #只要抵达队列,以异步发送优先回调我们这个returnConfig
- 设置确认回调
只要消息没有投递给指定队列,就会触发这个失败的回调。成功不会触发
/**
* 定制rabbitTemplate
* @post MyRabbitConfig对象创建完成后,执行这个方法
*/
@PostConstruct
public void initRabbitTemplate(){
//设置确认回调
rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){
/**
* 只要消息抵达broker服务器,就会ack = true
* @param correlationData 当前消息的唯一关联数据,这是消费的唯一id
* @param b 消息是否成功接收到
* @param s 失败的原因
*/
@Override
public void confirm(CorrelationData correlationData, boolean b, String s) {
}
});
//设置消息抵达队列的确认回调
rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
/**
* 只要消息没有投递给指定队列,就会触发这个失败的回调。成功不会触发
* @param message 投递失败消息的详细信息
* @param i 回复的状态
* @param s 回复的文本内容
* @param s1 当时消息发送给那个交换机
* @param s2 当时消息用哪个路由键
*/
@Override
public void returnedMessage(Message message, int i, String s, String s1, String s2) {
}
});
}
- confrim 模式只能保证消息到达 broker,不能保证消息准确投递到目标 queue 里。在有 些业务场景下,我们需要保证消息一定要投递到目标 queue 里,此时就需要用到return 退回模式。这样如果未能投递到目标 queue 里将调用 returnCallback ,可以记录下详细到投递数 据,定期的巡检或者自动纠错都需要这些数据。
3)ack——消费者的ack机制
九:消费者的ack机制
9.1消费者获取到消息,成功处理,可以回复Ack给Broker
- basic.ack用于肯定确认;broker将移除此消息
- basic.nack用于否定确认;可以指定broker是否丢弃此消息,可以批量
- basic.reject用于否定确认;同上,但不能批量
9.2 默认自动ack,消息被消费者收到,就会从broker的queue中移除
9.3 queue无消费者,消息依然会被存储,直到消费者消费
9.4 消费者收到消息,默认会自动ack。但是如果无法确定此消息是否被处理完成, 或者成功处理。我们可以开启手动ack模式
- 消息处理成功,ack(),接受下一个消息,此消息broker就会移除
- 消息处理失败,nack()/reject(),重新发送给其他人进行处理,或者容错处理后ack
- 消息一直没有调用ack/nack方法,broker认为此消息正在被处理,不会投递给别人,此时客户 端断开,消息不会被broker移除,会投递给别人
9.5 手动确认模式
spring.rabbitmq.listener.direct.acknowledge-mode=manual
手动确认模式,只要不确认的消息都不算处理
9.6 消息丢失处理
1)try-catch捕获异常,将因为网络等其他原因的获取出来,然后重新发送。
2)每一个操作记录在日志做好记录,保存到数据表中。定期扫描然后重新发送。
3)消息交给队列,持久化处理。
4)做好消息确认机制,生产者和消费者两端确认。手动ack
9.7 消息重复处理
1)调用的相应接口设置为幂等的
2)使用防重表
9.8 消息积压处理
消息积压会导致服务器性能下降。消费者能力不足或者发送端发送的能力太大
1)上线更多的消费端
2)上线处理的消息的消费者,将消息保存到数据库
十:延时队列
10.1 创建队列、交换机和绑定关系
/**
* @bean 容器中的Binding、Queue、Exchange都会自动创建(rabbitmq没有的情况下)
*/
@Configuration
public class MyMQConfig {
/**
* 队列
* @return
*/
@Bean
public Queue orderDelayQueue(){
//order.delay.queue
HashMap<String, Object> arguments = new HashMap<>();
/**
* x-dead-letter-exchange: order-event-exchange
* x-dead-letter-routing-key: order.release.order
* x-message-ttl: 60000
*/
arguments.put("x-dead-letter-exchange","order-event-exchange");
arguments.put("x-dead-letter-routing-key","order.release.order");
arguments.put("x-message-ttl",60000);
return new Queue("order.delay.queue",true,false,false,arguments);
}
/**
* 队列
* @return
*/
@Bean
public Queue orderReleaseOrderQueue(){
//order.release.order.queue
return new Queue("order.release.order.queue",true,false,false);
}
/**
* 交换机
* @return
*/
@Bean
public Exchange orderEventExchange(){
//String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
return new TopicExchange("order-event-exchange",true,false);
}
/**
* 绑定关系
* @return
*/
@Bean
public Binding orderCreateOrderBinding(){
//String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map<String, Object> arguments
return new Binding("order.delay.queue",
Binding.DestinationType.QUEUE,
"order-event-exchange",
"order.create.order",
null);
}
/**
* 绑定关系
* @return
*/
@Bean
public Binding orderReleaseOrderBinding(){
//String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map<String, Object> arguments
return new Binding("order.release.order.queue",
Binding.DestinationType.QUEUE,
"order-event-exchange",
"order.release.order",
null);
}
}
10.2 监听队列测试
1)编写controller,给MQ发送消息
@Autowired
private RabbitTemplate rabbitTemplate;
@ResponseBody
@GetMapping(value = "/test/createOrder")
public String createOrderTest() {
//订单下单成功
OrderEntity orderEntity = new OrderEntity();
orderEntity.setOrderSn(UUID.randomUUID().toString());
orderEntity.setModifyTime(new Date());
//给MQ发送消息
rabbitTemplate.convertAndSend("order-event-exchange","order.create.order",orderEntity);
return "ok";
}
2)监听队列
/**
* 监听队列
*/
@RabbitListener(queues = "order.release.order.queue")
public void listener(OrderEntity entity , Channel channel , Message message) throws IOException {
System.out.println("收到过期的订单信息:准备关闭订单" + entity.getOrderSn());
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}
十一:引入RabbitMQ
11.1 引入依赖
<!--引入rabbitmq的amqp依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
11.2 配置主机地址
## rabbitmq的服务器地址
spring.rabbitmq.host=192.168.0.1
# 虚拟主机
spring.rabbitmq.virtual-host=/
11.3 @EnableRabbit
在主启动类添加@EnableRabbit注解,开启rabbitmq
11.4 将rabbitmq发送的消息转化为Json
@Configuration
public class MyRabbitConfig {
/**
* 用来将对象转化为json
* @return
*/
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
}
11.5 添加交换机、队列和绑定关系
@Configuration
public class MyRabbitConfig {
/**
* 用来将对象转化为json
* @return
*/
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
/**
* 创建stockEventExchange交换机
* @return
*/
@Bean
public Exchange stockEventExchange(){
//使用topic类型的交换机
//String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
return new TopicExchange("stock-event-exchange",true,false);
}
@Bean
public Queue stockReleaseStockQueue(){
return new Queue("stock.release.stock.queue",true,false,false);
}
/**
* 延时队列
* @return
*/
@Bean
public Queue stockDelayQueue(){
HashMap<String, Object> arguments = new HashMap<>();
/**
* x-dead-letter-exchange: order-event-exchange
* x-dead-letter-routing-key: order.release.order
* x-message-ttl: 60000
*/
arguments.put("x-dead-letter-exchange","order-event-exchange");
arguments.put("x-dead-letter-routing-key","order.release.order");
arguments.put("x-message-ttl",120000);
return new Queue("stock.delay.queue",true,false,false,arguments);
}
/**
* 交换机与延迟队列绑定
* @return
*/
@Bean
public Binding stockLockedBinding() {
return new Binding("stock.delay.queue",
Binding.DestinationType.QUEUE,
"stock-event-exchange",
"stock.locked",
null);
}
/**
* 交换机与普通队列绑定
* @return
*/
@Bean
public Binding stockReleaseBinding() {
//String destination, DestinationType destinationType, String exchange, String routingKey,
// Map<String, Object> arguments
return new Binding("stock.release.stock.queue",
Binding.DestinationType.QUEUE,
"stock-event-exchange",
"stock.release.#",
null);
}
11.6 库存解锁的场景
1)下单成功,订单过期未支付。用户手动取消订单
2)下订单成功,库存锁定成功。但是接下来的业务处理发生异常,导致业务整体回滚。之前锁定的库存就要自动解锁。