Rabbit Mq 五种模式 + Spring Boot 实现

最新推荐文章于 2024-08-24 14:38:34 发布
最新推荐文章于 2024-08-24 14:38:34 发布
阅读量316 收藏 2
点赞数 1
分类专栏： RabbitMq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43010427/article/details/119828952
版权

请添加图片描述
简单模式：

  1. 一个生产者，一个队列，一个消费者

Config：

/**
 * @author Fly_Roushan
 * @date 2021/8/23
 */
@Configuration
public class RabbitConfig {

    /**
     * 简单模式不需要绑定交换机
     *
     * @return
     */
    @Bean
    public Queue simpleQueue() {
        return new Queue(RabbitConst.SIMPLE_QUEUE, true);
    }
}

Producer：

/**
 * @author Fly_Roushan
 * @date 2021/8/23
 */
@Component
public class Producer {

    private static final Logger LOGGER = LoggerFactory.getLogger(Producer.class);

    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * Simple Mode
     *
     */
    public void sendMessage() {
        String data = "Simple Test";
        LOGGER.info("[Producer] Send: {}", data);
        amqpTemplate.convertAndSend(RabbitConst.SIMPLE_QUEUE, data);
    }
}

Consumer：

/**
 * @author Fly_Roushan
 * @date 2021/8/23
 */
@Component
public class Consumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(Consumer.class);

    @RabbitListener(queues = RabbitConst.SIMPLE_QUEUE)
    @RabbitHandler
    public void simpleConsumer(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Consume: {}", data);
    }
}

结果：
在这里插入图片描述

请添加图片描述
工作模式：

  1. 一个生产者，一个队列，多个消费者
  2. 消费时采用轮询的方式

Config：

    /**
     * 工作模式不需要绑定交换机
     *
     * @return
     */
    @Bean
    public Queue workQueue() {
        return new Queue(RabbitConst.WORK_QUEUE, true);
    }

Producer：

    /**
     * Work Mode
     */
    public void workMessage() {
        String data = "Work Test";
        LOGGER.info("[Producer] Send: {}", data);
        amqpTemplate.convertAndSend(RabbitConst.WORK_QUEUE, data);
    }

Consumer：

    @RabbitListener(queues = RabbitConst.WORK_QUEUE)
    @RabbitHandler
    public void workConsumer1(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Consume 1: {}", data);
        ack(channel, message);
    }

    @RabbitListener(queues = RabbitConst.WORK_QUEUE)
    @RabbitHandler
    public void workConsumer2(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Consume 2: {}", data);
        ack(channel, message);
    }

结果：
在这里插入图片描述

请添加图片描述
订阅模式（fanout）：

  1. 一个生产者，一个交换机，多个队列，多个消费者
  2. 一个队列，可以使用多个消费者来进行轮询消费
  3. 所有的队列都会接受到生产者的消息

Config：

    /**
     * 用于绑定fanout交换机
     *
     * @return
     */
    @Bean
    public Queue fanoutQueue() {
        return new Queue(RabbitConst.FANOUT_QUEUE, true);
    }

    /**
     * 订阅模式需要声明特别的交换机
     *
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(RabbitConst.FANOUT_EXCHANGE);
    }

    /**
     * 根据实际需求绑定到fanout交换机
     *
     * @return
     */
    @Bean
    public Binding bandwidthFanout() {
        return BindingBuilder.bind(fanoutQueue()).to(fanoutExchange());
    }

Producer：

    /**
     * Fanout Mode
     * 这里不用指定队列，也就是RoutingKey，只需要指定对哪个交换机发送消息即可
     */
    public void fanoutMessage() {
        String data = "Fanout Test";
        LOGGER.info("[Producer] Send: {}", data);
        amqpTemplate.convertAndSend(RabbitConst.FANOUT_EXCHANGE, null, data);
    }

Consumer：

    /**
     * 简单说一下，这里使用的是随机队列。
     * 队列在有消费者声明的时候存在，没有就会自动消失。
     *
     * @param data
     * @param channel
     * @param message
     */
    @RabbitListener(bindings = @QueueBinding(value = @Queue(), exchange = @Exchange(value = RabbitConst.FANOUT_EXCHANGE, type = ExchangeTypes.FANOUT)))
    @RabbitHandler
    public void fanoutConsumer1(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Fanout Consume 1: {}", data);
        ack(channel, message);
    }

    @RabbitListener(bindings = @QueueBinding(value = @Queue(), exchange = @Exchange(value = RabbitConst.FANOUT_EXCHANGE, type = ExchangeTypes.FANOUT)))
    @RabbitHandler
    public void fanoutConsumer2(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Fanout Consume 2: {}", data);
        ack(channel, message);
    }

    @RabbitListener(queues = RabbitConst.FANOUT_QUEUE)
    @RabbitHandler
    public void fanoutConsumer3(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Fanout Consume 3: {}", data);
        ack(channel, message);
    }

结果：
在这里插入图片描述

请添加图片描述
路由模式（direct）：

  1. 一个生产者，一个交换机，多个队列
  2. 消息发送给完全匹配RoutingKey的队列
  3. 一个队列可以绑定多个RoutingKey

