当前位置： 首页 > news >正文

RabbitMQ

news 2025/11/26 15:59:34

目录

同步调用：一次只能干一件事

 异步通信：一次可以同时做很多事

MQ(MessageQueue)

docker安装RabbitMq

第一步：拉取镜像

第二步：启动rabbitmq

方式一：直接启动

方式二：使用docker-compose创建并运行容器

 RabbitMQ消息模型

一.基本消息队列（BasicQueue）

二. 工作消息队列（WorkQueue）

三.发布订阅（Publish、Subscribe）

1.Fanout Exchange：广播

 2.Direct Exchange：路由

3.topic Exchange：主题 

SpringAMQP

第一步：先创建一个SpringBoot项目，然后在当前项目创建出两个新的模块，分别命名为publisher,consumer。

第二步：修改主项目的打包方式为pom,java版本为1.8,springboot版本为2.3.10.RELEASE，并导入amqp的依赖

第三步：让两个模块继承这个主项目的依赖，使用标签

 第四步：在两个子模块下的applicaton.yml文件下配置连接RabbitMQ的信息

使用SpringAMQP处理基本消息队列

第一步：在publisher模块中书写发送消息队列的类

第二步： 在consumer模块书写接收消息队列的类

 使用SpringAMQP处理工作消息队列

publisher模块中发送消息的类

consumer模块中接收消息的类

在consumer模块中的application.yml文件中添加prefetch

使用SpringAMQP处理发布订阅之广播

publisher模块中发送消息的类

consumer模块中接收消息的类

我们也可以使用配置类来创建交换机和队列，并绑定

使用SpringAMQP处理发布订阅之路由

 consumer模块中接收消息的类

publisher模块中发送消息的类

使用SpringAMQP处理发布订阅之主题

  consumer模块中接收消息的类

publisher模块中发送消息的类

配置JSON转换器

在主项目的pom.xml文件中导入依赖

 在两个子模块中书写配置类，将MessageConverter交给IoC容器

同步调用：一次只能干一件事

同步调用的优点：
时效性高，可以立即得到结果

同步调用的问题：

  • 耦合度高
  • 性能下降
  • 有额外的资源消耗
  • 有级联失败的问题

 异步通信：一次可以同时做很多事

优点：

  • 耦合度低
  • 性能提升
  • 故障隔离
  • 流量削峰

缺点：

  • 依赖于Broker(事件代理者)的可靠性，安全性，性能提升能力
  • 架构变得更加复杂

MQ(MessageQueue)

MQ就是消息队列，就是事件驱动架构中的Broker

常用的MQ:RabbitMQ,ActiveMQ,RocketMQ,Kafka

docker安装RabbitMq

第一步：拉取镜像

docker pull rabbitmq:3.8-management

 

第二步：启动rabbitmq

方式一：直接启动
docker run \-e RABBITMQ_DEFAULT_USER=hhh \-e RABBITMQ_DEFAULT_PASS=1234 \-v mq-plugins:/plugins \--name mq \--hostname mq \-p 15672:15672 \-p 5672:5672 \-d \rabbitmq:3.8-management
# 设置环境变量  用户名是 hhh-e RABBITMQ_DEFAULT_USER=hhh \# 设置环境变量  密码是 1234-e RABBITMQ_DEFAULT_PASS=1234 \# 挂载数据卷，如果没有该数据卷会自己创建-v mq-plugins:/plugins \# mq的名字--name mq \# 主机名 这里不配置也可以--hostname mq \# web可视化终端监控端口；mq的ui界面管理平台端口-p 15672:15672 \# 程序与mq交互的访问端口；发消息和收消息的端口-p 5672:5672 \# 后端运行-d \# 镜像名称rabbitmq:3.8-management
[root@localhost docker-compose]# docker ps -a
CONTAINER ID   IMAGE                     COMMAND                   CREATED          STATUS          PORTS                                                                                                                                                 NAMES
ea34ab693409   rabbitmq:3.8-management   "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp   mq

 启动成功

方式二：使用docker-compose创建并运行容器

我们先把之前创建的容器删除

docker rm -f mq

yml文件内容

version: "3.2"services:mysql:image: mysql:5.7.25  #使用的镜像container_name: mysql_container #容器名字environment:MYSQL_ROOT_PASSWORD: 1234volumes:    #数据卷，绑定容器内的文件和宿主机文件- "/tmp/mysql/data:/var/lib/mysql"- "/tmp/mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf"ports:- "3306:3306"radditmq:image: rabbitmq:3.8-managementcontainer_name: mqenvironment:RABBITMQ_DEFAULT_USER: hhhRABBITMQ_DEFAULT_PASS: 1234volumes:- "mq-plugins:/plugins"ports:- "15672:15672"- "5672:5672"
volumes:mq-plugins: {} #要创建的数据卷

