SpringBoot整合RabbitMq（六种工作模型）

已于 2022-11-21 17:25:09 修改
阅读量649 收藏 3
点赞数 2
分类专栏： MQ 文章标签： java-rabbitmq rabbitmq spring boot java 中间件
于 2022-08-04 15:08:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29917503/article/details/126159663
版权

文章目录

RabbitMq六种消息模型（SpringBoot版）

关于MQ的基本概念：学习MQ之前，你要先懂这些~_略懂Java的博客-CSDN博客

关于MQRabbitMq的安装：Linux安装RabbitMQ详细教程（下载安装及docker安装）_略懂Java的博客-CSDN博客

RabbitMQ简介

RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com

RabbitMQ的工作原理

下图是RabbitMQ的基本结构：

在这里插入图片描述

组成部分说明：

  • Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue

  • Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑。

  • Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的

  • Producer：消息生产者，即生产方客户端，生产方客户端将消息发送

  • Consumer：消息消费者，即消费方客户端，接收MQ转发的消息。

生产者发送消息流程：

1、生产者和Broker建立TCP连接。

2、生产者和Broker建立通道。

3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。

4、Exchange将消息转发到指定的Queue（队列）

消费者接收消息流程：

1、消费者和Broker建立TCP连接

2、消费者和Broker建立通道

3、消费者监听指定的Queue（队列）

4、当有消息到达Queue时Broker默认将消息推送给消费者。

5、消费者接收到消息。

6、ack回复

Rabbit六种消息模型

RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。

在这里插入图片描述

基本消息模型（点对点）

在这里插入图片描述

在上图的模型中，有以下概念：

  • P：生产者，也就是要发送消息的程序

  • C：消费者：消息的接受者，会一直等待消息到来。

  • queue：消息队列，图中红色部分。可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

新建一个maven工程，添加spring-boot-starter-web、spring-boot-starter-amqp依赖，另外添加一个spring-boot-starter-test依赖方便测试。

 <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <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>
  </dependencies>

在application.yml中添加RabbitMQ的配置：

# 服务端口
server:
  port: 8080
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: rabbitmq
    password: rabbitmq
    virtual-host: /
    host:             #服务器公网地址
    port: 5672

定义队列名称

public interface RabbitMqConstants {
   String SMS_QUEUE  = "sms_queue";
   String EMAIL_QUEUE  = "email_queue";
}

定义RabbitConfig配置类 初始化2个队列

@Configuration
public class RabbitMqConfig {

    /**
     * new Queue(QUEUE_EMAIL,true,false,false)
     *  durable="true" 持久化 rabbitmq重启的时候不需要创建新的队列
     *  auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
     * exclusive  表示该消息队列是否只在当前connection生效,默认是false
     * @return
     */
    @Bean
    public Queue simpleSmsQueueInit() {
        return new Queue(RabbitMqConstants.SMS_QUEUE, true);
    }

    /**
     * 初始化邮箱队列
     * @return
     */
    @Bean
    public Queue simpleEmailQueueInit() {
        return new Queue(RabbitMqConstants.EMAIL_QUEUE, true);
    }
}

定义生产者

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class Producer  {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Test
    public void sent(){
     rabbitTemplate.convertAndSend(RabbitMqConstants.SMS_QUEUE,"Hello world");
    }
}

我们使用@Test方法运行sent方法向SMS_QUEUE队列发送消息

在RabbitMq控制台我们可以看到初始化的2个队列并且SMS_QUEUE队列有一条待消费消息
在这里插入图片描述

点击队列名称在GetMessage下可以看到具体的消息内容

在这里插入图片描述

然后我们编写消费者类并监听SMS_QUEUE队列

我们添加@Commonent注解目的是让该类添加到Spring容器中，在项目启动的时候可以监听队列中的消息。

@Component
public class Consumer {
    @RabbitListener(queues = RabbitMqConstants.SMS_QUEUE)
    public void getMessage(String message){
        System.out.println(message);
    }
}

我们启动springBoot的启动类启动项目发现消息自动消费了

在这里插入图片描述

在这里插入图片描述

工作模式（work）

在这里插入图片描述

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息，但是一个消息只能被一个消费者获取。

这个消息模型在Web应用程序中特别有用，可以处理短的HTTP请求窗口中无法处理复杂的任务。

生产者

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class WorkProducer {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sent(){
        for (int i = 1; i <=6 ; i++) {
            rabbitTemplate.convertAndSend(RabbitMqConstants.EMAIL_QUEUE,"Hello world"+i);
        }
    }
}

消费者

@Component
public class WorkConsumer {

    @RabbitListener(queues = RabbitMqConstants.EMAIL_QUEUE)
    public void getMessage(String message){
        System.out.println("消费者1接收到信息:"+message);
    }

