1. Toy模板网首页
  2. > Toy博客

多个springboot整合使用rabbitmq(使用注解的方式)

9月前 作者：java-zh 分类：Toy博客 阅读(29) 违法举报

这篇具有很好参考价值的文章主要介绍了多个springboot整合使用rabbitmq(使用注解的方式)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、简述

先参考单个springboot使用rabbitmq和了解rabbitmq的五种模式

单个springboot整合rabbitmq_java-zh的博客-CSDN博客

二、创建项目

1、先创建两个springboot项目，一个做生产者，一个做消费者

 2、导包(生产者和消费者对应的内容都是一样)

<?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.4.1</version>
        <relativePath/>
    </parent>
    <groupId>com.mq</groupId>
    <artifactId>mqcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <properties>
        <spring-cloud-alibaba.version>2021.1</spring-cloud-alibaba.version>
        <java.version>1.8</java.version>
        <spring-boot.version>2.5.3</spring-boot.version>
        <lombok.version>1.18.14</lombok.version>
        <mybaits.plus.version>3.3.2</mybaits.plus.version>
        <alibaba.json.version>1.2.75</alibaba.json.version>
        <spring-cloud-starter-bootstrap.version>3.0.2</spring-cloud-starter-bootstrap.version>
    </properties>

    <!--    <dependencyManagement>-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--AOP-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--bootstrap 启动器-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bootstrap</artifactId>
            <version>${spring-cloud-starter-bootstrap.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${alibaba.json.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
        <!--jjwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
        </dependency>


        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
        <!--zhong 基础jar-->
        <dependency>
            <groupId>com.common</groupId>
            <artifactId>base</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--消息队列 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>3.0.4</version>
        </dependency>
    </dependencies>
    <!--    </dependencyManagement>-->



</project>

3、编写配置文件

这里的配置文件生产者和消费者都一样

spring:
 rabbitmq:
    #如果是集群，用,隔开
    connection-timeout: 15000
    username: admin
    password: 123456
    #虚拟host，可以不设置
    virtual-host: /
    listener:
      simple:
        acknowledge-mode: auto  #manual:手动处理 auto:自动处理
        #消费端监听个数(即@RabbitListenter开启几个线程去处理)
        concurrency: 10
        #消费端监听的最大个数
        max-concurrency: 10
        prefetch: 5
        default-requeue-rejected: true  #消费不成功的消息,拒绝入队
        retry:
          enabled: true #开启消息重试
          max-attempts: 4 #重试次数
          max-interval: 10000 #重试最大间隔时间
          initial-interval: 2000 #重试初始间隔时间
    #消息确认方式,通过correlated来确认
    publisher-confirm-type: correlated
    publisher-returns: true
    host: 192.168.139.128
    port: 5672
rabbitmq:
  #订阅模式(扇形模式)  
  fanout:
    exchange:
      #交换机名称
      name1: exchange.fanout
    queue:
      #通道名称
      name1: exchange.fanout.queue_1
      name2: exchange.fanout.queue_2
  #交换机模式  
  direct:
    exchange:
      name1: exchange.direct
    queue:
      name1: exchange.direct.queue_1
      name2: exchange.direct.queue_2
    routing:
      name1: exchange.direct.routing.1
      name2: exchange.direct.routing.2
  #主题模式  
  topic:
    exchange: 
      name1: exchange.topic
    queue:
      name1: exchange.topic.queue_1
      name2: exchange.topic.queue_2
    routing:
      name1: '#.routingkey.#'
      name2: routingkey.*

三、编码代码和测试结果

这里以rabbitmq的订阅模式(扇形模式)、路由器模式、主题模式为案例

3.1 扇形模式

生产者

@Autowired
private  RabbitTemplate rabbitTemplate;

// 订阅模式的交换机名称
@Value("${rabbitmq.fanout.exchange.name1}")
 private String exchangeName;


/**
  * 订阅模式(扇形模式)生产者
  *
  * @param context
  */
@GetMapping("/fanout/{context}")
public void sendMessage(@PathVariable String context) {
   System.out.println("需要发送得内容为:" + context);
   rabbitTemplate.convertAndSend(exchangeName, "", context);
}

消费者

注意：消费者绑定交换机和通道的值必须是固定常量值，所以我们直接从配置文件中读取

@RabbitListener(bindings = @QueueBinding(exchange = @Exchange(value = "${rabbitmq.fanout.exchange.name1}", type = ExchangeTypes.FANOUT),
            value = @Queue(value = "${rabbitmq.fanout.queue.name1}")))
    @RabbitHandler
    public void consumerFanoutExchange(String context) {
        System.out.println("订阅模式，通道一接收到的内容为内容:" + context);
    }

@RabbitListener(bindings = @QueueBinding(exchange = @Exchange(value = "${rabbitmq.fanout.exchange.name1}", type = ExchangeTypes.FANOUT),
            value = @Queue(value = "${rabbitmq.fanout.queue.name2}")))
    @RabbitHandler
    public void consumerFanoutExchange2(String context) {
        System.out.println("订阅模式，通道二接收到的内容为内容:" + context);
}

3.2 路由器模式

生产者

@Autowired
private  RabbitTemplate rabbitTemplate;

// 路由器模式的交换机名称
@Value("${rabbitmq.direct.exchange.name1}")
private String directName;

// 路由器模式的路由key1
@Value("${rabbitmq.direct.routing.name1}")
private String directRoutingKeyName1;

//路由器模式的路由key2
@Value("${rabbitmq.direct.routing.name2}")
private String directRoutingKeyName2;

/**
  * 路由器模式
  * @param context
  * @param routingkey
  */
@GetMapping("/direct")
public void sendMessageDirect(@RequestParam("context") String context, @RequestParam("routingkey") Integer routingkey) {
   if (1 == routingkey) {
      rabbitTemplate.convertAndSend(directName, directRoutingKeyName1, context);
   } else if (2 == routingkey) {
      rabbitTemplate.convertAndSend(directName, directRoutingKeyName2, context);
   } else {
      System.out.println("数据非法");
   }
}

消费者


    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.direct.exchange.name1}", type = ExchangeTypes.DIRECT),
            value = @Queue(value = "${rabbitmq.direct.queue.name1}"),
            key = "${rabbitmq.direct.routing.name1}"))
    public void exchangeDirectRoutingKey1(String context, Message message) {
        System.out.println("key1:" + message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("路由器模式1 接收到的消息为:" + context);
    }

    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.direct.exchange.name1}", type = ExchangeTypes.DIRECT),
            value = @Queue(value = "${rabbitmq.direct.queue.name2}"),
            key = "${rabbitmq.direct.routing.name2}"))
    public void exchangeDirectRoutingKey2(String context, Message message) {
        System.out.println("key2:" + message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("路由器模式2 接收到的消息为" + context);
    }

3.3 主题模式

生产者

// 主题模式的交换机名称
    @Value("${rabbitmq.topic.exchange.name1}")
    private String topicName;

    //用来匹配主题模式对应的key
    public static final String EXCHANGE_TOPIC_CASE_KEY_1 = "topic.routingkey.case1";

    //如果case_key_2这样写,那么绑定case_key_1的队列一样会接收到，因为case_key_2也一样和key1匹配上
    public static final String EXCHANGE_TOPIC_CASE_KEY_2 = "routingkey.case2";

    @GetMapping("/topic")
    public void sendMessageTopic(@RequestParam("context") String context, @RequestParam("routingkey") Integer routingkey) {
        if (1 == routingkey) {
            rabbitTemplate.convertAndSend(topicName, EXCHANGE_TOPIC_CASE_KEY_1, context + routingkey);
        } else if (2 == routingkey) {
            rabbitTemplate.convertAndSend(topicName, EXCHANGE_TOPIC_CASE_KEY_2, context + routingkey);
        } else {
            System.out.println("数据非法");
        }
    }

消费者

@RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.topic.exchange.name1",  type = ExchangeTypes.TOPIC),
            value = @Queue(value = "${rabbitmq.topic.queue.name1}"),
            key = "${rabbitmq.topic.routing.name1}"))
    @RabbitHandler
    public void exchangeTopicRoutingKey1(String context, Message message) {
        System.out.println("key1:"+message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("主题模式1:接收的内容为:"+ context);
    }

@RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.topic.exchange.name1", type = ExchangeTypes.TOPIC),
            value = @Queue(value = "${rabbitmq.topic.queue.name2}"),
            key = "${rabbitmq.topic.routing.name2}"))
    @RabbitHandler
    public void exchangeTopicRoutingKey2(String context,  Message message) {
        System.out.println("key2:"+message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("主题模式2:接收的内容为:"+ context);
    }

3.4 全量代码

生产者

@RestController
@RequiredArgsConstructor
@RequestMapping("/test/mq")
public class ProductController {

    private final RabbitTemplate rabbitTemplate;

    // 订阅模式的交换机名称
    @Value("${rabbitmq.fanout.exchange.name1}")
    private String exchangeName;

    // 路由器模式的交换机名称
    @Value("${rabbitmq.direct.exchange.name1}")
    private String directName;

    // 路由器模式的路由key1
    @Value("${rabbitmq.direct.routing.name1}")
    private String directRoutingKeyName1;

    //路由器模式的路由key2
    @Value("${rabbitmq.direct.routing.name2}")
    private String directRoutingKeyName2;

    // 主题模式的交换机名称
    @Value("${rabbitmq.topic.exchange.name1}")
    private String topicName;

    //用来匹配主题模式对应的key
    public static final String EXCHANGE_TOPIC_CASE_KEY_1 = "topic.routingkey.case1";

    //如果case_key_2这样写,那么绑定case_key_1的队列一样会接收到，因为case_key_2也一样和key1匹配上
    public static final String EXCHANGE_TOPIC_CASE_KEY_2 = "routingkey.case2";


    /**
     * 订阅模式(扇形模式)生产者
     *
     * @param context
     */
    @GetMapping("/fanout/{context}")
    public void sendMessage(@PathVariable String context) {
        System.out.println("需要发送得内容为:" + context);
        rabbitTemplate.convertAndSend(exchangeName, "", context);
    }

    /**
     * 路由器模式
     * @param context
     * @param routingkey
     */
    @GetMapping("/direct")
    public void sendMessageDirect(@RequestParam("context") String context, @RequestParam("routingkey") Integer routingkey) {
        if (1 == routingkey) {
            rabbitTemplate.convertAndSend(directName, directRoutingKeyName1, context);
        } else if (2 == routingkey) {
            rabbitTemplate.convertAndSend(directName, directRoutingKeyName2, context);
        } else {
            System.out.println("数据非法");
        }
    }

    @GetMapping("/topic")
    public void sendMessageTopic(@RequestParam("context") String context, @RequestParam("routingkey") Integer routingkey) {
        if (1 == routingkey) {
            rabbitTemplate.convertAndSend(topicName, EXCHANGE_TOPIC_CASE_KEY_1, context + routingkey);
        } else if (2 == routingkey) {
            rabbitTemplate.convertAndSend(topicName, EXCHANGE_TOPIC_CASE_KEY_2, context + routingkey);
        } else {
            System.out.println("数据非法");
        }
    }
}

消费者文章来源地址https://www.toymoban.com/news/detail-664825.html

@Component
public class ConsumerTest {


    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(value = "${rabbitmq.fanout.exchange.name1}", type = ExchangeTypes.FANOUT),
            value = @Queue(value = "${rabbitmq.fanout.queue.name1}")))
    @RabbitHandler
    public void consumerFanoutExchange(String context) {
        System.out.println("订阅模式，通道一接收到的内容为内容:" + context);
    }

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(value = "${rabbitmq.fanout.exchange.name1}", type = ExchangeTypes.FANOUT),
            value = @Queue(value = "${rabbitmq.fanout.queue.name2}")))
    @RabbitHandler
    public void consumerFanoutExchange2(String context) {
        System.out.println("订阅模式，通道二接收到的内容为内容:" + context);
    }


    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.direct.exchange.name1}", type = ExchangeTypes.DIRECT),
            value = @Queue(value = "${rabbitmq.direct.queue.name1}"),
            key = "${rabbitmq.direct.routing.name1}"))
    public void exchangeDirectRoutingKey1(String context, Message message) {
        System.out.println("key1:" + message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("路由器模式1 接收到的消息为:" + context);
    }

    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.direct.exchange.name1}", type = ExchangeTypes.DIRECT),
            value = @Queue(value = "${rabbitmq.direct.queue.name2}"),
            key = "${rabbitmq.direct.routing.name2}"))
    public void exchangeDirectRoutingKey2(String context, Message message) {
        System.out.println("key2:" + message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("路由器模式2 接收到的消息为" + context);
    }

    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.topic.exchange.name1",  type = ExchangeTypes.TOPIC),
            value = @Queue(value = "${rabbitmq.topic.queue.name1}"),
            key = "${rabbitmq.topic.routing.name1}"))
    @RabbitHandler
    public void exchangeTopicRoutingKey1(String context, Message message) {
        System.out.println("key1:"+message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("主题模式1:接收的内容为:"+ context);
    }

    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = "${rabbitmq.topic.exchange.name1", type = ExchangeTypes.TOPIC),
            value = @Queue(value = "${rabbitmq.topic.queue.name2}"),
            key = "${rabbitmq.topic.routing.name2}"))
    @RabbitHandler
    public void exchangeTopicRoutingKey2(String context,  Message message) {
        System.out.println("key2:"+message.getMessageProperties().getReceivedRoutingKey());
        System.out.println("主题模式2:接收的内容为:"+ context);
    }


}

