RabbitMQ实战教程
1.MQ引言
1.1.什么是MQ
MQ(Message Quene) : 翻译为消息队列,通过典型的生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。
1.2 MQ有哪些
当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafka，阿里巴巴自主开发RocketMQ等。
1.3 不同MQ特点
1.ActiveMQ
ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。它是一个完全支持JMS规范的的消息中间件。丰富的API,多种集群架构模式让ActiveMQ在业界成为老牌的消息中间件,在中小型企业颇受欢迎!
2.Kafka
Kafka是LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。Kafka主要特点是基于Pull的模式来处理消息消费，
追求高吞吐量，一开始的目的就是用于日志收集和传输。0.8版本开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格要求，
适合产生大量数据的互联网服务的数据收集业务。
3.RocketMQ
RocketMQ是阿里开源的消息中间件，它是纯Java开发，具有高吞吐量、高可用性、适合大规模分布式系统应用的特点。RocketMQ思路起源于Kafka，但并不是Kafka的一个Copy，它对消息的可靠传输及事务性做了优化，目前在阿里集团被广泛应用于交易、充值、流计算、消息推送、日志流式处理、binglog分发等场景。
4.RabbitMQ
RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。AMQP协议更多用在企业系统内对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在。
RabbitMQ比Kafka可靠，Kafka更适合IO高吞吐的处理，一般应用在大数据日志处理或对实时性（少量延迟），可靠性（少量丢数据）要求稍低的场景使用，比如ELK日志收集。
2 RabbitMQ 的引言
2.1 RabbitMQ
基于AMQP协议，erlang语言开发，是部署最广泛的开源消息中间件,是最受欢迎的开源消息中间件之一。
AMQP 协议
AMQP（advanced message queuing protocol）`在2003年时被提出，最早用于解决金融领不同平台之间的消息传递交互问题。顾名思义，AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。这使得实现了AMQP的provider天然性就是跨平台的。以下是AMQP协议模型:
2.2 RabbitMQ 的安装
2.2.1 下载
2.2.2 下载安装包
注意:这里的安装包是centos7安装的包
2.2.3 安装步骤
# 1.将rabbitmq安装包上传到linux系统中
erlang-22.0.7-1.el7.x86_64.rpm
rabbitmq-server-3.7.18-1.el7.noarch.rpm
socat-1.7.3.2-2.el7.x86_64.rpm
# 2.安装Erlang依赖包
rpm -ivh erlang-22.0.7-1.el7.x86_64.rpm
rpm -ivh socat-1.7.3.2-2.el7.x86_64.rpm
# 3.安装RabbitMQ安装包(需要联网)
yum install -y rabbitmq-server-3.7.18-1.el7.noarch.rpm
注意:默认安装完成后配置文件模板在:/usr/share/doc/rabbitmq-server-3.7.18/rabbitmq.config.example目录中,需要
将配置文件复制到/etc/rabbitmq/目录中,并修改名称为rabbitmq.config
# 4.复制配置文件
cp /usr/share/doc/rabbitmq-server-3.7.18/rabbitmq.config.example /etc/rabbitmq/rabbitmq.config
# 5.查看配置文件位置
ls /etc/rabbitmq/rabbitmq.config
# 6.修改配置文件(参见下图:)
vim /etc/rabbitmq/rabbitmq.config
将上图中配置文件中红色部分去掉%%,以及最后的,逗号 修改为下图:
# 7.执行如下命令,启动rabbitmq中的插件管理
rabbitmq-plugins enable rabbitmq_management
出现如下说明:
Enabling plugins on node rabbit@localhost:
rabbitmq_management
The following plugins have been configured:
rabbitmq_management
rabbitmq_management_agent
rabbitmq_web_dispatch
Applying plugin configuration to rabbit@localhost...
The following plugins have been enabled:
rabbitmq_management
rabbitmq_management_agent
rabbitmq_web_dispatch
set 3 plugins.
Offline change; changes will take effect at broker restart.
# 8.启动RabbitMQ的服务
systemctl start rabbitmq-server
systemctl restart rabbitmq-server
systemctl stop rabbitmq-server
# 9.查看服务状态(见下图:)
systemctl status rabbitmq-server
● rabbitmq-server.service - RabbitMQ broker
Loaded: loaded (/usr/lib/systemd/system/rabbitmq-server.service; disabled; vendor preset: disabled)
Active: active (running) since 三 2019-09-25 22:26:35 CST; 7s ago
Main PID: 2904 (beam.smp)
Status: "Initialized"
CGroup: /system.slice/rabbitmq-server.service
├─2904 /usr/lib64/erlang/erts-10.4.4/bin/beam.smp -W w -A 64 -MBas ageffcbf -MHas ageffcbf -
MBlmbcs...
├─3220 erl_child_setup 32768
├─3243 inet_gethost 4
└─3244 inet_gethost 4
.........
# 10.关闭防火墙服务
systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
systemctl stop firewalld
# 11.访问web管理界面
http://192.168.245.128:15672/
3 RabiitMQ 配置
3.1 RabbitMQ 管理命令行
# 1.服务启动相关
systemctl start|restart|stop|status rabbitmq-server
# 2.管理命令行 用来在不使用web管理界面情况下命令操作RabbitMQ
rabbitmqctl help 可以查看更多命令
# 3.插件管理命令行
rabbitmq-plugins enable|list|disable
3.2 web管理界面介绍
3.2.1 overview概览
connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况`
channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。
Exchanges：交换机，用来实现消息的路由
Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。
3.2.2 Admin用户和虚拟主机管理
3.2.2.1 添加用户
上面的Tags选项，其实是指定用户的角色，可选的有以下几个：
超级管理员(administrator)
可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
监控者(monitoring)
可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
策略制定者(policymaker)
可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
普通管理者(management)
仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
其他
无法登陆管理控制台，通常就是普通的生产者和消费者。
3.2.2.2 创建虚拟主机
虚拟主机
为了让各个用户可以互不干扰的工作，RabbitMQ添加了虚拟主机（Virtual Hosts）的概念。其实就是一个独立的访问路径，不同用户使用不同路径，各自有自己的队列、交换机，互相不会影响。
3.2.2.3 绑定虚拟主机和用户
创建好虚拟主机，我们还要给用户添加访问权限：
点击添加好的虚拟主机：
进入虚拟机设置界面
4.springBoot整合rabbitMq
4.1.搭建环境
创建springboot工程 引入依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- rabbitMQ -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
4.2.配置文件
# 应用名
spring.application.name=springboot-rabbitmq
# rabbitmq配置信息
# ip
spring.rabbitmq.host=49.234.63.83
# 端口
spring.rabbitmq.port=5672
# 用户名
spring.rabbitmq.username=root
# 密码
spring.rabbitmq.password=root
# 配置虚拟机
spring.rabbitmq.virtual-host=tang
# 开启消息确认机制 confirm 异步
spring.rabbitmq.publisher-confirm-type=correlated
# 开启return机制
spring.rabbitmq.publisher-returns=true
# 消息开启手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual
4.3.项目目录结构
RabbitmqConfig配置队列 交换机以及队列与交换机的绑定关系
RabbitmqController controller层
WorkReceiveListener 监听队列的消息
RabbitmqServiceImpl,RabbitmqService service层
User 实体类
RabbitmqMapper dao层
RabbitmqApplication 启动类
4.4.工作模式
RabbitmqConfig
// 配置一个工作模型队列
@Bean
public Queue queueWork1() {
return new Queue("queue_work");
}
WorkReceiveListener
配置两个消费者
@RabbitListener(queues = "queue_work")
public void receiveMessage(String msg, Channel channel, Message message) {
// 只包含发送的消息
System.out.println("1接收到消息：" + msg);
// channel 通道信息
// message 附加的参数信息
}
@RabbitListener(queues = "queue_work")
public void receiveMessage2(Object obj, Channel channel, Message message) {
// 包含所有的信息
System.out.println("2接收到消息：" + obj);
}
RabbitmqController
@RequestMapping("/sendWork")
public Object sendWork() {
rabbitmqService.sendWork();
return "发送成功...";
}
RabbitmqService
void sendWork();
RabbitmqServiceImpl
@Autowired
private RabbitmqMapper rabbitmqMapper;
@Override
public void sendWork() {
rabbitmqMapper.sendWork();
}
RabbitmqMapper
生产消息 往队列里生产十条消息
public void sendWork() {
for (int i = 0; i < 10; i++) {
rabbitTemplate.convertAndSend("queue_work", "测试work模型: " + i);
}
}
测试
发送请求
http://localhost:8080/sendWork
1接收到消息：测试work模型: 0
2接收到消息：(Body:'测试work模型: 2' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=, receivedRoutingKey=queue_work, deliveryTag=1, consumerTag=amq.ctag-t1IFipsGbjbZsUGhD3ztUA, consumerQueue=queue_work])
1接收到消息：测试work模型: 1
1接收到消息：测试work模型: 5
2接收到消息：(Body:'测试work模型: 4' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=, receivedRoutingKey=queue_work, deliveryTag=2, consumerTag=amq.ctag-t1IFipsGbjbZsUGhD3ztUA, consumerQueue=queue_work])
2接收到消息：(Body:'测试work模型: 3' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=, receivedRoutingKey=queue_work, deliveryTag=3, consumerTag=amq.ctag-t1IFipsGbjbZsUGhD3ztUA, consumerQueue=queue_work])
2接收到消息：(Body:'测试work模型: 6' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=, receivedRoutingKey=queue_work, deliveryTag=4, consumerTag=amq.ctag-t1IFipsGbjbZsUGhD3ztUA, consumerQueue=queue_work])
1接收到消息：测试work模型: 7
1接收到消息：测试work模型: 8
2接收到消息：(Body:'测试work模型: 9' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=, receivedRoutingKey=queue_work, deliveryTag=5, consumerTag=amq.ctag-t1IFipsGbjbZsUGhD3ztUA, consumerQueue=queue_work])
可以看到两个两个消费者轮流消费这十条消息
4.5.发布订阅模式
RabbitmqConfig
// 发布订阅模式
// 声明两个队列
@Bean
public Queue queueFanout1() {
return new Queue("queue_fanout1");
}
@Bean
public Queue queueFanout2() {
return new Queue("queue_fanout2");
}
// 准备一个交换机
@Bean
public FanoutExchange exchangeFanout() {
return new FanoutExchange("exchange_fanout");
}
// 将交换机和队列进行绑定
@Bean
public Binding bindingExchange1() {
return BindingBuilder.bind(queueFanout1()).to(exchangeFanout());
}
@Bean
public Binding bindingExchange2() {
return BindingBuilder.bind(queueFanout2()).to(exchangeFanout());
}
WorkReceiveListener
@RabbitListener(queues = "queue_fanout1")
public void receiveMsg1(String msg) {
System.out.println("队列1接收到消息：" + msg);
}
@RabbitListener(queues = "queue_fanout2")
public void receiveMsg2(String msg) {
System.out.println("队列2接收到消息：" + msg);
}
RabbitmqController
@RequestMapping("/sendPublish")
public String sendPublish() {
rabbitmqService.sendPublish();
return "发送成功...";
}
RabbitmqService
void sendPublish();
RabbitmqServiceImpl
@Override
public void sendPublish() {
rabbitmqMapper.sendPublish();
}
RabbitmqMapper
// 向发布订阅模式里面发送消息
public void sendPublish() {
for (int i = 0; i < 5; i++) {
// rabbitTemplate.convertSendAndReceive("exchange_fanout", "", "测试发布订阅模型：" + i);
rabbitTemplate.convertAndSend("exchange_fanout", "", "测试发布订阅模型：" + i);
}
}
convertAndSend方法传递三个参数 其中 routingKey为空 即向交换机中发送五条消息 这五条消息被交换机路由到绑定该交换机的两个队列中
测试
发生请求http://localhost:8080/sendPublish
队列1接收到消息：测试发布订阅模型：0
队列2接收到消息：测试发布订阅模型：0
队列1接收到消息：测试发布订阅模型：1
队列1接收到消息：测试发布订阅模型：2
队列2接收到消息：测试发布订阅模型：1
队列2接收到消息：测试发布订阅模型：2
队列1接收到消息：测试发布订阅模型：3
队列2接收到消息：测试发布订阅模型：3
队列1接收到消息：测试发布订阅模型：4
队列2接收到消息：测试发布订阅模型：4
可以看到每个队列中都有这五条消息 故其名为广播模式(发布于订阅模式)
4.6.topic 模型
RabbitmqConfig
// topic 模型
@Bean
public Queue queueTopic1() {
return new Queue("queue_topic1");
}
@Bean
public Queue queueTopic2() {
return new Queue("queue_topic2");
}
@Bean
public TopicExchange exchangeTopic() {
return new TopicExchange("exchange_topic");
}
@Bean
public Binding bindingTopic1() {
return BindingBuilder.bind(queueTopic1()).to(exchangeTopic()).with("topic.#");
}
@Bean
public Binding bindingTopic2() {
return BindingBuilder.bind(queueTopic2()).to(exchangeTopic()).with("topic.*");
}
topic.# 其中#为0个或者多个
topic.* 其中 星号为1个
WorkReceiveListener
@RabbitListener(queues = "queue_topic1")
public void receiveMsg3(String msg) {
System.out.println("消费者1接收到：" + msg);
}
@RabbitListener(queues = "queue_topic2")
public void receiveMsg4(String msg) {
System.out.println("消费者2接收到：" + msg);
}
RabbitmqController
@RequestMapping("/sendTopic")
public String sendTopic() {
rabbitmqService.sendTopic();
return "发送成功...";
}
RabbitmqService
void sendTopic();
RabbitmqServiceImpl
@Override
public void sendTopic() {
rabbitmqMapper.sendTopic();
}
RabbitmqMapper
public void sendTopic() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
rabbitTemplate.convertSendAndReceive("exchange_topic", "topic.km.topic", "测试发布订阅模型：" + i);
} else {
rabbitTemplate.convertSendAndReceive("exchange_topic", "topic.km", "测试发布订阅模型：" + i);
}
}
}
rabbitTemplate.convertSendAndReceive()方法是直到消费者确认收到了消息在发送下一个消息
rabbitTemplate.convertAndSend()方法是一股脑的将所有消息发送到队列
测试
发送请求http://localhost:8080/sendTopic
消费者1接收到：测试发布订阅模型：0
消费者1接收到：测试发布订阅模型：1
消费者2接收到：测试发布订阅模型：1
消费者1接收到：测试发布订阅模型：2
消费者2接收到：测试发布订阅模型：3
消费者1接收到：测试发布订阅模型：3
消费者1接收到：测试发布订阅模型：4
消费者2接收到：测试发布订阅模型：5
消费者1接收到：测试发布订阅模型：5
消费者1接收到：测试发布订阅模型：6
消费者1接收到：测试发布订阅模型：7
消费者2接收到：测试发布订阅模型：7
消费者1接收到：测试发布订阅模型：8
消费者2接收到：测试发布订阅模型：9
消费者1接收到：测试发布订阅模型：9
可以看到
监听queue_topic1队列收到了全部的10条消息，而queue_topic2只收到了五条消息
4.7.confirm 机制
RabbitmqConfig
// 测试confirm 机制，专门创建了一个队列
@Bean
public Queue queueConfirm() {
return new Queue("queue_confirm");
}
WorkReceiveListener
@RabbitListener(queues = "queue_confirm")
public void receiveMsg(User user) {
System.out.println("接收到的消息为：" + user);
}
RabbitmqController
@RequestMapping("/sendConfirm")
public String sendConfirm() {
rabbitmqService.sendConfirm();
return "发送成功...";
}
RabbitmqService
void sendConfirm();
RabbitmqServiceImpl
@Override
public void sendConfirm() {
rabbitmqMapper.sendConfirm();
}
User
package com.tang.rabbitmq.pojo;/*
* @author Dram
* @create 2021-04-16 13:52
*/
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
private static final long serialVersionUID = 8142836626401616290L;
private Integer id;
private String name;
private String password;
}
RabbitmqMapper
public void sendConfirm() {
rabbitTemplate.convertAndSend("queue_confirm", new User(1, "km", "km123"), new CorrelationData("" + System.currentTimeMillis()));
rabbitTemplate.setConfirmCallback(confirmCallback);
}
// 配置 confirm 机制
private final RabbitTemplate.ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {
/**
* @param correlationData 消息相关的数据，一般用于获取 唯一标识 id
* @param b true 消息确认成功，false 失败
* @param s 确认失败的原因
*/
@Override
public void confirm(CorrelationData correlationData, boolean b, String s) {
if (b) {
System.out.println("confirm 消息确认成功..." + correlationData.getId());
} else {
System.out.println("confirm 消息确认失败..." + correlationData.getId() + " cause: " + s);
}
}
};
测试
发生请求http://localhost:8080/sendConfirm
接收到的消息为：User(id=1, name=km, password=km123)
confirm 消息确认成功...1618839044858
4.8.return机制
RabbitmqConfig
// 测试return机制
@Bean
public Queue queueReturn() {
return new Queue("queue_return");
}
@Bean
public TopicExchange exchangeReturn() {
return new TopicExchange("exchange_return");
}
@Bean
public Binding bindingReturn() {
return BindingBuilder.bind(queueReturn()).to(exchangeReturn()).with("return.*");
}
RabbitmqController
@RequestMapping("/sendReturn")
public String sendReturn() {
rabbitmqService.sendReturn();
return "发送成功...";
}
RabbitmqService
void sendReturn();
RabbitmqServiceImpl
@Override
public void sendReturn() {
rabbitmqMapper.sendReturn();
}
RabbitmqMapper
public void sendReturn() {
rabbitTemplate.setReturnsCallback(returnedMessage -> {
Message message = returnedMessage.getMessage();
String mes = new String(message.getBody());
System.out.println(mes);
});
// rabbitTemplate.setReturnCallback(returnCallback);
rabbitTemplate.convertAndSend("exchange_return", "return.km.km", "测试 return 机制");
// rabbitTemplate.convertAndSend("exchange_return", "return.km", "测试 return 机制");
}
测试
发送请求http://localhost:8080/sendReturn
测试 return 机制
当发送消息的时候与交换机与队列绑定的路由不一致时 return机制触发
4.9.延迟机制
4.9.1.延迟队列
- 延迟队列–消息进入到队列之后，延迟指定的时间才能被消费者消费
- AMQP协议和RabbitMq队列本身是不支持延迟队列功能的,但是可以通过TTL(Time To Live)特性模拟延迟队列的功能
- TTL就是消息的存活时间。RabbitMq可以分别对队列和消息设置存活时间
- 在创建队列的时候可以设置队列的存活时间,当消息进入到队列并且在存活时间内没有消费者消费,则此消息就会从当前队列中移除
- 创建消息没有设置TTL，但是消息设置了TTL，那么当消息的存活时间结束,也会被移除
- 当TTL结束之后,我们可以指定将当前队列的消息转存到其他指定的队列
4.9.2.使用延迟队列实现订单支付监控
实现流程图
代码实现
RabbitmqConfig
public static final String IMMEDIATE_QUEUE = "queue.demo.immediate";//立即消费的队列名称
public static final String IMMEDIATE_EXCHANGE = "exchange.demo.immediate";//立即消费的exchange
public static final String IMMEDIATE_ROUTING_KEY = "routingkey.demo.immediate";//立即消费的routing-key 名称
public static final String DELAY_QUEUE= "queue.demo.delay";//延时消费的队列名称
public static final String DEAD_LETTER_EXCHANGE = "exchange.demo.delay";//延时消费的exchange
public static final String DELAY_ROUTING_KEY = "routingkey.demo.delay";//延时消费的routing-key名称
// 创建一个立即消费队列
@Bean
public Queue immediateQueue() {
// 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
return new Queue(IMMEDIATE_QUEUE, true);
}
// 创建一个延时队列
@Bean
public Queue delayQueue() {
Map<String, Object> params = new HashMap<>();
//设置队列的存活时间
params.put("x-message-ttl", 1000*10);
// x-dead-letter-exchange 声明了队列里的死信转发到的DLX名称，
params.put("x-dead-letter-exchange", IMMEDIATE_EXCHANGE);
// x-dead-letter-routing-key 声明了这些死信在转发时携带的 routing-key 名称。
params.put("x-dead-letter-routing-key", IMMEDIATE_ROUTING_KEY);
return new Queue(DELAY_QUEUE, true, false, false, params);
}
@Bean
public DirectExchange immediateExchange() {
// 一共有三种构造方法，可以只传exchange的名字， 第二种，可以传exchange名字，是否支持持久化，是否可以自动删除，
//第三种在第二种参数上可以增加Map，Map中可以存放自定义exchange中的参数
return new DirectExchange(IMMEDIATE_EXCHANGE, true, false);
}
@Bean
public DirectExchange deadLetterExchange() {
// 一共有三种构造方法，可以只传exchange的名字， 第二种，可以传exchange名字，是否支持持久化，是否可以自动删除，
// 第三种在第二种参数上可以增加Map，Map中可以存放自定义exchange中的参数
return new DirectExchange(DEAD_LETTER_EXCHANGE, true, false);
}
//把立即消费的队列和立即消费的exchange绑定在一起
@Bean
public Binding immediateBinding() {
return BindingBuilder.bind(immediateQueue()).to(immediateExchange()).with(IMMEDIATE_ROUTING_KEY);
}
//把延时消费的队列和延时消费的exchange绑定在一起
@Bean
public Binding delayBinding() {
return BindingBuilder.bind(delayQueue()).to(deadLetterExchange()).with(DELAY_ROUTING_KEY);
}
WorkReceiveListener
@RabbitListener(queues = "queue.demo.immediate")
public void receiveDelayMsg(String msg) {
System.out.println(msg);
}
RabbitmqController
@RequestMapping("/sendDelay")
public String sendDelay() {
rabbitmqService.sendDelay();
return "发送成功...";
}
RabbitmqService
void sendDelay();
RabbitmqServiceImpl
@Override
public void sendDelay() {
rabbitmqMapper.sendDelay();
}
RabbitmqMapper
public void sendDelay() {
rabbitTemplate.convertAndSend("exchange.demo.delay","routingkey.demo.delay","测试延迟机制");
}
测试
发送请求http://localhost:8080/sendDelay
测试延迟机制
十秒之后监听到了queue.demo.immediate队列中的消息
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
