RabbitMQ五种模式

最新推荐文章于 2023-05-19 22:35:28 发布
最新推荐文章于 2023-05-19 22:35:28 发布
阅读量1.6k 收藏 3
点赞数 4
文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43827740/article/details/121928178
版权

RabbitMQ五种模式

1. 简单模式
当生产者发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的一个队列queue只被一个消费者监听消费.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YUu9mlOd-1639466571608)(https://z3.ax1x.com/2021/04/12/cBqJOJ.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BQWQMI6U-1639466571609)(https://z3.ax1x.com/2021/04/12/cBqjhV.png)]

    //定义对列名称
    private final String DEMO8_QUEUE = "demo8_queue";
    //定义对列名称
    private final String DEMO9_QUEUE = "demo9_queue";

    @Bean
    public Queue queue8() {
        return new Queue(DEMO8_QUEUE, true);
    }

    @Bean
    public Queue queue9() {
        return new Queue(DEMO9_QUEUE, true);
    }

    /**
     * @Author wzj
     * @Param
     * @param: requestJSON
     * @Description 简单模式/争抢模式
     * @Date 10:55 2021/4/12
     **/
    @RequestMapping(value = "/demo1", method = RequestMethod.POST)
    public void demo1(String requestJSON) {
        Message message = null;
        try {
            message = MessageBuilder.withBody(requestJSON.getBytes("UTF-8")).build();
            //持久化消息
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            rabbitTemplate.convertAndSend("demo8_queue", message);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }

生产者：生成消息,发送到交换机
交换机：根据消息属性,将消息发送给队列
消费者：监听这个队列,发现消息后,获取消息执行消费逻辑

应用场景：发短信、发邮件。

2. 争抢模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MJrB4JeS-1639466571610)(https://z3.ax1x.com/2021/04/12/cBL3Nt.png)]

强调的也是后端队列与消费者绑定的结构

cBLY38.png

    //定义对列名称
    private final String DEMO8_QUEUE = "demo8_queue";
    //定义对列名称
    private final String DEMO9_QUEUE = "demo9_queue";

    @Bean
    public Queue queue8() {
        return new Queue(DEMO8_QUEUE, true);
    }

    @Bean
    public Queue queue9() {
        return new Queue(DEMO9_QUEUE, true);
    }

    /**
     * @Author wzj
     * @Param
     * @param: requestJSON
     * @Description 简单模式/争抢模式
     * @Date 10:55 2021/4/12
     **/
    @RequestMapping(value = "/demo1", method = RequestMethod.POST)
    public void demo1(String requestJSON) {
        Message message = null;
        try {
            message = MessageBuilder.withBody(requestJSON.getBytes("UTF-8")).build();
            //持久化消息
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            rabbitTemplate.convertAndSend("demo8_queue", message);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }

生产者：发送消息到交换机
交换机：根据消息属性将消息发送给队列
消费者：多个消费者,同时绑定监听一个队列,之间形成了争抢消息的效果

应用场景：抢红包,资源分配系统

3. 路由模式
前面简单模式和争抢模式，着重强调的是消费端。而路由模式，看到“路由”二字，大家也许会猜到，这个和交换机有关了。
路由模式指交换机通过消息的key将消息发送到指定的队列。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bhZmFT8A-1639466571611)(https://z3.ax1x.com/2021/04/12/cBOAbj.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WMOPtgNQ-1639466571611)(https://z3.ax1x.com/2021/04/12/cBO1r4.png)]

    //定义交换机名称
    private final String DIRECT_EXCHANGE_NAME = "directExchange";
    //定义交换机名称

    //配置交换器
    @Bean
    DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE_NAME, true, false);
    }

    //定义对列名称
    private final String DEMO6_QUEUE = "demo6_queue";
    //定义对列名称
    private final String DEMO7_QUEUE = "demo7_queue";

    @Bean
    public Queue queue6() {
        return new Queue(DEMO6_QUEUE, true);
    }

    @Bean
    public Queue queue7() {
        return new Queue(DEMO7_QUEUE, true);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingDirectExchangeQueue6(Queue queue6, DirectExchange directExchange) {
        return BindingBuilder.bind(queue6).to(directExchange).with(DIRECT_KEY);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingDirectExchangeQueue7(Queue queue7, DirectExchange directExchange) {
        return BindingBuilder.bind(queue7).to(directExchange).with(DIRECT_KEY);
    }

    /**
     * @Author wzj
     * @Param
     * @param: requestJSON
     * @Description 路由键模式
     * @Date 10:55 2021/4/12
     **/
    @RequestMapping(value = "/demo2", method = RequestMethod.POST)
    public void demo5(String requestJSON) {
        Message message = null;
        try {
            message = MessageBuilder.withBody(requestJSON.getBytes("UTF-8")).build();
            //持久化消息
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            rabbitTemplate.convertAndSend(DIRECT_EXCHANGE_NAME, DIRECT_KEY, message);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

应用场景：
1.将手机号作为路由key ，将其发送到指定队列，由持有该手机号的客户端监听队列中的手机短信。
2.将系统的异常消息发送到指定队列，由负责日志记录的应用记录日志。

4. 发布订阅模式
这里强调的也是交换机，将受到的消息发送给多个队列，而不单单指一个。

cBOBse.png

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUpaioNG-1639466571612)(https://z3.ax1x.com/2021/04/12/cBOydA.png)]

    //定义交换机名称
    private final String FANOUT_EXCHANGE_NAME = "fanoutExchange";

    //配置交换器
    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE_NAME, true, false);
    }

    //定义对列名称
    private final String DEMO1_QUEUE = "demo1_queue";
    //定义对列名称
    private final String DEMO2_QUEUE = "demo2_queue";
    //定义对列名称
    private final String DEMO3_QUEUE = "demo3_queue";
    //定义对列名称
    private final String DEMO4_QUEUE = "demo4_queue";
    //定义对列名称
    private final String DEMO5_QUEUE = "demo5_queue";

    //配置对列
    @Bean
    public Queue queue1() {
        return new Queue(DEMO1_QUEUE, true);
    }

    @Bean
    public Queue queue2() {
        return new Queue(DEMO2_QUEUE, true);
    }

    @Bean
    public Queue queue3() {
        return new Queue(DEMO3_QUEUE, true);
    }

    @Bean
    public Queue queue4() {
        return new Queue(DEMO4_QUEUE, true);
    }

    @Bean
    public Queue queue5() {
        return new Queue(DEMO5_QUEUE, true);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingFanoutExchangeQueue1(Queue queue1, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue1).to(fanoutExchange);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingFanoutExchangeQueue2(Queue queue2, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue2).to(fanoutExchange);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingFanoutExchangeQueue3(Queue queue3, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue3).to(fanoutExchange);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingFanoutExchangeQueue4(Queue queue4, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue4).to(fanoutExchange);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingFanoutExchangeQueue5(Queue queue5, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue5).to(fanoutExchange);
    }

    /**
     * @Author wzj
     * @Param
     * @param: requestJSON
     * @Description 订阅模式
     * @Date 10:55 2021/4/12
     **/
    @RequestMapping(value = "/demo3", method = RequestMethod.POST)
    public void demo3(String requestJSON) {
        Message message = null;
        try {
            message = MessageBuilder.withBody(requestJSON.getBytes("UTF-8")).build();
            //持久化消息
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            rabbitTemplate.convertAndSend(FANOUT_EXCHANGE_NAME, null, message);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

生产端：发送消息到交换机
交换机：由于是发布订阅模式,会将这个消息发送同步到后端所有与其绑定的队列
消息端：简单模式 1个队列绑定一个消费者 争抢模式 1个队列绑定多个消费者

应用场景：邮件的群发,广告的群发

5.主题模式
和路由模式很类似，区别在于主题模式的路由规则是通配匹配。指交换机通过消息的key将消息发送到某类队列中（类似于快递分拣）。

cBOvyF.png

cBXUTs.png

    //定义交换机名称
    private final String TOPIC_EXCHANGE_NAME = "topicExchange";

    //配置交换器
    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE_NAME, true, false);
    }

    //定义对列名称
    private final String DEMO9_QUEUE = "demo9_queue";
    //定义对列名称
    private final String DEMO10_QUEUE = "demo10_queue";
    //定义对列名称
    private final String DEMO11_QUEUE = "demo11_queue";

    @Bean
    public Queue queue9() {
        return new Queue(DEMO9_QUEUE, true);
    }

    @Bean
    public Queue queue10() {
        return new Queue(DEMO10_QUEUE, true);
    }

    @Bean
    public Queue queue11() {
        return new Queue(DEMO11_QUEUE, true);
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingTopicExchangeQueue9(Queue queue9, TopicExchange topicExchange) {
        return BindingBuilder.bind(queue9).to(topicExchange).with("aaa.aaa.*");
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingTopicExchangeQueue10(Queue queue10, TopicExchange topicExchange) {
        return BindingBuilder.bind(queue10).to(topicExchange).with("aaa.#");
    }

    // 绑定队列到交换器
    @Bean
    Binding bindingTopicExchangeQueue11(Queue queue11, TopicExchange topicExchange) {
        return BindingBuilder.bind(queue11).to(topicExchange).with("aaa");
    }

    /**
     * @Author wzj
     * @Param
     * @param: requestJSON
     * @Description 主题模式
     * @Date 10:55 2021/4/12
     **/
    @RequestMapping(value = "/demo4", method = RequestMethod.POST)
    public void demo4(String requestJSON) {
        Message message = null;
        try {
            message = MessageBuilder.withBody(requestJSON.getBytes("UTF-8")).build();
            //持久化消息
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            rabbitTemplate.convertAndSend(TOPIC_EXCHANGE_NAME, TOPIC_KEY, message);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

交换机绑定队列,不在使用具体的路由key,可以使用符号代替路由key值的规则

应用场景：物流分拣。

总结

五种工作模式中，前两种（简单模式、争抢模式）和消费者相关，后三种（路由模式、发布订阅模式、主题模式）和交换机相关。需要根据不同的场景使用不用的工作模式。
weixin_43827740
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot整合RabbitMQ（各个模式如何发送一个消息）
炫风丶小子
11-20 842
RabbitMQ作为一个消息中间件，在使用过程中我们需要保证生产端是否将消息发送到了MQ上，如何保证消费端
RabbitMQ的消息延迟两种实现--死信和插件
qq_32923295的博客
04-13 440
在实际场景中，我们经常会有这种情况，当用户进入支付页面，但是不支付退出，通常会出现30min支付时间，否则订单取消的场景，那么这种就可以用到消息延迟 RabbitMQ的消息延迟有两种实现方案：死信和RabbitMQ插件 死信队列，在队列中并没有明确的指定哪种是死信队列，所以需要我们自己通过配置去实现 RabbitMQ插件rabbitmq_delayed_message_exchange：RabbitMQ的版本必须是3.5.8以上 死信： 原理： 当提交订单后，未支付，设置订单30分钟超时。 当
RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）
weixin_45181611的博客
05-10 3003
消息模式详解
【RabbitMQ笔记06】消息队列RabbitMQ七种模式之Topics主题模式
•一个写代码的• •知识星球•https://t.zsxq.com/15rGFbGEk
02-26 1842
前一篇文章介绍了Routing路由模式，它是根据消息的唯一标识routing key路由键，将其分发到不同的Queue队列里面，这篇文章介绍的Topics主题模式，也是需要依赖与routing key路由键来进行分发消息，但是不同的是，Topics主题可以采用通配符的方式来指定routing key。Topics主题模式下，它要求【routing key路由键】必须采用【多个单词】来表示，每一个单词采用点好【.】分割，例如：【xxx.yyy.zzz】，这就是三个单词，分别是：xxx、yyy、zzz，路由
RabbitMQ 延迟队列，消息延迟推送*
cnn0314的博客
11-02 629
RabbitMQ 延迟队列，消息延迟推送 应用场景# 目前常见的应用软件都有消息的延迟推送的影子，应用也极为广泛，例如： 淘宝七天自动确认收货。在我们签收商品后，物流系统会在七天后延时发送一个消息给支付系统，通知支付系统将款打给商家，这个过程持续七天，就是使用了消息中间件的延迟推送功能。 12306 购票支付确认页面。我们在选好票点击确定跳转的页面中往往都会有倒计时，代表着 30 分钟内订单不确认的话将会自动取消订单。其实在下订单那一刻开始购票业务系统就会发送一个延时消息给订单系统，延
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
基于RabbitMQ几种Exchange 模式详解
08-28
下面小编就为大家带来一篇基于RabbitMQ几种Exchange 模式详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
springboot+RabbitMQ三种模式demo
07-03
springboot+RabbitMQ的direct，topic，fanout三种模式demo
基于Redis和RabbitMQ实现一个异步并发限制工具
future_xiaowu的博客
04-14 3723
背景： 现有一个分布式的应用要与第三方报表服务对接，对方提供restful接口，调用这些接口以获取报表信息或者下载报表文件。首先，如果不需要下载文件，直接在MVC架构的service调用这些rest接口就好。可涉及到文件下载，网络IO耗时可能比较长而报表服务能承受的并发量有限，请求过多可能压垮报表服务的接口 问题分析与解决思路： 限制报表请求的并发量防止报表服务端报错或者崩溃，将请求参数放入分布式队列，利用redis计数currency，超出并发数量就限流，给出排队提示并将请求打回队列头部，未超出则从
rabbitmq 延时队列踩坑记
xyw10000
10-26 2640
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 开发项目中，我们可能存在这个场景。比如订单创建30分钟未支付自动超时取消，也可能存在调用第三方接口不是实时响应结果，需要间隔一些时间获取处理状态。往往解决这些场景的技术手段无外乎于两种，1 定时任务调度 2 延时队列。鉴于定时任务实时性不好控制，往往使用延时队列来实现处理。 JDK ...
springBoot+RabbitMq 实现延时发送消息-插件方式
危险、的博客
10-27 1319
一.linux环境安装rabbitMQ延时插件 *由于项目使用的rabbitmq3.8.3版本，所以下载3.8版本的延时插件，避免出现版本不一致导致的坑。* 1.下载地址 https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/tag/v3.8.0 2.选择ez文件 3.把插件放入rabbitMQ的plugins目录下 4.执行安装命令 rabbitmq-plugins enable rabbitmq_delaye
消息队列之RabbitMQ的五种工作模式及代码样例(一)
qq_43805456的博客
02-08 2417
消息队列之RabbitMQ的五种工作模式
RabbitMQ:消息丢失处理
xzr1117的博客
04-06 629
RabbitMQ存在数据丢失的三种情况： ①生产者发送消息失败： 写消息的过程中，消费还没到MQ，在网络传输过程中丢了，或者是消费到了RabbitMQ，但是MQ那出错了，没保存下来。 ②中间件挂了：RabbitMQ接收到消费之后，先暂存在自己的内存里，结果消费者还没来得及消费，RabbitMQ自己挂掉了，导致暂存在内存中的数据丢了。 ③消费者弄丢数据：消费了拿到了这个数据，但还没来得及处理，自己就挂掉了。但是RabbitMQ以为这个消费者消费完了。 ...
RabbitMQ详解（三）消息可靠性处理
傅红雪的专栏
02-13 1811
1. 生产者消息可靠投递 在使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ为我们提供了两个选项用来控制消息的投递可靠性模式。 RabbitMQ整个消息投递的路径为： producer->rabbitmq broker cluster->exchange->queue->consumer message从pr...
RabbitMQ之消息的可靠性
qq_36526036的博客
03-25 4045
1、场景导入 众所周知，Rabbit MQ是一款用Erlang语言编写的，基于AMQP协议的消息中间件。那么消息传输的可靠性就至关重要了，说到这里，我们先看一下Rabbit MQ的整个工作流程： 从上面一张图中，可以很容易知道，消息是由生产者发出，流经Broker(信道->交换机->队列），再到消费者消费完毕，这就是一个消息的完整流转过程。那么在这个过程中一定会出现消息传输不可靠问题...
【RabbitMQ高级消息可靠性、高可用、延时、消息堆积问题】
weixin_48009757的博客
05-19 2156
修改publisher服务的单元测试类：​​​@Slf4j@Autowired​@Test​​​//设置生产者消息确认机制publish-confirm的回调方法@Overrideif(ack){log.info("消息发送到交换机成功，消息ID：{}", correlationData.getId());} else {
springBoot+RabbitMq 实现延时发送消息-死信方式
危险、的博客
10-26 1435
由于考虑到RabbitMq支持高并发、持久化、高可用等优点，决定从activeMq转战RabbitMq，因为前期调研不充分，结果发现RabbitMq自身竟然不支持延时消息，只能通过死信或者集成插件来实现，这里先介绍死信的方式。 这里就不赘述Rabbit的详细用法了，就直接上代码介绍实现步骤啦。 一.定义消息队列的敞亮 public static final String ACT_QUEUE= "act_queue";//活动立即消费队列 public static final String ACT_DELA
rabbitmq的五种工作模式
最新发布
06-09
RabbitMQ支持以下五种工作模式： 1. 简单模式（Simple Mode）：一个生产者向一个队列发送消息，一个消费者从队列中接收消息。 2. 工作模式（Work Mode）：一个生产者向一个队列发送消息，多个消费者从队列中接收...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值