到了这里，关于多个springboot整合使用rabbitmq(使用注解的方式)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • rabbitmq整合springboot:ChannelAwareMessageListener和@RabbitListener的使用

    Springboot中使用Rabbimq监听队列中有两种方式，一种是@RabbitListener注解的方式，一种是实现springboot:ChannelAwareMessageListener接口的方式 前者使用如下： 消费者： 生产者： 后者使用方式： 配置文件：

    2024年02月12日
    浏览(40)
  • Spring的注解开发-注解方式整合MyBatis代码实现

    Spring的注解开发-注解方式整合MyBatis代码实现

    之前使用xml方式整合了MyBatis，文章导航：Spring整合第三方框架-MyBatis整合Spring实现-CSDN博客 现在使用注解的方式无非是就是将xml标签替换为注解，将xml配置文件替换为配置类而已。 非自定义配置类                 与数据库建立连接的同时，扫描指定的mapper接口，实现实现

    2024年02月07日
    浏览(54)
  • 在SpringBoot中对RabbitMQ三种使用方式

    在SpringBoot中对RabbitMQ三种使用方式

            1.使用AmqpAdmin定制消息发送组件          2.消息发送者发送消息              创建实体类                                  发送消息                           如图所以,如果我们直接发送的话就会报这个错,有两种解决方法,第一种是比较常用的让实体

    2024年02月13日
    浏览(32)
  • springboot下使用rabbitMQ之开发配置方式(二)

    springboot下使用rabbitMQ之开发配置方式(二)

    消息参数传递在开发中也是个坑，不论使用内置的 SimpleMessageConverter 还是 Jackson2JsonMessageConverter 均无法让Consumer接收动态参数 首先贴出具体代码以及测试用例: 消费者 生产者（测试用例） 执行测试用例，它居然抛错了： 看吧json字符串是无法序列化为Map😂 试试用dto来接收这

    2024年02月16日
    浏览(36)
  • Spring Boot中整合MyBatis（基于xml方式&基于注解实现方式）

    Spring Boot中整合MyBatis（基于xml方式&基于注解实现方式）

    在Spring Boot中整合MyBatis时，你需要导入JDBC（不需要手动添加）、Druid的相关依赖、MySQL相关依赖。 JDBC依赖：在Spring Boot中整合MyBatis时，并不需要显式地添加JDBC的包依赖。这是因为，当你添加 mybatis-spring-boot-starter 依赖时，它已经包含了对JDBC的依赖。 mybatis-spring-boot-starter 是

    2024年02月15日
    浏览(57)

  • SpringBoot连接多个RabbitMQ

    1. 前 言 在 SpringBoot 中整合单个 RabbitMQ 使用，是很简单的，只需要引入依赖，然后在配置里面配置好 MQ 的连接地址、账号、密码等信息，然后使用即可。但如果 MQ 的连接地址是多个，那这种连接方式就不奏效了。 前段时间，我开发的一个项目就遇到了这样的问题。那个项目

    2024年02月16日
    浏览(38)

  • RabbitMQ: SpringBoot 整合 RabbitMQ

    重点是这个依赖 通过              和上一个一样  

    2024年02月09日
    浏览(47)

  • flask整合rabbitMQ插件的方式

    当今互联网应用的高并发场景下，如何保证可靠的消息传递和高效的处理成为了一项重要的挑战。在这种情况下，RabbitMQ作为一种可靠的消息队列系统，被广泛应用于各个领域。 本文将介绍如何使用RabbitMQ插件整合Flask框架，实现并发性生产者和消费者的兼容。通过这种方式，

    2024年02月03日
    浏览(34)
  • 【RabbitMQ】RabbitMQ整合SpringBoot案例

    【RabbitMQ】RabbitMQ整合SpringBoot案例

    【RabbitMQ】消息队列-RabbitMQ篇章 RabbitMQ实现流程 2.1 实现架构总览 实现步骤： 1：创建生产者工程：sspringboot-rabbitmq-fanout-producer 2：创建消费者工程：springboot-rabbitmq-fanout-consumer 3：引入spring-boot-rabbitmq的依赖 4：进行消息的分发和测试 5：查看和观察web控制台的状况 2.2 具体实现

    2024年02月12日
    浏览(44)

  • 【RabbitMQ】4 Spring/SpringBoot整合RabbitMQ

    spring-amqp 是对AMQP的一些概念的一些抽象， spring-rabbit 是对RabbitMQ操作的封装实现。 主要有几个核心类 RabbitAdmin 、 RabbitTemplate 、 SimpleMessageListenerContainer 等。 RabbitAdmin 类完成对Exchange，Queue，Binding的操作，在容器中管理了 RabbitAdmin 类的时候，可以对Exchange，Queue，Binding进行自

    2024年01月22日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包