    @RabbitListener(queues = RabbitMqConstants.EMAIL_QUEUE)
    public void getMessageAgain(String message){
        System.out.println("消费者2接收到信息:"+message);
    }
}

在这里插入图片描述

订阅模型分类

  • 一个生产者多个消费者

  • 每个消费者都有一个自己的队列

  • 生产者没有将消息直接发送给队列，而是发送给exchange(交换机、转发器)

  • 每个队列都需要绑定到交换机上

  • 生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者消费

Exchange类型

  • Fanout：广播，将消息交给所有绑定到交换机的队列

  • Direct：定向，把消息交给符合指定routing key 的队列

  • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

广播模型（Fanout）

在这里插入图片描述
首先我们创建2个队列，分别是消息的队列和邮箱队列 创建一个fanout交换机，将这两个队列绑定到交换机上

  public interface RabbitMqConstants {
    String SMS_QUEUE  = "sms_queue";

   String EMAIL_QUEUE  = "email_queue";

   String FANOUT_EXCHANGE = "fanout_exchange";
  }

@Configuration
public class RabbitMqConfig {

    /**
     * new Queue(QUEUE_EMAIL,true,false,false)
     *  durable="true" 持久化 rabbitmq重启的时候不需要创建新的队列
     *  auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
     * exclusive  表示该消息队列是否只在当前connection生效,默认是false
     * @return
     */
    @Bean
    public Queue simpleSmsQueueInit() {
        return new Queue(RabbitMqConstants.SMS_QUEUE, true);
    }

    /**
     * 初始化邮箱队列
     * @return
     */
    @Bean
    public Queue simpleEmailQueueInit() {
        return new Queue(RabbitMqConstants.EMAIL_QUEUE, true);
    }

    /**
     * 初始化fanout交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchangeInit() {
        return new FanoutExchange(RabbitMqConstants.FANOUT_EXCHANGE, true,false);
    }

    /**
     * 短信队列绑定到交换机
     * @param simpleSmsQueueInit
     * @param fanoutExchange
     * @return
     */
    @Bean
    public Binding bindingSmsQueue(Queue simpleSmsQueueInit, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(simpleSmsQueueInit).to(fanoutExchange);
    }

    /**
     * 邮箱队列绑定到交换机
     * @param simpleEmailQueueInit
     * @param fanoutExchange
     * @return
     */
    @Bean
    public Binding bindingEmailQueue(Queue simpleEmailQueueInit, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(simpleEmailQueueInit).to(fanoutExchange);
    }

}

生产者

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class FanoutProducer {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sent(){
        rabbitTemplate.convertAndSend(RabbitMqConstants.FANOUT_EXCHANGE,"","我是交换机发出的消息");
    }
}

消费者

@Component
public class FanoutConsumer {

    @RabbitListener(queues = RabbitMqConstants.SMS_QUEUE)
    public void getMessage(String message){
        System.out.println("短信消费者接收到信息:"+message);
    }

    @RabbitListener(queues = RabbitMqConstants.EMAIL_QUEUE)
    public void getMessageAgain(String message){
        System.out.println("邮箱消费者接收到信息:"+message);
    }
}

在这里插入图片描述

路由模式(direct)

在这里插入图片描述

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。

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

初始化路由交换机

   String SMS_QUEUE  = "sms_queue";

   String EMAIL_QUEUE  = "email_queue";

   String DIRECT_EXCHANGE = "direct_exchange";

@Configuration
public class RabbitMqConfig {
    /**
     * 初始化direct交换机
     * @return
     */
    @Bean
    public DirectExchange directExchangeInit() {
        return new DirectExchange(RabbitMqConstants.DIRECT_EXCHANGE, true,false);
    }

    /**
     * 初始化短信队列
     * @return
     */
    @Bean
    public Queue directSmsQueueInit() {
        return new Queue(RabbitMqConstants.SMS_QUEUE, true);
    }

    /**
     * 初始化邮箱队列
     * @return
     */
    @Bean
    public Queue directEmailQueueInit() {
        return new Queue(RabbitMqConstants.EMAIL_QUEUE, true);
    }

    /**
     * 短信队列绑定到交换机
     * @param directSmsQueueInit
     * @param directExchange
     * @return
     */
    @Bean
    public Binding directBindingSmsQueue(Queue directSmsQueueInit, DirectExchange directExchange) {
        return BindingBuilder.bind(directSmsQueueInit).to(directExchange).with("sms");
    }

    /**
     * 邮箱队列绑定到交换机
     * @param directEmailQueueInit
     * @param directExchange
     * @return
     */
    @Bean
    public Binding directBindingEmailQueue(Queue directEmailQueueInit, DirectExchange directExchange) {
        return BindingBuilder.bind(directEmailQueueInit).to(directExchange).with("email");
    }
}

