RabbitMQ
主要内容
- AMQP 简介
- RabbitMQ 简介
- RabbitMQ 原理
- Erlang 安装
- 安装 RabbitMQ
- RabbitMQ 账户管理
- 交换器
一、AMQP简介
1 AMQP是什么?
AMQP(Advanced Message Queuing Protocol),高级消息队列协议)是进程之间传递 异步消息的网络协议。
2 AMQP 工作过程
发布者(Publisher)发布消息(Message),经过交换机(Exchange),交换机根据路由规则将收到消息分发给交换机绑定的队列(Queue),最后 AMQP 代理会将消息投递给订阅了此 队列的消费者,或者消费者按照需求自行获取。
3 队列
队列是数据结构中概念。数据存储在一个队列中,数据是有顺序的,先进的先出,后进 后出。其中一侧负责进数据,另一次负责出数据。 MQ(消息队列)很多功能都是基于此队列结构实现的
二、 RabbitMQ 简介
1 RabbitMQ
介绍 RabbitMQ 是由 Erlang 语言编写的基于 AMQP 的消息中间件。而消息中间件作为分 布式系统重要组件之一,可以解决应用耦合,异步消息,流量削峰等问题。
1.1 解决应用耦合
1.1.1 不使用 MQ 时
1.1.2 使用 MQ 解决耦合
2 RabbitMQ 适用场景
排队算法、秒杀活动、消息分发、异步处理、数据同步、处理耗时任务、流量销峰等。
三、 RabbitMQ 原理
1.Message 消息。
消息是不具名的,它由消息头消息体组成。消息体是不透明的,而消息头则由 一系列可选属性组成,这些属性包括:routing-key(路由键)、priority(相对于其他消息的 优先权)、delivery-mode(指出消息可能持久性存储)等。
2.Publisher
消息的生产者。也是一个向交换器发布消息的客户端应用程序。
3.Consumer
消息的消费者。表示一个从消息队列中取得消息的客户端应用程序。
4.Exchange
交换器。用来接收生产者发送的消息并将这些消息路由给服务器中的队列。 三种常用的交换器类型
- direct(发布与订阅 完全匹配)
- fanout(广播)
- topic(主题,规则匹配)
5.Binding
绑定。用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息 队列连接起来的路由规则,所以可以将交换器理解成一个由绑定构成的路由表。
6.Queue
消息队列。用来保存消息直到发送给消费者。它是消息的容器,也是消息的终点。一 个消息可投入一个或多个队列。消息一直在队列里面,等待消费者链接到这个队列将其取 走。
7.Routing-key
路由键。RabbitMQ 决定消息该投递到哪个队列的规则。(也可以理解为队列的名称, 路由键是 key,队列是 value)
队列通过路由键绑定到交换器。
消息发送到 MQ 服务器时,消息将拥有一个路由键,即便是空的,RabbitMQ 也会将 其和绑定使用的路由键进行匹配。
如果相匹配,消息将会投递到该队列。
如果不匹配,消息将会进入黑洞。
8.Connection
链接。指 rabbit 服务器和服务建立的 TCP 链接。
9.Channel
信道。
1,Channel 中文叫做信道,是 TCP 里面的虚拟链接。例如:电缆相当于 TCP,信道是一个独立光纤束,一条 TCP 连接上创建多条信道是没有问题的。
2,TCP 一旦打开,就会创建 AMQP 信道。
3,无论是发布消息、接收消息、订阅队列,这些动作都是通过信道完成的。
10.Virtual Host
虚拟主机。表示一批交换器,消息队列和相关对象。虚拟主机是共享相同的身份认证 和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器, 拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础,必须在链接时 指定,RabbitMQ 默认的 vhost 是/
11.Borker
表示消息队列服务器实体。
交换器和队列的关系
交换器是通过路由键和队列绑定在一起的,如果消息拥有的路由键跟队列和交换器的 路由键匹配,那么消息就会被路由到该绑定的队列中。
也就是说,消息到队列的过程中,消息首先会经过交换器,接下来交换器在通过路由 键匹配分发消息到具体的队列中。
路由键可以理解为匹配的规则。
RabbitMQ 为什么需要信道?为什么不是 TCP 直接通信?
- TCP 的创建和销毁开销特别大。创建需要 3 次握手,销毁需要 4 次分手。
- 如果不用信道,那应用程序就会以 TCP 链接 Rabbit,高峰时每秒成千上万条链接 会造成资源巨大的浪费,而且操作系统每秒处理 TCP 链接数也是有限制的,必定造成性能 瓶颈。
- 信道的原理是一条线程一条通道,多条线程多条通道同用一条 TCP 链接。一条 TCP 链接可以容纳无限的信道,即使每秒成千上万的请求也不会成为性能的瓶颈。
四、Erlang安装
RabbitMQ 是使用 Erlang 语言编写的,所以需要先配置 Erlang
1 修改主机名
RabbitMQ 是通过主机名进行访问的,必须指定能访问的主机名。
# vim /etc/sysconfig/network
# vim /etc/hosts
新添加了一行,前面为服务器 ip,空格后面添加计算机主机名
2 安装依赖
# yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel unixODBC unixODBC-devel
3 上传并解压
上传 otp_src_22.0.tar.gz 到/usr/local/tmp 目录中,进入目录并解压。
解压时注意,此压缩包不具有 gzip 属性,解压参数没有 z,只有 xf
# cd /usr/local/tmp
# tar xf otp_src_22.0.tar.gz
4 配置参数
先新建/usr/local/erlang 文件夹,作为安装文件夹
#mkdir -p /usr/local/erlang
进入文件夹
# cd otp_src_22.0
配置参数
# ./configure --prefix=/usr/local/erlang --with-ssl --enable-threads --enable-smp-support --enable-kernel-poll --enable-hipe --without-javac
5 编译并安装
编译
# make
安装
# make install
6 修改环境变量
希望能够在任意位置执行erl命令
修改/etc/profile 文件
#vim /etc/profile
在文件中添加下面代码
export PATH=$PATH:/usr/local/erlang/bin
运行文件,让修改内容生效
# source /etc/profile
7 查看配置是否成功
# erl -version
五、 安装 RabbitMQ
1 上传并解压
上传 rabbitmq-server-generic-unix-3.7.17.tar.xz 到/usr/loca/tmp 中
# cd /usr/local/tmp
# tar xf rabbitmq-server-generic-unix-3.7.17.tar.xz
2 复制到 local 下
复制解压文件到/usr/local 下,命名为 rabbitmq
# cp -r rabbitmq_server-3.7.17 /usr/local/rabbitmq
3 配置环境变量
# vim /etc/profile
在文件中添加
export PATH=$PATH:/usr/local/rabbitmq/sbin
解析文件
# source /etc/profile
4 开启 web 管理插件
进入 rabbitmq/sbin 目录
# cd /usr/local/rabbitmq/sbin
查看插件列表
# ./rabbitmq-plugins list
生效管理插件
# ./rabbitmq-plugins enable rabbitmq_management
5 后台运行
启动 rabbitmq。
#./rabbitmq-server -detached
停止命令,如果无法停止,使用 kill -9 进程号
进行关闭
./rabbitmqctl stop_app
启动成功信息如下:
5.1 启动错误解决
如果启动RabbitMQ 发生下述错误,可以提供环境配置文件,解决。环境配置文件命 名为: rabbitmq-env.conf。所在位置是: $rabbitmq_home/etc/rabbitmq/目录。内如 是: HOSTNAME=主机名称
解决:
6 查看 web 管理界面
默认可以在安装 rabbitmq 的电脑上通过用户名:guest 密码 guest 进行访问 web 管 理界面
端口号:15672(放行端口,或关闭防火墙)
在虚拟机浏览器中输入:http://localhost:15672
六、 RabbitMq 账户管理
1 创建账户
语法:./rabbitmqctl add_user username password
# cd /usr/local/rabbitmq/sbin
# ./rabbitmqctl add_user admin admin123
2 给用户授予管理员角色
其中 smallming 为新建用户的用户名 ,多个角色可以用空格分隔
# ./rabbitmqctl set_user_tags admin administrator
3 给用户授权
“/”
表示 RabbitMQ 根虚拟主机
admin
表示用户名
".*" ".*" ".*"
表示完整权限
# ./rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*"
4 登录
使用新建账户和密码在 windows 中访问 rabbitmq 并登录
在浏览器地址栏输入:http://ip:15672/
用户名:admin
密码:admin123
七、 Exchange 交换器(交换机)
交换器负责接收客户端传递过来的消息,并转发到对应的队列中。在 RabbitMQ 中支 持四种交换器
- Direct Exchange:直连交换器(默认)
- Fanout Exchange:扇形交换器
- Topic Exchange:主题交换器
- Header Exchange:首部交换器。
在 RabbitMq 的 Web 管理界面中 Exchanges 选项卡就可以看见这四个交换器。
1 direct 交换器
direct 交换器是RabbitMQ默认交换器。默认会进行公平调度。所有接受者依次从消 息队列中获取值。Publisher 给哪个队列发消息,就一定是给哪个队列发送消息。对交换器 绑定的其他队列没有任何影响。
(代码演示)一个队列需要绑定多个消费者
需要使用注解/API:
org.springframework.amqp.core.Queue:队列
AmqpTemplate:操作 RabbitMQ 的接口。负责发送或接收消息
@RabbitListener(queues = "") 注解某个方法为接收消息方法
1.1 代码实现
1.1.1 新建项目 Publisher
1.1.1.1添加依赖
<?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>
<groupId>com.bjsxt</groupId>
<artifactId>amqp_rabbit</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.5.RELEASE</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Spring Boot提供的关于AMQP协议实现的启动器。可以使用AMQP协议快速的访问MQ消息中间件。 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
</dependencies>
</project>
创建Consumer
RabbitMQ_direct交换器_消息消费者处理逻辑代码开发_RabbitListener注解描述类型
package com.bjsxt.rabbit.consumer;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;
/**
* 日志消息消费者,只消费Info日志。
* 日志消息存储在队列 log-info-queue
* 使用的交换器名称是 log-ex-direct
* 交换器类型是 direct
* 队列的路由键是 direct-rk-info
*
* 注解RabbitListener - 监听注解。可以描述类型和方法。
* 类型 - 当前类型监听某个队列。
* 方法 - 当前方法监听某个队列。
* 属性 -
* bindings - QueueBinding[]类型,代表这个类型或方法监听的队列、交换器、路由键的绑定方式
* 注解QueueBinding -
* 属性 -
* value - 绑定监听的队列是什么
* exchange - 队列对应的交换器是什么
* key - 队列的路由键是什么
* 注解Queue - 描述一个队列
* 属性 -
* value|name - 队列名称
* autoDelete - 是否自动删除。默认为"", 如果队列名称定义,不自动删除;队列名称不定义,队列为自动删除队列。
* 如果是自动删除,代表所有的consumer关闭后,队列自动删除。
* 注解Exchange - 描述一个交换器
* 属性 -
* value|name - 交换器名称
* type - 交换器的类型,可选direct|fanout|topic, 默认direct
* autoDelete - 是否自动删除,默认为false。不自动删除。
*/
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "log-info-queue", autoDelete = "false"),
exchange = @Exchange(value = "log-ex-direct", type = "direct", autoDelete = "false"),
key = "direct-rk-info"
)
})
@Component
public class InfoLogConsumer {
/**
* 消息消费的方法。当队列log-info-queue中出现消息,立刻消费。
*
* RabbitHandler注解 - 配合类型上的RabbitListener注解,标记当前的方法,是一个监听消息队列,消费消息的方法。
*
* @param msg 消息内容。
*/
@RabbitHandler
public void onMessage(String msg){
System.out.println("InfoLogConsumer 消费消息:" + msg);
}
}
RabbitMQ_direct交换器_消息消费者配置及启动
创建启动类
package com.bjsxt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RabbitConsumerApp {
public static void main(String[] args) {
SpringApplication.run(RabbitConsumerApp.class, args);
}
}
1.1.1.2编写配置文件
新建 application.yml.
host:默认值 localhost
username 默认值:guest
password 默认值:guest
spring:
rabbitmq:
host: 192.168.89.141 # RabbitMQ服务的地址,默认localhost
port: 5672 # RabbitMQ的端口,默认5672。
username: bjsxt # 访问RabbitMQ的用户名,默认guest
password: bjsxt # 访问RabbitMQ的密码,默认guest
virtual-host: / # 访问RabbitMQ的哪一个虚拟主机,默认为 /
启动测试
RabbitMQ_direct交换器_消息消费者处理逻辑代码开发_RabbitListener注解描述方法
创建LogConsumers
package com.bjsxt.rabbit.consumer;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* 日志消息消费者,消费error和warn日志。
* error日志消息存储在队列 log-error-queue
* warn日志消息存储在队列 log-warn-queue
* 使用的交换器名称是 log-ex-direct
* 交换器类型是 direct
* error队列的路由键是 direct-rk-error
* warn队列的路由键是 direct-rk-warn
*/
@Component
public class LogConsumers {
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "log-error-queue"),
exchange = @Exchange(value = "log-ex-direct"),
key = "direct-rk-error"
)
})
public void onLogErrorMessage(String msg){
System.out.println("错误日志信息:" + msg);
}
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "log-warn-queue", autoDelete = "false"),
exchange = @Exchange(value = "log-ex-direct"),
key = "direct-rk-warn"
)
})
public void onLogWarnMessage(String msg){
System.out.println("警告日志信息:" + msg);
}
}
启动测试
RabbitMQ_direct交换器_消息发送者代码开发
创建publisher
package com.bjsxt.rabbit.sender;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* 发送消息的类型。
* 把消息发送到RabbitMQ中。
* 在spring-boot-starter-amqp中,启动器自动创建初始化一个AmqpTemplate,
* 作为访问Amqp消息服务器(MQ中间件)的客户端对象。
*/
@Component
public class LogMessageSender {
@Autowired
private AmqpTemplate template;
/**
* 发送消息的方法。
* template.convertAndSend(String exchange, String routingKey, Object message)
* exchange - 交换器名称
* routingKey - 路由键
* message - 要发送的消息内容,就是传递的消息对象的消息体。
*/
public void sendMessage(String exchange, String routingKey, String message){
this.template.convertAndSend(exchange, routingKey, message);
}
}
创建启动类
package com.bjsxt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RabbitPublisherApp {
public static void main(String[] args) {
SpringApplication.run(RabbitPublisherApp.class, args);
}
}
创建测试代码
package com.bjsxt.test;
import com.bjsxt.RabbitPublisherApp;
import com.bjsxt.entity.User;
import com.bjsxt.rabbit.fanoutsender.UserMessageSender;
import com.bjsxt.rabbit.sender.LogMessageSender;
import com.bjsxt.rabbit.topicsender.TopicMessageSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Random;
/**
* 消息发送者测试类型
*/
@SpringBootTest(classes = {RabbitPublisherApp.class})
@RunWith(SpringRunner.class)
public class TestPublisher {
@Autowired
private LogMessageSender sender;
@Autowired
private UserMessageSender userMessageSender;
@Autowired
private TopicMessageSender topicMessageSender;
private String exchange = "log-ex-direct";
private String rkInfo = "direct-rk-info";
private String rkError = "direct-rk-error";
private String rkWarn = "direct-rk-warn";
@Test
public void testSend(){
Random r = new Random();
// 发送10条消息。
for(int i = 0 ; i < 10; i++){
// rInt%3 - 0:投递消息到info;1:投递消息到error;2:投递消息到warn
int rInt = r.nextInt(100);
if(rInt%3 == 0){
this.sender.sendMessage(exchange, rkInfo, "发送Info日志消息 - index="+i+";rInt="+rInt);
}else if(rInt%3 == 1){
this.sender.sendMessage(exchange, rkError, "发送error日志消息 - index="+i+";rInt="+rInt);
}else{
this.sender.sendMessage(exchange, rkWarn, "发送warn日志消息 - index="+i+";rInt="+rInt);
}
}
}
}
编写配置文件
spring:
rabbitmq:
host: 192.168.89.141
username: bjsxt
password: bjsxt
启动测试
先启动Consumer
运行testSend
RabbitMQ_direct交换器_消息消费者集群搭建方式
相同代码启动多次,自动搭建Consumer集群
package com.bjsxt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RabbitConsumerApp1 {
public static void main(String[] args) {
SpringApplication.run(RabbitConsumerApp1.class, args);
}
}
创建测试代码
package com.bjsxt.test;
import com.bjsxt.RabbitPublisherApp;
import com.bjsxt.entity.User;
import com.bjsxt.rabbit.fanoutsender.UserMessageSender;
import com.bjsxt.rabbit.sender.LogMessageSender;
import com.bjsxt.rabbit.topicsender.TopicMessageSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Random;
/**
* 消息发送者测试类型
*/
@SpringBootTest(classes = {RabbitPublisherApp.class})
@RunWith(SpringRunner.class)
public class TestPublisher {
@Autowired
private LogMessageSender sender;
@Autowired
private UserMessageSender userMessageSender;
@Autowired
private TopicMessageSender topicMessageSender;
private String exchange = "log-ex-direct";
private String rkInfo = "direct-rk-info";
private String rkError = "direct-rk-error";
private String rkWarn = "direct-rk-warn";
@Test
public void testSend2Consumers(){
for(int i = 0; i < 10; i++){
this.sender.sendMessage(exchange, rkInfo, "info消息"+i);
this.sender.sendMessage(exchange, rkError, "error消息"+i);
this.sender.sendMessage(exchange, rkWarn, "warn消息"+i);
}
}
@Test
public void testSend(){
Random r = new Random();
// 发送10条消息。
for(int i = 0 ; i < 10; i++){
// rInt%3 - 0:投递消息到info;1:投递消息到error;2:投递消息到warn
int rInt = r.nextInt(100);
if(rInt%3 == 0){
this.sender.sendMessage(exchange, rkInfo, "发送Info日志消息 - index="+i+";rInt="+rInt);
}else if(rInt%3 == 1){
this.sender.sendMessage(exchange, rkError, "发送error日志消息 - index="+i+";rInt="+rInt);
}else{
this.sender.sendMessage(exchange, rkWarn, "发送warn日志消息 - index="+i+";rInt="+rInt);
}
}
}
}
2 fanout 交换器
扇形交换器,实际上做的事情就是广播,fanout 会把消息发送给所有的绑定在当前交 换器上的队列。对应 Consumer 依然采用公平调度方式。
(代码演示)一个交换器需要绑定多个队列
需要使用注解/API:
- FanoutExchange:fanout 交换器
- Binding:绑定交换器和队列
- BindingBuilder:Binding 的构建器
- amq.fanout:内置 fanout 交换器名称
2.1 RabbitMQ_fanout交换器_消息消费者代码开发
2.1.1 代码
创建pojo
package com.bjsxt.entity;
import java.io.Serializable;
import java.util.Objects;
// 实体类型
public class User implements Serializable {
// 定义一个序列化唯一ID。
public static final long serialVersionUID = 1L;
private Long id;
private String name;
private int age;
public User(){}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(id, user.id) &&
Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age);
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
创建 FanoutConsumers
package com.bjsxt.rabbit.fanout;
import com.bjsxt.entity.User;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* 广播交换器,消费者。
*/
@Component
public class FanoutConsumers {
/**
* 消费消息的方法。
* @param user 消息体内容。
*/
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "queue-user-1", autoDelete = "false"),
exchange = @Exchange(value = "ex-fanout", type = "fanout", autoDelete = "false")
)
})
public void onMessage1(User user){
System.out.println("onMessage1 run : " + user);
}
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "queue-user-2", autoDelete = "false"),
exchange = @Exchange(value = "ex-fanout", type = "fanout")
)
})
public void onMessage2(User user){
System.out.println("onMessage2 run : " + user);
}
}
启动查看
2.2RabbitMQ_fanout交换器_消息发送者代码开发
2.2.1 创建发送消息者
package com.bjsxt.rabbit.fanoutsender;
import com.bjsxt.entity.User;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* 发送消息类型。消息发送到fanout交换器中。
* 交换器名称是: ex-fanout
*/
@Component
public class UserMessageSender {
@Autowired
private AmqpTemplate template;
/**
* 发送消息方法。
* @param user
*/
public void send(User user){
this.template.convertAndSend("ex-fanout", "", user);
}
}
创建测试代码
package com.bjsxt.test;
import com.bjsxt.RabbitPublisherApp;
import com.bjsxt.entity.User;
import com.bjsxt.rabbit.fanoutsender.UserMessageSender;
import com.bjsxt.rabbit.sender.LogMessageSender;
import com.bjsxt.rabbit.topicsender.TopicMessageSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Random;
/**
* 消息发送者测试类型
*/
@SpringBootTest(classes = {RabbitPublisherApp.class})
@RunWith(SpringRunner.class)
public class TestPublisher {
@Autowired
private LogMessageSender sender;
@Autowired
private UserMessageSender userMessageSender;
@Autowired
private TopicMessageSender topicMessageSender;
private String exchange = "log-ex-direct";
private String rkInfo = "direct-rk-info";
private String rkError = "direct-rk-error";
private String rkWarn = "direct-rk-warn";
@Test
public void testSendUserMessage2Fanout(){
for(int i = 0; i < 3; i++){
User user = new User();
user.setId((long) i);
user.setName("姓名 - " + i);
user.setAge(20+i);
this.userMessageSender.send(user);
}
}
@Test
public void testSend2Consumers(){
for(int i = 0; i < 10; i++){
this.sender.sendMessage(exchange, rkInfo, "info消息"+i);
this.sender.sendMessage(exchange, rkError, "error消息"+i);
this.sender.sendMessage(exchange, rkWarn, "warn消息"+i);
}
}
@Test
public void testSend(){
Random r = new Random();
// 发送10条消息。
for(int i = 0 ; i < 10; i++){
// rInt%3 - 0:投递消息到info;1:投递消息到error;2:投递消息到warn
int rInt = r.nextInt(100);
if(rInt%3 == 0){
this.sender.sendMessage(exchange, rkInfo, "发送Info日志消息 - index="+i+";rInt="+rInt);
}else if(rInt%3 == 1){
this.sender.sendMessage(exchange, rkError, "发送error日志消息 - index="+i+";rInt="+rInt);
}else{
this.sender.sendMessage(exchange, rkWarn, "发送warn日志消息 - index="+i+";rInt="+rInt);
}
}
}
}
先启动Consumer
启动 testSendUserMessage2Fanout
3 topic 交换器
3.1 RabbitMQ_topic交换器_执行流程介绍
允许在路由键(RoutingKey)中出现匹配规则。
路由键的写法和包写法相同。com.bjsxt.xxxx.xxx 格式。
在绑定时可以带有下面特殊符号,中间可以出现:
* : 代表一个单词(两个.之间内容)
# : 0 个或多个字符
接收方依然是公平调度,同一个队列中内容轮换获取值。
需要使用注解/API:
- TopicExchange:Topic 交换器
- amq.topic:内置 topic 交换器名称
RabbitMQ_topic交换器_消息消费者代码开发
代码
创建Consumer
package com.bjsxt.rabbit.topic;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* 主题消息消费者。
*/
@Component
public class TopicConsumers {
/**
* 短信消息消费者,对应的routingKey是 user.rk.sms | order.rk.sms | pay.rk.sms | reg.rk.sms 等。
* 分别代表,用户登录短信|订单下订成功通知短信|支付成功通知短信|注册码通知短信 等。
*/
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "queue-sms-topic", autoDelete = "false"),
exchange = @Exchange(value = "ex-topic", type = "topic"),
key = "*.rk.sms"
)
})
public void onUserSMSMessage(String message){
System.out.println("用户短信消息内容是:" + message);
}
/**
* 路由键包括: user.rk.email | reg.rk.email | pay.rk.email
* @param message
*/
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "queue-email-topic", autoDelete = "false"),
exchange = @Exchange(value = "ex-topic", type = "topic"),
key = "*.rk.email"
)
})
public void onUserEmailMessage(String message){
System.out.println("用户邮件消息内容是:" + message);
}
/**
* 所有的和 rk相关的消息,统一处理消费。
* 包含的路由键有: user.rk.sms | user.rk.email | reg.rk.sms | reg.rk.email 等。
* 不发短信,不发邮件,作为一个日志记录工具存在。
* @param message
*/
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "queue-all-topic", autoDelete = "false"),
exchange = @Exchange(value = "ex-topic", type = "topic"),
key = "*.rk.*"
)
})
public void onUserServiceMessage(String message){
System.out.println("执行的消息处理逻辑是:" + message);
}
}
启动RabbitConsumerAPP
RabbitMQ_topic交换器_消息发送者代码开发
代码
package com.bjsxt.rabbit.topicsender;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* 发送消息到主题交换器
*/
@Component
public class TopicMessageSender {
@Autowired
private AmqpTemplate template;
/**
* 发送消息的方法
* @param exchange
* @param routingKey
* @param message
*/
public void send(String exchange, String routingKey, String message){
template.convertAndSend(exchange, routingKey, message);
}
}
创建测试类
package com.bjsxt.test;
import com.bjsxt.RabbitPublisherApp;
import com.bjsxt.entity.User;
import com.bjsxt.rabbit.fanoutsender.UserMessageSender;
import com.bjsxt.rabbit.sender.LogMessageSender;
import com.bjsxt.rabbit.topicsender.TopicMessageSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Random;
/**
* 消息发送者测试类型
*/
@SpringBootTest(classes = {RabbitPublisherApp.class})
@RunWith(SpringRunner.class)
public class TestPublisher {
@Autowired
private LogMessageSender sender;
@Autowired
private UserMessageSender userMessageSender;
@Autowired
private TopicMessageSender topicMessageSender;
private String exchange = "log-ex-direct";
private String rkInfo = "direct-rk-info";
private String rkError = "direct-rk-error";
private String rkWarn = "direct-rk-warn";
@Test
public void testSendMessage2Topic(){
// 随机数%6
// 0 rk - user.rk.sms *.rk.* *.rk.sms
// 1 rk - user.rk.email *.rk.* *.rk.email
// 2 rk - order.rk.sms *.rk.* *.rk.sms
// 3 rk - order.rk.email *.rk.* *.rk.email
// 4 rk - reg.rk.sms *.rk.* *.rk.sms
// 5 rk - reg.rk.qq *.rk.*
Random r = new Random();
for(int i = 0; i < 10; i++){
int rInt = r.nextInt(100);
if(rInt%6 == 0){
this.topicMessageSender.send("ex-topic",
"user.rk.sms",
"用户登录验证码是123456 - 发送短信");
}else if(rInt%6 == 1){
this.topicMessageSender.send("ex-topic",
"user.rk.email",
"用户登录验证码是123456 - 发送到邮箱");
}else if(rInt%6 == 2){
this.topicMessageSender.send("ex-topic",
"order.rk.sms",
"订单下订成功 - 发送短信");
}else if(rInt%6 == 3){
this.topicMessageSender.send("ex-topic",
"order.rk.email",
"订单下订成功 - 发送到邮箱");
}else if(rInt%6 == 4){
this.topicMessageSender.send("ex-topic",
"reg.rk.sms",
"注册验证码是654321 - 发送短信");
}else if(rInt%6 == 5){
this.topicMessageSender.send("ex-topic",
"reg.rk.qq",
"注册验证码是654321 - 发送QQ信息");
}
}
}
@Test
public void testSendUserMessage2Fanout(){
for(int i = 0; i < 3; i++){
User user = new User();
user.setId((long) i);
user.setName("姓名 - " + i);
user.setAge(20+i);
this.userMessageSender.send(user);
}
}
@Test
public void testSend2Consumers(){
for(int i = 0; i < 10; i++){
this.sender.sendMessage(exchange, rkInfo, "info消息"+i);
this.sender.sendMessage(exchange, rkError, "error消息"+i);
this.sender.sendMessage(exchange, rkWarn, "warn消息"+i);
}
}
@Test
public void testSend(){
Random r = new Random();
// 发送10条消息。
for(int i = 0 ; i < 10; i++){
// rInt%3 - 0:投递消息到info;1:投递消息到error;2:投递消息到warn
int rInt = r.nextInt(100);
if(rInt%3 == 0){
this.sender.sendMessage(exchange, rkInfo, "发送Info日志消息 - index="+i+";rInt="+rInt);
}else if(rInt%3 == 1){
this.sender.sendMessage(exchange, rkError, "发送error日志消息 - index="+i+";rInt="+rInt);
}else{
this.sender.sendMessage(exchange, rkWarn, "发送warn日志消息 - index="+i+";rInt="+rInt);
}
}
}
}
先运行Consumer
运行testSendMessage2Topic
项目练习源码:https://gitee.com/cutelili/rabbit-mq/tree/master/amqp_rabbit