Config：

    /**
     * 一个平平无奇的Queue
     *
     * @return
     */
    @Bean
    public Queue directQueue1() {
        return new Queue(RabbitConst.DIRECT_QUEUE_1);
    }

    /**
     * 一个平平无奇的Queue
     *
     * @return
     */
    @Bean
    public Queue directQueue2() {
        return new Queue(RabbitConst.DIRECT_QUEUE_2);
    }

    /**
     * 声明对应交换机
     *
     * @return
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(RabbitConst.DIRECT_EXCHANGE);
    }

    /**
     * 绑定三连
     * 一个Queue, 一个Routing Key
     *
     * @return
     */
    @Bean
    public Binding directBinding1() {
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with(RabbitConst.DIRECT_KEY_1);
    }

    /**
     * 一个Queue, 两个Routing Key
     * 队列相同，with方法那里的RoutingKey不同
     * 
     * @return
     */
    @Bean
    public Binding directBinding2() {
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with(RabbitConst.DIRECT_KEY_2);
    }

    @Bean
    public Binding directBinding3() {
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with(RabbitConst.DIRECT_KEY_3);
    }

Producer：

    /**
     * Direct Mode
     *
     * @param routingKey
     */
    public void directMessage(String routingKey) {
        String data = "Direct Test " + routingKey;
        LOGGER.info("[Producer] Send: {}", data);
        amqpTemplate.convertAndSend(RabbitConst.DIRECT_EXCHANGE, routingKey, data);
    }

Consumer：

    @RabbitListener(queues = RabbitConst.DIRECT_QUEUE_1)
    @RabbitHandler
    public void directConsumer1(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Direct Consume 1: {}", data);
        ack(channel, message);
    }

    @RabbitListener(queues = RabbitConst.DIRECT_QUEUE_2)
    @RabbitHandler
    public void directConsumer2(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Direct Consume 2: {}", data);
        ack(channel, message);
    }

结果：
在这里插入图片描述
请添加图片描述
主题模式（topic）：

  1. 一个生产者，一个交换机，多个队列
  2. 消息发送给满足匹配规则的队列
  3. 一个队列可以绑定多个RoutingKey

Config：

    /**
     * 平平无奇的队列
     */
    @Bean
    public Queue topicQueue() {
        return new Queue(RabbitConst.TOPIC_QUEUE);
    }

    /**
     * with输入匹配规则
     * 匹配规则：
     * *代表一个单词
     * #代表一个或多个单词
     * *和#都可以代表任意字符或空
     * 多个字符用.连接
     * 
     * eg. 
     * TOPIC.*.TEST 可以匹配 TOPIC.TEST     TOPIC.AA.TEST   不能匹配TOPIC.AA.BB.TEST
     * TOPIC.#.TEST 可以匹配 TOPIC.TEST     TOPIC.AA.TEST   TOPIC.AA.BB.TEST
     *
     * @return
     */
    @Bean
    public Binding topicBinding() {
        return BindingBuilder.bind(topicQueue()).to(topicExchange()).with("TOPIC.#.TEST");
    }

Producer：

    /**
     * Topic Mode
     *
     * @param routingKey
     */
    public void topicMessage(String routingKey) {
        String data = "Topic Test " + routingKey;
        LOGGER.info("[Producer] Send: {}", data);
        amqpTemplate.convertAndSend(RabbitConst.TOPIC_EXCHANGE, routingKey, data);
    }

Consumer：

    @RabbitListener(queues = RabbitConst.TOPIC_QUEUE)
    @RabbitHandler
    public void topicConsumer(String data, Channel channel, Message message) {
        LOGGER.info("[Consumer] Topic Consume: {}", data);
        ack(channel, message);
    }

结果：
在这里插入图片描述

总结：

  1. 在我看来，工作模式和简单模式更像是针对队列的处理，在其他模式中也适用，广播时，也可以为一个队列来准备多个消费者分担压力。
  2. 传递对象链接：https://blog.csdn.net/qq_43010427/article/details/119827784

如有不准确之处，欢迎大家指出~