生产者

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class DirectProducer {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sent(){
        rabbitTemplate.convertAndSend(RabbitMqConstants.DIRECT_EXCHANGE,"email","我是交换机发出的消息");
    }
}

消费者

@Component
public class DirectConsumer {

    @RabbitListener(queues = RabbitMqConstants.SMS_QUEUE)
    public void getMessage(String message){
        System.out.println("短信消费者接收到信息:"+message);
    }

    @RabbitListener(queues = RabbitMqConstants.EMAIL_QUEUE)
    public void getMessageAgain(String message){
        System.out.println("邮箱消费者接收到信息:"+message);
    }
}

在这里插入图片描述

主题模式（Topic）

在这里插入图片描述

每个消费者监听自己的队列，并且设置带统配符的routingkey,生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。

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

通配符规则：

#：匹配一个或多个词

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

举例：

sms.#：能够匹配sms.irs.corporate 或者 sms.irs

email.*：只能匹配email.irs

public interface RabbitMqConstants {
   String TOPIC_EXCHANGE = "topic_exchange";

   String SMS_TOPIC_QUEUE = "sms_topic_queue";

   String EMAIL_TOPIC_QUEUE = "email_topic_queue";
}

@Configuration
public class RabbitMqConfig {
    /**
     * 初始化topic交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchangeInit() {
        return new TopicExchange(RabbitMqConstants.TOPIC_EXCHANGE, true,false);
    }

    /**
     * 初始化短信队列
     * @return
     */
    @Bean
    public Queue topicSmsQueueInit() {
        return new Queue(RabbitMqConstants.SMS_TOPIC_QUEUE, true);
    }

    /**
     * 初始化邮箱队列
     * @return
     */
    @Bean
    public Queue topicEmailQueueInit() {
        return new Queue(RabbitMqConstants.EMAIL_TOPIC_QUEUE, true);
    }

    /**
     * 短信队列绑定到交换机
     * @param topicSmsQueueInit
     * @param topicExchangeInit
     * @return
     */
    @Bean
    public Binding topicBindingSmsQueue(Queue topicSmsQueueInit, TopicExchange topicExchangeInit) {
        return BindingBuilder.bind(topicSmsQueueInit).to(topicExchangeInit).with("sms.#");
    }

    /**
     * 邮箱队列绑定到交换机
     * @param topicEmailQueueInit
     * @param topicExchangeInit
     * @return
     */
    @Bean
    public Binding topicBindingEmailQueue(Queue topicEmailQueueInit, TopicExchange topicExchangeInit) {
        return BindingBuilder.bind(topicEmailQueueInit).to(topicExchangeInit).with("email.*");
    }
}

生产者

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class TopicProducer {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sent(){
        rabbitTemplate.convertAndSend(RabbitMqConstants.TOPIC_EXCHANGE,"sms.x.x","我是主题模式发出的消息1");
        rabbitTemplate.convertAndSend(RabbitMqConstants.TOPIC_EXCHANGE,"email.x","我是主题模式发出的消息2");
    }
}

消费者

@Component
public class TopicConsumer {

    @RabbitListener(queues = RabbitMqConstants.SMS_TOPIC_QUEUE)
    public void getMessage(String message){
        System.out.println("主题模式短信消费者接收到信息:"+message);
    }

    @RabbitListener(queues = RabbitMqConstants.EMAIL_TOPIC_QUEUE)
    public void getMessageAgain(String message){
        System.out.println("主题模式邮箱消费者接收到信息:"+message);
    }
}

[外链图片转存中...(img-bFPMkn3K-1659596315509)]

