RabbitMQ
MQ (MessageQueue),消息队列,字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。
同步通讯与异步通讯
同步通讯
同步调用的优点:
- 时效性较强,可以立即得到结果同步
调用的问题:
-
耦合度高:
每次加入新的需求,都要修改原来的代码
-
性能和吞吐能力下降:
调用者需要等待服务提供者响应,如果调用链过长则响应时间等于每次调用的时间之和。
-
有额外的资源消耗:
调用链中的每个服务在等待响应过程中,不能释放请求占用的资源,高并发场景下会极度浪费系统资源
-
有级联失败问题:
如果服务提供者出现问题,所有调用方都会跟着出问题,如同多米诺骨牌一样,迅速导致整个微服务群故障
异步通讯
异步通信的优点:
- 耦合度低
- 吞吐量提升
- 故障隔离
- 流量削峰
异步通信的缺点:
- 依赖于Broker的可靠性、安全性、吞吐能力
- 架构复杂了业务没有明显的流程线,不好追踪管理
快速入门
安装
- 下载镜像
docker pull rabbitmq:3-management
- 安装MQ
执行下面的命令来运行MQ容器:
docker run \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123321 \
--name mq \
--hostname mq1 \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3-management
RabbitMQ概述
RabbitMQ中的几个概念:
- channel:操作MQ的工具
- exchange:路由消息到队列中
- queue:缓存消息
- virtual host:虚拟主机,是对queue、exchange等资源的逻辑分组
常见的消息模型:
- 基本消息队列(BasicQueue)
- 工作消息队列(WorkQueue)
发布订阅(Publish、Subscribe),又根据交换机类型不同分为三种:
- Fanout Exchange:广播
- Direct Exchange:路由
- Topic Exchange:主题
基本消息队列的消息发送流程:
- 建立connection
- 创建channel
- 利用channel声明队列
- 利用channel向队列发送消息
基本消息队列的消息接收流程:
- 建立connection
- 创建channel
- 利用channel声明队列
- 定义consumer的消费行为handleDelivery()
- 利用channel将消费者与队列绑定
HelloWorld案例
- 导入依赖
<!--AMQP依赖,包含RabbitMQ-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!--单元测试-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
- 消息发布者发布消息
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class PublisherTest {
@Test
public void testSendMessage() throws IOException, TimeoutException {
// 1.建立连接
ConnectionFactory factory = new ConnectionFactory();
// 1.1.设置连接参数,分别是:主机名、端口号、vhost、用户名、密码
factory.setHost("192.168.88.130");
factory.setPort(5672);
factory.setVirtualHost("/");
factory.setUsername("itcast");
factory.setPassword("123321");
// 1.2.建立连接
Connection connection = factory.newConnection();
// 2.创建通道Channel
Channel channel = connection.createChannel();
// 3.创建队列
String queueName = "simple.queue";
channel.queueDeclare(queueName, false, false, false, null);
// 4.发送消息
String message = "hello, rabbitmq!";
channel.basicPublish("", queueName, null, message.getBytes());
System.out.println("发送消息成功:【" + message + "】");
// 5.关闭通道和连接
channel.close();
connection.close();
}
}
- 消息接收者接收消息
package com.lhs;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class ConsumerTest {
public static void main(String[] args) throws IOException, TimeoutException {
// 1.建立连接
ConnectionFactory factory = new ConnectionFactory();
// 1.1.设置连接参数,分别是:主机名、端口号、vhost、用户名、密码
factory.setHost("192.168.88.130");
factory.setPort(5672);
factory.setVirtualHost("/");
factory.setUsername("itcast");
factory.setPassword("123321");
// 1.2.建立连接
Connection connection = factory.newConnection();
// 2.创建通道Channel
Channel channel = connection.createChannel();
// 3.创建队列
String queueName = "simple.queue";
channel.queueDeclare(queueName, false, false, false, null);
// 4.订阅消息
channel.basicConsume(queueName, true, new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
// 5.处理消息
String message = new String(body);
System.out.println("接收到消息:【" + message + "】");
}
});
System.out.println("等待接收消息。。。。");
}
}
SpringAMQP
SpringAMQP是基于RabbitMQ封装的一套模板,并且还利用SpringBoot对其实现了自动装配,使用起来非常方便。
SpringAMQP提供了三个功能:
- 自动声明队列、交换机及其绑定关系
- 基于注解的监听器模式,异步接收消息
- 封装了RabbitTemplate工具,用于发送消息
Basic Queue 简单队列模型
- 导入依赖
<!--AMQP依赖,包含RabbitMQ-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 添加配置
spring:
rabbitmq:
host: 192.168.88.130 # 主机名
port: 5672 # 端口
virtual-host: / # 虚拟主机
username: itcast # 用户名
password: 123321 # 密码
- 消息发送者发送消息
@SpringBootTest
public class SpringamqpTest {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void test01(){
String queueName = "simple.queue";
String msg = "hello world123 !";
rabbitTemplate.convertAndSend(queueName, msg);
System.out.println("发送消息完成!");
}
}
- 消息接收者接收消息
package com.lhs.listener;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class SpringRabbitListener {
@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage(String msg) throws InterruptedException {
System.out.println("spring 消费者接收到消息:【" + msg + "】");
}
}
WorkQueue
Work queues,也被称为(Task queues),任务模型。简单来说就是让多个消费者绑定到一个队列,共同消费队列中的消息。
- 发送50条消息
@Test
public void test02(){
String queueName = "simple.queue";
String msg = "hello world!";
for (int i = 1; i <= 50; i++) {
rabbitTemplate.convertAndSend(queueName, msg + i);
}
System.out.println("发送消息完成!");
}
- 接收消息
@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
System.out.println("消费者1接收到消息:【" + msg + "】" + LocalTime.now());
Thread.sleep(20);
}
@RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
System.err.println("消费者2........接收到消息:【" + msg + "】" + LocalTime.now());
Thread.sleep(200);
}
- 测试结果
两个消费者各处理25条:
- 能者多劳
spring:
rabbitmq:
listener:
simple:
prefetch: 1 # 每次只能获取一条消息,处理完成才能获取下一个消息
- 总结
Work模型的使用:
- 多个消费者绑定到一个队列,同一条消息只会被一个消费者处理
- 通过设置prefetch来控制消费者预取的消息数量
发布/订阅
可以看到,在订阅模型中,多了一个exchange角色,而且过程略有变化:
- Publisher:生产者,也就是要发送消息的程序,但是不再发送到队列中,而是发给X(交换机)
- Exchange:交换机,图中的X。一方面,接收生产者发送的消息。另一方面,知道如何处理消息,例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作,取决于Exchange的类型。Exchange有以下3种类型:
- Fanout:广播,将消息交给所有绑定到交换机的队列
- Direct:定向,把消息交给符合指定routing key 的队列
- Topic:通配符,把消息交给符合routing pattern(路由模式) 的队列
- Consumer:消费者,与以前一样,订阅队列,没有变化
- Queue:消息队列也与以前一样,接收消息、缓存消息。
Exchange(交换机)只负责转发消息,不具备存储消息的能力,因此如果没有任何队列与Exchange绑定,或者没有符合路由规则的队列,那么消息会丢失!
Fanout
在广播模式下,消息发送流程是这样的:
- 1) 可以有多个队列
- 2) 每个队列都要绑定到Exchange(交换机)
- 3) 生产者发送的消息,只能发送到交换机,交换机来决定要发给哪个队列,生产者无法决定
- 4) 交换机把消息发送给绑定过的所有队列
- 5) 订阅队列的消费者都能拿到消息
- .基于注解声明队列和交换机
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lhs.queue"),
exchange = @Exchange(name = "myExchange",type = ExchangeTypes.FANOUT)
))
public void listenFanoutExchangeMessage1(String msg) throws InterruptedException {
System.out.println("消费者3........接收到消息:【" + msg + "】" + LocalTime.now());
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lhs.queue"),
exchange = @Exchange(name = "myExchange",type = ExchangeTypes.FANOUT)
))
public void listenFanoutExchangeMessage2(String msg) throws InterruptedException {
System.out.println("消费者4........接收到消息:【" + msg + "】" + LocalTime.now());
}
- 发送消息
@Test
public void test03(){
String exchange = "myExchange";
String msg = "你好";
rabbitTemplate.convertAndSend(exchange,"",msg);
}
Direct
在Direct模型下:
- 队列与交换机的绑定,不能是任意绑定了,而是要指定一个
RoutingKey
(路由key) - 消息的发送方在 向 Exchange发送消息时,也必须指定消息的
RoutingKey
。 - Exchange不再把消息交给每一个绑定的队列,而是根据消息的
Routing Key
进行判断,只有队列的Routingkey
与消息的Routing key
完全一致,才会接收到消息
- 基于注解声明队列和交换机
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lhs1.queue1"),
exchange = @Exchange(name = "myExchange1",type = ExchangeTypes.DIRECT),
key = {"red","yellow"}
))
public void listenDirectExchangeMessage3(String msg) throws InterruptedException {
System.out.println("消费者5........接收到消息:【" + msg + "】" + LocalTime.now());
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lhs1.queue2"),
exchange = @Exchange(name = "myExchange1",type = ExchangeTypes.DIRECT),
key = {"red","blue"}
))
public void listenDirectExchangeMessage4(String msg) throws InterruptedException {
System.out.println("消费者6........接收到消息:【" + msg + "】" + LocalTime.now());
}
- 发布消息
@Test
public void test04(){
String exchange = "myExchange1";
String msg = "你好";
String key = "blue";
rabbitTemplate.convertAndSend(exchange,key,msg);
}
Topic
Topic
类型的Exchange
与Direct
相比,都是可以根据RoutingKey
把消息路由到不同的队列。只不过Topic
类型Exchange
可以让队列在绑定Routing key
的时候使用通配符!
Routingkey
一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: item.insert
通配符规则:
#
:匹配一个或多个词
*
:匹配不多不少恰好1个词
- 基于注解声明队列和交换机
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lhs2.queue1"),
exchange = @Exchange(name = "myExchange2",type = ExchangeTypes.TOPIC),
key = "china.#"
))
public void listenTopicExchangeMessage1(String msg) throws InterruptedException {
System.out.println("消费者7........接收到消息:【" + msg + "】" + LocalTime.now());
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lhs2.queue2"),
exchange = @Exchange(name = "myExchange2",type = ExchangeTypes.TOPIC),
key = "#.news"
))
public void listenTopicExchangeMessage2(String msg) throws InterruptedException {
System.out.println("消费者8........接收到消息:【" + msg + "】" + LocalTime.now());
}
- 发布消息
@Test
public void test05(){
String exchange = "myExchange2";
String msg = "你好Topic";
String key = "china.n";
rabbitTemplate.convertAndSend(exchange,key,msg);
}
消息转换器
Spring对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而默认实现是SimpleMessageConverter,基于JDK的ObjectOutputStream完成序列化。文章来源:https://www.toymoban.com/news/detail-788627.html
众所周知,JDK序列化存在下列问题:文章来源地址https://www.toymoban.com/news/detail-788627.html
- 数据体积过大
- 有安全漏洞
- 可读性差
- 配置json转换器
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.9.10</version>
</dependency>
- 在启动类中添加转换器
@Bean
public MessageConverter jsonMessageConverter(){
return new Jackson2JsonMessageConverter();
}
到了这里,关于SpringCloud:RabbitMQ兔子消息队列的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!