1.目前我们已经完成了商品和搜索系统的开发。我们思考一下,是否存在问题?
2.如果我们在后台修改了商品的价格,搜索页面依然是旧的价格,这样显然不对。该如何解决?这里有两种解决方案:
以上两种方式都有同一个严重问题:就是代码耦合,后台服务中需要嵌入搜索和商品页面服务,违背了微服务的独立
原则。
所以,我们会通过另外一种方式来解决这个问题:消息队列
解耦:
在项目启动之初是很难预测未来会遇到什么困难的,消息中间件在处理过程中插入了一个隐含的,基于数据的接口层,两边都实现这个接口,这样就允许独立的修改或者扩展两边的处理过程,只要两边遵守相同的接口约束即可。
冗余(存储):
在某些情况下处理数据的过程中会失败,消息中间件允许把数据持久化知道他们完全被处理
扩展性:
消息中间件解耦了应用的过程,所以提供消息入队和处理的效率是很容易的,只需要增加处理流程就可以了。
流量控制,削峰:
在访问量剧增的情况下,但是应用仍然需要发挥作用,但是这样的突发流量并不常见。而使用消息中间件采用队列的形式可以减少突发访问压力,不会因为突发的超时负荷要求而崩溃
可恢复性:
当系统一部分组件失效时,不会影响到整个系统。消息中间件降低了进程间的耦合性,当一个处理消息的进程挂掉后,加入消息中间件的消息仍然可以在系统恢复后重新处理
顺序保证:
在大多数场景下,处理数据的顺序也很重要,大部分消息中间件支持一定的顺序性
缓冲:
消息中间件通过一个缓冲层来帮助任务最高效率的执行
异步通信:
通过把把消息发送给消息中间件,消息中间件并不立即处理它,后续在慢慢处理。
消息中间件都是分布式的,因此才可以提供异步、解耦等功能。
基于消息的通信是可靠的,消息不会丢失。大多数消息中间件都提供将消息持久化到磁盘的功能。
通过消息中间件,可将远程同步调用拆解成为异步调用。对于不需要获取远程调用结果的应用场景来说,性能提升明 显。
消息直接由中间件存储和分发。消息生产者只需关注如何将消息发送给消息中介服务器;消费者只需关注如何从中介服务器订阅。生产者和消费者之间是完全解耦的,不需要知道彼此的存在。
可以将复杂的应用系统重构成为事件驱动的系统
消息队列是典型的:生产者、消费者模型。生产者不断向消息队列中生产消息,消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的,而且只关心消息的发送和接收,没有业务逻辑的侵入,这样就实现了生产者和消费者的解耦。
结合前面所说的问题:
如果以后有其它系统也依赖商品服务的数据,同样监听消息即可,商品服务无需任何代码修改。
消息代理(message broker)和目的地(destination)。当消息发送者发送消息以后,将由消息代理接管,消息代理保证消息传递到指定目的地。
队列(queue):点对点消息通信(point-to-point)
主题(topic):发布(publish)/订阅(subscribe)消息通信
发送者(发布者)发送消息到主题,多个接收者(订阅者)监听(订阅)这个 主题,那么就会在消息到达时同时收到消息
基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现
ActiveMQ、RabbitMQ、RocketMQ、Kafka
RabbitMQ是使用Erlang语言开发的开源消息队列系统,基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、安全。AMQP协议更多用在企业系统内对数据一致性、稳定性和可靠性要求很高的场景,对性能和吞吐量的要求还在其次。
优点:由于erlang语言的高并发特性,性能较好;吞吐量到万级,MQ功能比较完备,健壮、稳定、易用、跨平台、支持多种语言,支持AJAX文档齐全,开源提供的管理界面非常棒,用起来很好用,社区活跃度高;更新频率相当高。
缺点:商业版需要收费,学习成本较高。
消息,消息是不具名的,它由消息头和消息体组成。消息体是不透明的,而消息头则由一系列的可选属性组成, 这些属性包括routing-key(路由键)、priority(相对于其他消息的优先权)、delivery-mode(指出该消息可 能需要持久性存储)等。
消息的生产者,也是一个向交换器发布消息的客户端应用程序。
交换器,用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
Exchange有4种类型:direct(默认),fanout, topic, 和headers,不同类型的Exchange转发消息的策略有所区别
消息队列,用来保存消息直到发送给消费者。它是消息的容器,也是消息的终点。一个消息可投入一个或多个队列。消息一直 在队列里面,等待消费者连接到这个队列将其取走。
消息的消费者,表示一个从消息队列中取得消息的客户端应用程序。
绑定,用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则,所以可以将交 换器理解成一个由绑定构成的路由表。
Exchange 和Queue的绑定可以是多对多的关系。
信道,多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接,AMQP 命令都是通过信道 发出去的,不管是发布消息、订阅队列还是接收消息,这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都 是非常昂贵的开销,所以引入了信道的概念,以复用一条 TCP 连接。
虚拟主机,表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加 密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器,拥 有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础,必须在连接时 指定,RabbitMQ 默认的 vhost 是 / 。
官网下载地址:http://www.rabbitmq.com/download.html
官方文档:https://www.rabbitmq.com/networking.html
docker pull rabbitmq:management
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间内部通信口,集群端口
docker update rabbitmq --restart=always
在web浏览器中输入地址:http://你虚拟机ip:15672/
输入默认账号: guest : guest
注:如果服务器无法访问15672端口,记得在服务器中开通15672端口权限
overview:概览,各种统计信息,图表,也可以通过export definitions导出配置,转移到其他mq里面
connections:无论生产者还是消费者,都需要与RabbitMQ建立连接后才可以完成消息的生产和消费,在这里可以查看连接情况
channels:通道,建立连接后,会形成通道,消息的投递获取依赖通道。
Exchanges:交换机,用来实现消息的路由
Queues:队列,即消息队列,消息存放在队列中,等待消费,消费后被移除队列。
admin:mq的管理和设置,添加用户信息,分配虚拟主机等
如果不使用guest,我们也可以自己创建一个用户
1、 超级管理员(administrator)
可登陆管理控制台,可查看所有的信息,并且可以对用户,策略(policy)进行操作。
2、 监控者(monitoring)
可登陆管理控制台,同时可以查看rabbitmq节点的相关信息(进程数,内存使用情况,磁盘使用情况等)
3、 策略制定者(policymaker)
可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
4、 普通管理者(management)
仅可登陆管理控制台,无法看到节点信息,也无法对策略进行管理。
5、 其他
无法登陆管理控制台,通常就是普通的生产者和消费者。
虚拟主机:类似于mysql中的database。他们都是以“/”开头
AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS 存在一些差别,AMQP 中增加了 Exchange 和Binding 的角色。生产者把消息发布到 Exchange 上,消息最终到达队列并被消费者接收,而 Binding 决定交 换器的消息应该发送到那个队列。
Exchange分发消息时根据类型的不同分发策略有区别,目前共四种类型:direct、fanout、topic、headers 。headers 匹配 AMQP 消息的 header 而不是路由键,headers 交换器和 direct 交换器完全一致,但性能差很多,目前几乎用不到了,所以直接 看另外三种类型:
消息中的路由键(routing key)如果和Binding 中的 binding key 一致, 交换器 就将消息发到对应的队列中。路由键与队 列名完全匹配,如果一个队列绑定到交换 机要求路由键为“dog”,则只转发 routing key 标记为“dog”的消息,不会转发“dog.puppy”,也不会转发“dog.guard” 等等。它是完全匹配、单播的模式。
每个发到 fanout 类型交换器的消息都 会分到所有绑定的队列上去。fanout 交 换器不处理路由键,只是简单的将队列 绑定到交换器上,每个发送到交换器的 消息都会被转发到与该交换器绑定的所 有队列上。很像子网广播,每台子网内 的主机都获得了一份复制的消息。fanout 类型转发消息是最快的。
topic 交换器通过模式匹配分配消息的 路由键属性,将路由键和某个模式进行匹配,此时队列需要绑定到一个模式上。 它将路由键和绑定键的字符串切分成单 词,这些单词之间用点隔开。它同样也 会识别两个通配符:符号“#”和符号“*”。#匹配0个或多个单词,*匹配一 个单词。
1)首先创建出四个队列,如下图
2)创建direct类型的交换机
3)将exchange.direct交换机与四个队列进行绑定
4)在交换机里测试给sysg.news发送消息
5)此时消息就接受到了
注:
nack message requeue true : 接收消息,并且不在队列中删除
automatic ack :获取玩消息后,在队列中删除消息,保证消费消息
1)创建exchange.fanout交换机
2)给交换机绑定如下四个队列
3)给sysg.emps队列发送消息
4)查看哪些队列收到了消息
此时发现四个队列都接受到了消息,所以fanout每个队列都会接收到消息
1)创建exchange.topic交换机
2)给交换机绑定如下四个队列
注:路由键的名称需要特别注意一下,模糊匹配
3)给sysg.newss队列发送消息
4)查看哪些队列收到了消息
前三个包含sysg,第四个包含news。所以四个队列都能接收到消息
<!--引入mq依赖-->
org.springframework.boot
spring-boot-starter-amqp
引入依赖后,RabbitAutoConfiguration就会自动生效。给容器中自动引入了RabbitTemplate和AmqpAdmin
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
@EnableRabbit
@SpringBootApplication
public class GulimailOrderApplication {
public static void main(String[] args) {
SpringApplication.run(GulimailOrderApplication.class, args);
}
}
@SpringBootTest
@Slf4j
class GulimailOrderApplicationTests {
@Autowired
private AmqpAdmin amqpAdmin;
@Test
public void createExchange() {
/**
* 全参构造器
* DirectExchange(String name, boolean durable, boolean autoDelete, Map 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 arguments)
* name:交换机名称
* durable:是否持久化
* autoDelete:是否自动删除
* arguments:参数
/**
* 创建队列
*/
@Test
public void createQueue(){
/**
* 全参构造器
* Queue(String name, boolean durable, boolean exclusive, boolean autoDelete, Map 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 arguments)
* name:队列名称
* durable:是否持久化
* exclusive:是否排他,队列一般不排他,谁能接受到谁用
* autoDelete:是否自动删除
* arguments:参数
将exchange指定的交换机和destination目的地进行绑定,使用routingKey作为路由键
/**
* 创建队列和交换机绑定
*/
@Test
public void createBinding(){
/**
* 全参构造器
* Binding(String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map 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 arguments)
* destination:目的地
* destinationType:目的地类型
* exchange:交换机
* routingKey:路由键
* arguments:参数
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,必须有@EnableRabbit
/**
* queues:声明需要监听的所有队列
*/
@RabbitListener(queues = {"hello-java-queue"})
public void recieveMessage(Object message){
System.out.println("接收到消息的内容:"+message+"==>类型:" + message.getClass());
}
参数可以定义为以下类型
* 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());
}
@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);
}
}
1) 消息的丢失,在MQ角度考虑,一般有三种途径:
2) 生产者/消费者保证消息不丢失有两种实现方式:
3) 开启事务会大幅降低消息发送及接收效率,使用的相对较少,因此我们生产环境一般都采取消息确认模式,我们只是讲解消息确认模式及消息持久化
生产者确认机制有很严重的性能问题,如果每秒钟只有几百的消息量,可以使用。所以,我们主要讲了消费者的消息确认机制。
1)confirmCallback—— broker服务器接收到消息就会回调
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) {
}
});
}
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) {
}
});
}
3)ack——消费者的ack机制
spring.rabbitmq.listener.direct.acknowledge-mode=manual
手动确认模式,只要不确认的消息都不算处理