飞翔的肉山
关注
专栏目录
spring boot 集成rabbit mq 成功demo
11-23
spring boot 集成rabbit mq 成功demo，spring boot 集成rabbit mq 成功demo
rabbitmq-advanced-spring-boot-starter：一个通用库，用于通过spring boot amqp上的扩展名与rabbit mq进行消息传递
01-30
该项目的目的是为Rabbit MQ提供一个通用的Spring Boot Starter项目，用于消息传递解决方案。 通过简单地在yml中提供配置，这有助于我们自动配置Rabbit mq交换和队列以及绑定。 这也有助于在框架级别的单个位置更好地...
rabbit的工作模式
qq_53678217的博客
04-21 334
1. 正文 1. 工作者模式: 2. 发布订阅模式 3. 路由模式 4. topic主体模式。 5. Springboot整合rabbitMQ 2. 工作者模式: 特点: 1. 一个生产者 2. 由多个消费。 3. 统一个队列。 4. 这些消费者之间存在竞争关系。 用处: 比如批量处理上. rabbitMQ里面积压了大量的消息。 生产者 package com.ykq.work; import com.rabbitmq.client.Channel; i
RabbitMQ自学之路（五）——-SpringBoot与RabbitMQ整合和对五种队列模式的实现
互联网叫兽
06-21 2341
前面章节已经对RabbitMQ的五种队列模式进行了介绍，现在通过SpringBoot整合RabbitMQ来对五种队列模式进行一个更深入的描述 一、springboot集成RabbitMQ springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp对消息各种支持。 1、配置pom文件，添加spring-b...
SpringBoot整合MQ
最新发布
weixin_55772633的博客
08-24 1433
springboot整合ActiveMQ提供了JmsMessagingTemplate对象作为客户端操作消息队列操作ActiveMQ需要配置ActiveMQ服务器地址，默认端口61616企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@JmsListener配置jms的pub-sub-domain属性可以在点对点模型和发布订阅模型间切换消息模型。
springboot+mq
Stestack的博客
08-05 381
前言: RabbitMQ相关知识请参考: https://www.jianshu.com/p/cc3d2017e7b3 Linux安装RabbitMQ请参考: https://www.jianshu.com/p/ee9f7594212b Windows安装RabbitMQ请参考: https://www.jianshu.com/p/c7726ba4b046 一、先扔一张图 image....
SpringBoot 整合 RabbitMQ 实现三种模式 （一）有图 有源码
Xiang想
09-02 945
使用SpringBoot整合RabbitMQ实现直连、散形、主题三种模式。有图有源码
spring-microservices-v2：我们最受欢迎的课程的V2-微服务+ Spring Boot + Spring Cloud + Docker + Kubernetes-https：www.udemy.comcoursemicroservices-with-spring-boot-and-spring-cloud
02-21
Spring微服务-V2 我们最受欢迎的课程的V2-微服务+ Spring Cloud + Docker + Kubernetes 了解如何使用Spring和Spring Boot创建很棒的微服务和RESTful Web...使用Rabbit MQ的异步通信 带有Spring Cloud-V2的微服务 步骤
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
详解Spring Boot 配置多个RabbitMQ
08-30
Spring Boot 配置多个 RabbitMQ Spring Boot 是一个流行的 Java 框架，用于快速构建生产级别的应用程序。RabbitMQ 是一个消息队列中间件，用于实现异步消息处理和队列管理。配置多个 RabbitMQ 实例是为了提高系统的...
SpringBoot 整合 RabbitMQ 消息队列
Jaemon
12-30 627
SpringBoot 整合 RabbitMQ 消息队列
rabbitmq 同一个topic交换机下不同的routingkey指向同一个queue
top_explore的博客
08-17 5630
使用rabbitmq时，如果在同一个交换机下绑定了不同的routingkey A和B，指向同一个queue。 那么在监听的时候，routingkey为B的消息也会被A监听到。
Springboot整合RabbitMQ
weixin_45698637的博客
04-17 3137
Springboot整合RabbitMQdocker 安装RabbitMQ配置文件RabbitMQ 使用1. Fanout模式使用2. Direct模式使用3. Topic模式使用 docker 安装RabbitMQ docker run -it -d -p 5672:5672 -p15672:15672 --hostname my-rabbit --name my-rabbit \ -v /home/docker_volume/rabbit/:/var/lib/rabbitmq \ -
Spring Boot项目使用RabbitMQ队列
play_big_knife的博客
12-20 3381
Spring Boot项目中使用Rabbitmq做为消息队列。消费队列可以实现生产者和消费者之间的和谐通信。
RabbitMQ常用的五种模式
何以解忧
05-29 431
官方地址：https://www.rabbitmq.com/getstarted.html 参考：https://www.cnblogs.com/Alva-mu/p/9535396.html java可以简单使用springdataRabbit来操作 简单的生产者消费者模式 （就是一个生产者发送消息到队列，由一个消费者消费） work模式 一个生产者对应多个消费者,但是只能有一个消费者获得消息...
springboot+rabbitmq两小时入门（三）：多重绑定
leo的博客
08-09 1941
概要： rabbitmq中，一个queue可以绑定多个routingkey，一个routingkey可以绑定多个queue。（下面demo演示的是一个queue可以绑定多个routingkey） application.properties配置： spring.rabbitmq.host=localhost # TCP/IP端口为5672，http端口为15672 spring.r...
SpringAMQP中topic模式关于一个队列多个key指向多个消费者
weixin_44282807的博客
05-05 1228
RabbitMQ 主题模式关于一个队列多个路由key
RabbitMq大纲
weixin_37862824的博客
08-15 911
rabbitMq、AMQP协议、百分百投递
spring boot 使用 Rabbit MQ
08-19
在 Spring Boot 中使用 RabbitMQ（Rabbit Message Queue）可以方便地实现消息驱动的应用程序。RabbitMQ 是一个开源的消息代理（message broker），它实现了 AMQP（Advanced Message Queuing Protocol）协议，用于在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值