欲无缘
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot+rabbitmq实现其六种工作模式
qq_46134095的博客
05-04 799
介绍 rabbitmq有六种工作模式。我们使用springboot整合实现rabbitmq的六种工作模式，并在其中谈及如何调用ack。 准备工作 导入springboot的rabbitmq的场景,还有一个web场景 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</arti
Spring Boot集成rabbitmq使用设计模式根据不同业务类型高级封装
weixin_42502300的博客
12-11 922
Spring Boot集成rabbitmq使用设计模式根据不同业务类型高级封装
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
SpringBoot整合RabbitMQ——Headers交换机
SK_Jaco的博客
07-17 2453
文章目录SpringBoot整合RabbitMQ——Headers交换机简介添加依赖application.yml配置消息生产者（发送端）SendConfig.java配置信息Controller层Service层消费者（接收端） SpringBoot整合RabbitMQ——Headers交换机 简介 头交换机（headers exchange）使用多个消息属性来代替路由键建立路由规则。通过判断消...
Springboot项目整合Rabbitmq详细教程
洛阳泰山的博客
10-13 2408
首先在springboot的pom文件里引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 然后application.yml： ps：里面的虚拟host配置项不是必须的，我自己在rabbitmq服务上创建了自己的虚拟host
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合RabbitMQ案例
04-07
springBoot整合RabbitMQ案例
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
springboot-rabbitMQ-websocketspringboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
Springboot整合RabbitMQ简单demo
01-22
Springboot整合RabbitMQ最简单demo
RabbitMq------初级+高级（一）
weixin_54406708的博客
08-02 2025
基于spring-boot-AMQP来对rabbitmq进行消息的异步发送，以及对应的队列。
封装一套RabbitMQ通用发送和接收类
weixin_38702618的博客
03-02 4529
一、发送消息类 /** * 消息发送封装类 * * 需要发送消息的模块注入这个类就可以实现消息发送,推荐使用直接发送Bean的方式发送mq消息 */ @Component @EnableAsync public class RabbitMqMessageSender { private static Logger logger = LoggerFactory.getLog...
springboot + rabbitmq headers模式
weixin_43866295的博客
01-31 879
springboot + rabbitmq headers模式 配置类： @Configuration public class RabbitMqConfig5 { @Bean public Queue queueN1() { return new Queue("queueN1"); } @Bean public Queue queueN2() { return new ...
SpringCloud（6）— RabbitMQ(消息队列)
shaopengjie的博客
12-13 1488
MQ（MessageQueue）,中文含义为消息队列，用来存放消息，也就是事件驱动模式中的 BrokerRabbitMQ：现阶段使用最多的MQ技术，优点在于消息的低延迟和可靠性ActiveMQ：开发语言基于Java,可以进行深度定制RocketMQ：开发语言基于Java,可以进行深度定制，阿里巴巴开发Kafka：单机吞吐量很高，但消息可靠性不高。RabbitMQ通过 VirtualHost 进行隔离，相互不可见。RabbitMQ中的相关概念channel：操作MQ的工具。
较完善的rabbitmq消息队列工具类
zhiqiang_zhao
05-13 1446
包含： 1 生产者补单队列 2 生产者重试机制 3 消费者重试机制 4 可靠性投递，最终事务一致原则 5 消费端限流 （服务端限流内存和磁盘配置此处不涉及） rabbitConfig全局配置 package org.jeecg.boot.starter.rabbitmq.config; import lombok.extern.slf4j.Slf4j; import org.springframework.amqp.core.Message; import org.springframe
Springboot整合RabbitMQ-发送消息、监听(含工具类)
panlupeng的博客
08-25 1640
1.MQ消息队列概念 消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。 消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 MQ 中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在 2.MQ的四个常用类型direct,topic,fanout,headers 1.direct：exchan
RabbitMq队列声明参数详细解析
ACMjiayou的博客
02-12 2018
小Tips： 大家可以通过RabbitMQ的web插件查看本文中的大部分信息。 队列的声明的5个参数分别是： 1.队列名称 2.队列是否持久化 3.队列是否具有排他性（只有同一连接共享此队列，且连接断开时队列删除）排他队列详细说明 4.队列是否自动删除 自动删除是队列经历过至少一次连接后，所有的消费者都断开了连接，此时队列会进行自动删除。 5.封装队列的一些参数 Message TTL: How long a message published to a queue can live befor
springBoot整合rabbitMQ，动态创建队列，动态监听。（三）
web15085181368的博客
04-10 7264
一， 动态监听和队列的使用场景主要是项目不确定队列的名称等信息，根据业务队列变化，或者在大量数据处理的创景中一个或者几个队列处理不过来，需要随着数据增加消费者队列也要动态增长 下面是简单使用： SimpleMessageListenerContainer类是rabbitMQ中专门负责监听队列，维护队列的添加，移除等； MessageListener是rabbitMQ中专门负责接收消息以后处理消息的接口，SimpleMessageListenerContainer在监听到消息以后会调用MessageListe
RabbitMQ：Queue的介绍和使用
编程学习者的博客
05-13 6945
1.声明 当前内容用于本人学习和使用当前的Queue,当前内容为RabbitMQ中对Queue的介绍 当前内容来源：RabbitMQ中的Queue 2.Queue的官方介绍 首先先分析以下前面的Queue的使用，其实这个东西就是一个队列，一个存储消息的队列，并且可以持久化，而且这个队列中的消息可以被消费，如果出现死信则是死信队列，死信队列也是可以被处理的 接下来就是官方介绍 Queues in the AMQP 0-9-1 model are very similar to queues in other
springboot 整合rabbitmq
最新发布
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值