在yml文件所在目录使用命令

docker-compose up -d

[root@localhost docker-compose]# ll
总用量 4
-rw-r--r--. 1 root root 653 8月  19 12:06 docker-compose.yml
drwxr-xr-x. 2 root root  39 8月  18 21:35 myweb-service
[root@localhost docker-compose]# docker up -d

运行成功

[root@localhost docker-compose]# docker ps -a
CONTAINER ID   IMAGE                     COMMAND                   CREATED          STATUS          PORTS                                                                                                                                                 NAMES
1faf568f83de   mysql:5.7.25              "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                                                                                                  mysql_container
ea34ab693409   rabbitmq:3.8-management   "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp   mq
 

 RabbitMQ消息模型

一.基本消息队列（BasicQueue）

生产者将消息发送到队列，消费者从队列中获取消息，队列是存储消息的缓冲区。

二. 工作消息队列（WorkQueue）

工作消息队列是基本消息队列的增强版，具有多个消费者消费队列的消息。假设消息队列中积压了多个消息，那么此时可以使用多个消费者来消费队列中的消息。效率要比基本消息队列模型高。

三.发布订阅（Publish、Subscribe）

1.Fanout Exchange：广播

将消息交给所有绑定到交换机的队列,生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。交换机把消息发送给绑定过的所有队列.队列的消费者都能拿到消息。实现一条消息被多个消费者消费.

 2.Direct Exchange：路由

在广播模式中，生产者发布消息，所有消费者都可以获取所有消息.

使用路由模式时，生产者向Exchange发送消息，发送消息时，会指定一个routing key

Exchange（交换机）接收生产者的消息后，就会把把消息递交给 与routing key完全匹配的队列

3.topic Exchange：主题 

1.Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

2.Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

3.通配符规则：

#：匹配一个或多个词

*：匹配恰好1个词

SpringAMQP

第一步：先创建一个SpringBoot项目，然后在当前项目创建出两个新的模块，分别命名为publisher,consumer。

第二步：修改主项目的打包方式为pom,java版本为1.8,springboot版本为2.3.10.RELEASE，并导入amqp的依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.10.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.hhh</groupId><artifactId>spring_day10_mq</artifactId><version>0.0.1-SNAPSHOT</version><name>spring_day10_mq</name><description>spring_day10_mq</description><packaging>pom</packaging><properties><java.version>1.8</java.version></properties><dependencies><!--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><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

第三步：让两个模块继承这个主项目的依赖，使用<parent>标签

注意：模块的<artifactId>publisher</artifactId>不能少

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.hhh</groupId><artifactId>spring_day10_mq</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>publisher</artifactId>
</project>
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.hhh</groupId><artifactId>spring_day10_mq</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>consumer</artifactId>
</project>

 第四步：在两个子模块下的applicaton.yml文件下配置连接RabbitMQ的信息

logging:pattern:dateformat: MM-dd HH:mm:ss:SSS   #日志文件的格式
spring:rabbitmq:host: 192.168.230.100  # 主机名port: 5672 # 发送消息和接收消息的端口号virtual-host: / # 虚拟主机username: hhh # 用户名password: 1234 # 密码

使用SpringAMQP处理基本消息队列

第一步：在publisher模块中书写发送消息队列的类

@RunWith(SpringRunner.class)//TODO:是一个测试启动器，可以加载SpringBoot测试注解,让测试方法在Spring容器环境下执行
@SpringBootTest
public class BaseMessage {@AutowiredRabbitTemplate rabbitTemplate;@Testpublic void simpleMessage(){//1.定义队列名字String queue="simple.queue";//2.定义消息内容String msg="你好，这是hhh发送的消息";//3.发送消息rabbitTemplate.convertAndSend(queue,msg);}
}

点击发送之后，可以发现消息队列的总数变成1

第二步： 在consumer模块书写接收消息队列的类

//TODO:把这个交给Spring容器管理
@Component
public class BaseMessageListener {@RabbitListener(queues = "simple.queue")//只接受simple.queue队列的消息public void getBaseMassage(String msg){//定义参数来接收消息System.out.println(msg);}
}

启动SpringBoot引导类

接收成功，消息队列总数变成0

 使用SpringAMQP处理工作消息队列

思路就是使用多个监听类，来接收同一个消息队列的消息

publisher模块中发送消息的类

@Testpublic void workMessage(){//1.定义队列名字String queue="simple.queue";//2.定义消息String msg="这是工作消息";//3.发送消息for(int i=0;i<50;i++){rabbitTemplate.convertAndSend(queue,msg+i);}}

consumer模块中接收消息的类

public class BaseMessageListener {@RabbitListener(queues = "simple.queue")public void getWorkMessage1(String msg) throws InterruptedException {System.out.println("这是消费者1:"+msg);Thread.sleep(20);//休息20毫秒}@RabbitListener(queues = "simple.queue")public void getWorkMessage2(String msg) throws InterruptedException {System.out.println("这是消费者2:"+msg);Thread.sleep(50);//休息50毫秒}
}

 启动后发现这两个消费者类是平分了这些消息

是因为消息队列会把消息分配平均交给负责监听此消息队列的类，这样做的弊端就是，有的消费者类很快就能执行完，而有可能会很满，导致效率底下，所以我们可以进行修改

在consumer模块中的application.yml文件中添加prefetch

spring:rabbitmq:host: 192.168.230.100   #主机名port: 5672        #用于发送信息和接收信息的端口号virtual-host: /    #虚拟主机username: hhh    #用户名password: 1234 #密码listener:simple:prefetch: 1
prefetch:
预取:每次将队列中的消息发送给消费者一个消息，等消费者处理完后再继续给一个消息
这样一来，处理消息快的消费者就会处理更多的消息
不修改之前，是把消息队列里的消息进行平分

可以发现处理快的消费者就可以处理更多的消息

使用SpringAMQP处理发布订阅之广播

在广播模式下，消息发送流程是这样的：

  • 1） 可以有多个队列
  • 2） 每个队列都要绑定到Exchange（交换机）
  • 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
  • 4） 交换机把消息发送给绑定过的所有队列
  • 5） 订阅队列的消费者都能拿到消息

因此我们要

  • 创建一个交换机 itcast.fanout，类型是Fanout
  • 创建两个队列fanout.queue1和fanout.queue2，绑定到交换机itcast.fanout

publisher模块中发送消息的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class FanoutMessage {@Autowiredprivate RabbitTemplate rabbitTemplate;@Testpublic void test(){//定义交换机名字String exchangeName="hhh.fanout";//定义消息String msg="你好呀，fanout";//发送消息
//第二个参数是RoutingKey,因为这里使用的广播类型（让于其绑定的消息队列都收到消息），所以设置为空rabbitTemplate.convertAndSend(exchangeName,"",msg);}
}

consumer模块中接收消息的类

@Component
public class FanoutListener {//这里创建了一个消息队列fanout.queue1，和一个fanout类型的交换机（如果本来存在就不会重新创建），并且绑定//绑定的同时也指定了这个类监听消息队列fanout.queue1@RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue1"),exchange = @Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)))public void getFanoutMessage1(String msg){System.out.println("这是消费者1:"+msg);}@RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue2"),exchange =@Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)))public void getFanoutMessage2(String msg){System.out.println("这是消费者2:"+msg);}}

结果：两个消费者（都与交换机进行绑定）都可以接收到消息

我们也可以使用配置类来创建交换机和队列，并绑定

@Configuration
public class FanoutConfig {//创建fanoutExchange交换机，并交给IoC容器，bean id 为getFanoutExchange@Beanpublic FanoutExchange getFanoutExchange(){return new FanoutExchange("hhh.fanout");}//创建消息队列1，并交给IoC容器，bean id 为getQueue1@Beanpublic Queue getQueue1(){return new Queue("fanout.queue1");}//创建消息队列2，并交给IoC容器，bean id 为getQueue2@Beanpublic Queue getQueue2(){return new Queue("fanout.queue2");}//TODO:将消息队列绑定到交换机上//TODO:注意：由于SpringBoot会帮我们创建交换器类型，和Queue类型的bean,而我们又自己创建了相同类型的bean//我们这里要指定bean的名字，不然Spring自动装配就会报错，不知道要装配哪个bean//TODO:因此我们要让Spring根据bean的id来进行注入@Beanpublic Binding bindingQueue1ToExchange(FanoutExchange getFanoutExchange,Queue getQueue1){return BindingBuilder.bind(getQueue1).to(getFanoutExchange);}@Beanpublic Binding bindingQueue2ToExchange(FanoutExchange getFanoutExchange,Queue getQueue2){return BindingBuilder.bind(getQueue2).to(getFanoutExchange);}
}
@Component
public class FanoutListener {//这里创建了一个消息队列fanout.queue1，和一个fanout类型的交换机（如果本来存在就不会重新创建），并且绑定//绑定的同时也指定了这个类监听消息队列fanout.queue1/* @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue1"),exchange = @Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)))*/@RabbitListener(queues = "fanout.queue1")public void getFanoutMessage1(String msg){System.out.println("这是消费者1:"+msg);}/*@RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue2"),exchange =@Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)))*/@RabbitListener(queues = "fanout.queue2")public void getFanoutMessage2(String msg){System.out.println("这是消费者2:"+msg);}}

使用SpringAMQP处理发布订阅之路由

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

 consumer模块中接收消息的类

@Configuration
public class DirectMessageListener {@RabbitListener(bindings = @QueueBinding(value = @Queue("direct.queue1"),exchange = @Exchange(name="hhh.direct",type= ExchangeTypes.DIRECT),key = {"yellow","red"} //指定这个消息队列绑定的RouterKey))public void getDirectMessage1(String msg){System.out.println("这是消费者1:"+msg);}@RabbitListener(bindings = @QueueBinding(value = @Queue("direct.queue"),exchange = @Exchange(name="hhh.direct",type=ExchangeTypes.DIRECT),key={"yellow","blue"} //指定这个消息队列绑定的RouterKey))public void getDirectMessage2(String msg){System.out.println("这是消费者2:"+msg);}
}

publisher模块中发送消息的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class DirectMessage {@Autowiredprivate RabbitTemplate rabbitTemplate;@Testpublic void test(){//定义交换机名字String exchangeName="hhh.direct";//定义消息String msg="你好，direct";//发送消息，指定发送给RouterKey为yellow的消息队列rabbitTemplate.convertAndSend(exchangeName,"yellow",msg);}
}

结果：两个消费者都收到了消息队列，因为他们都有yellow这个RouterKey 

使用SpringAMQP处理发布订阅之主题

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.spu.insert 或者 item.spu

item.*：只能匹配item.spu

  consumer模块中接收消息的类

@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "topic.queue1"),exchange = @Exchange(name = "hhh.topic", type = ExchangeTypes.TOPIC),key = "china.#" //key = "china.#" 表示路由key只要以china开始都会接收))public void listenTopicQueue1(String msg) {System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");}@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "topic.queue2"),exchange = @Exchange(name = "hhh.topic", type = ExchangeTypes.TOPIC),key = "#.news" //表示路由key只要以news结尾都会接收))public void listenTopicQueue2(String msg) {System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");}

publisher模块中发送消息的类

 @Testpublic void testSendTopicExchange() {// 交换机名称String exchangeName = "itcast.topic";// 消息String message = "你好，topic";// 发送消息rabbitTemplate.convertAndSend(exchangeName, "china.news", message);}

配置JSON转换器

默认情况下Spring采用的序列化方式是JDK序列化，JDK序列化存在下列问题：

  • 数据体积过大
  • 有安全漏洞
  • 可读性差

我们希望消息体的体积更小、可读性更高，因此可以使用JSON方式来做序列化和反序列化。

在主项目的pom.xml文件中导入依赖

<dependency><groupId>com.fasterxml.jackson.dataformat</groupId><artifactId>jackson-dataformat-xml</artifactId><version>2.9.10</version>
</dependency>

 在两个子模块中书写配置类，将MessageConverter交给IoC容器

/*消息转换器*/@Configuration
public class MessageConverterConfig {@Bean//将json转换器对象放到IoC容器public MessageConverter jsonMessageConverter(){return new Jackson2JsonMessageConverter();}
}


http://www.mrgr.cn/news/6038.html

相关文章：

  • 在idea中的git选择某一次记录拉出一个新分支
  • vue js 前端同时下载多个文件，前端多文件下载
  • oracle和mysql查询某字段在哪个表中
  • 关于路由和负载均衡
  • GitLab Merge Request流水线
  • 基于Matlab GUI的信号发生器界面程序示例
  • 【设计模式】单例模式
  • JVM的原理和性能调优
  • MySQL索引详解：原理、数据结构与分析和优化
  • springboot admin监控
  • 设计模式六大原则中的里氏替换原则
  • 基于spring boot的酒店管理系统
  • es插件 安装Elasticvue插件
  • 3-Electron打开新窗口，并跳转到指定的路由
  • 虚幻5|AI行为树，跟随task（非行为树AI）
  • 【Docker】docker的数据持久化
  • 在Linux系统下配置IP地址的方法
  • VS Code 远程连接SSH服务
  • openEuler安装openGauss5.0单机数据库
  • 海山数据库(He3DB)源码详解：He3DB-XLogWrite函数