SpringBoot整合RabbitMQ（创建队列、一次性消费、发送消息、路由绑定，监听消费）

最新推荐文章于 2024-07-02 21:07:07 发布
最新推荐文章于 2024-07-02 21:07:07 发布
阅读量7.6k 收藏 46
点赞数 18
分类专栏： MQ 文章标签： rabbitmq spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dean_xiu/article/details/120898254
版权

文章目录

主要步骤

  • 创建SpringBoot工程
  • 配置RabbitMQ的基本参数
    host 、virtual host、username、password
  • 通过RabbitTemplate创建RabbitAdmin，通过RabbitAdmin操作RabbitMQ
    RabbitAdmin可以创建队列、交换机、发送数据、主动消费数据
    同时SpringBoot提供了Listener监听器来实现实时消费数据

环境

开发工具：IDEA 2020.1
操作系统：Centos7
RabbitMQ版本：Docker中rabbitmq:management
Docker版本：20.10.9

实际操作

创建SpringBoot工程

  • 使用命令创建SpringBoot工程
mvn org.apache.maven.plugins:maven-archetype-plugin:3.1.2:generate -DarchetypeArtifactId="maven-archetype-webapp" -DarchetypeGroupId="org.apache.maven.archetypes" -DarchetypeVersion="1.4"

该命令创建的是传统maven工程，需要手动改造成SpringBoot工程
删除WebApp目录及下属内容，改造为下列文件结构
在这里插入图片描述

  • 添加pom文件中的依赖
    完全改造后内容如下，比对完成即可
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.dean</groupId>
  <artifactId>SpringBoot_RabbitMQ</artifactId>
  <version>1.0-SNAPSHOT</version>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
  </parent>



  <properties>
    <java.version>1.8</java.version>
  </properties>

  <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>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>SpringBoot_RabbitMQ</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

主要是<parent>、<properties>、<dependency>节点进行了更改

  • 编写启动类
    在这里插入图片描述

配置RabbitMQ的基本参数

  • resources目录下创建application.yml配置文件
    在这里插入图片描述
  • 编写参数
    在这里插入图片描述

操作RabbitMQ

  • 创建一个SpringBoot的测试用例
    上面的操作中，我们已经在pom文件中添加了SpringBoot Test的依赖了
    现在我们需要src目录下创建一个test目录，在test目录下写一个RabbitTest类进行测试
    在这里插入图片描述
    在这里插入图片描述

  • 创建一个队列
    在这里插入图片描述

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitApplication.class)
public class RabbitTest {
    @Resource
    private RabbitTemplate rabbitTemplate;

    //声明一个队列
    @Test
    public void createQueue() {
        //创建RabbitAdmin 用于操作队列
        RabbitAdmin admin = new RabbitAdmin(rabbitTemplate);
        Queue springQueue = new Queue("SpringQueue");
        admin.declareQueue(springQueue);
    }
}

执行后，可以在RabbitMQ的web界面看到新生成的队列
在这里插入图片描述

  • 向队列发送消息
 @Test
    public void sendMsg() {
        rabbitTemplate.convertAndSend("SpringQueue","Hello Spring Rabbit");
    }
    }

在这里插入图片描述
在这里插入图片描述

  • 消费（一次性消费）
    这个场景就是例如我们上线某聊天软件后，需要得知有多少未读信息，不去拿消息本身
@Test
    public void consumeMsg() {
        rabbitAdmin = new RabbitAdmin(rabbitTemplate);
        //队列的属性 Properties继承HashTable
        Properties properties = rabbitAdmin.getQueueProperties("SpringQueue");
        //由于不知道properties里面都有什么，所以输出看一下
        /**
         * 里面的内容如下：
         * QUEUE_MESSAGE_COUNT
         * QUEUE_CONSUMER_COUNT
         * QUEUE_NAME
         */
        Enumeration<?> names = properties.propertyNames();
        while (names.hasMoreElements()) {
            Object e = names.nextElement();
            System.out.println(e);
        }
        //获取消息总数
        String msg = properties.get("QUEUE_MESSAGE_COUNT").toString();
        System.out.println(msg );
        //清空队列 （也就是说本次是一次性消费）
        rabbitAdmin.purgeQueue("SpringQueue");
    }

在这里插入图片描述
消息已被清空
在这里插入图片描述

  • 路由绑定
@Test
    public void routeBind() {
        rabbitAdmin = new RabbitAdmin(rabbitTemplate);
        //声明队列
        //系统消息接收队列，userId在实际生产中为实际用户id
        Queue sysQueue = new Queue("sys.msg.userId");
        //一对一消息接收队列，sendUserId为实际向用户发送消息的用户id
        Queue userQueue=new Queue("user.msg.sendUserId");
        //声明交换机 Direct
        DirectExchange directEx = new DirectExchange("notice.direct");
        //声明绑定
        Binding sysBind = BindingBuilder.bind(sysQueue).to(directEx).with("sys");
        Binding userBind = BindingBuilder.bind(userQueue).to(directEx).with("user");

        //创建队列
        rabbitAdmin.declareQueue(sysQueue);
        rabbitAdmin.declareQueue(userQueue);
        //创建交换机
        rabbitAdmin.declareExchange(directEx);
        //创建绑定关系
        rabbitAdmin.declareBinding(sysBind);
        rabbitAdmin.declareBinding(userBind);
    }

在这里插入图片描述
成功创建的队列
在这里插入图片描述

成功创建的交换机及绑定关系
在这里插入图片描述

  • 通过路由向队列发送消息
@Test
    public void sendMsg2Route() {
        rabbitTemplate.convertAndSend("notice.direct","sys", "系统通知");
        rabbitTemplate.convertAndSend("notice.direct","sys", "系统通知");
        rabbitTemplate.convertAndSend("notice.direct","user", "用户通知");
    }

在这里插入图片描述
向系统队列发两条消息，向用户队列发一条消息
在这里插入图片描述

RabbitMQ监听消费

  • 首先我们需要一个监听器和一个监听配置
    在这里插入图片描述
  • 监听器SysNoticeListener
@Component
public class SysNoticeListener implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        System.out.println(Thread.currentThread().getName()+": 监听到消息");
        Thread.sleep(1000);
    }
}

重点在于实现了ChannelAwareMessageListener类，重写了其方法OnMessage

  • 监听配置类 RabbitConfig
@Configuration
public class RabbitConfig {
    //注入自定义的监听器
    @Resource
    private SysNoticeListener sysNoticeListener;

    @Bean
    public SimpleMessageListenerContainer listenerContainer(ConnectionFactory connectionFactory) {
        //创建监听器工厂
        SimpleRabbitListenerContainerFactory factory=new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);

        //ack机制  自动消费 或 手动消费
        //自动消费：无论消费是否成功都进行确认
        //手动消费：由程序员来判断消费是否成功
        //设置为无ACK机制
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);

        //设定消费者的线程数
        factory.setMaxConcurrentConsumers(5); //设置最大其实也不生效
        factory.setConcurrentConsumers(3);  //3个消费者

        //使用工厂生成监听器容器
        SimpleMessageListenerContainer container = factory.createListenerContainer();
        //绑定监听队列  监听器监听哪个队列
        container.setQueueNames("sys.msg.userId");
        //绑定监听器  用哪个监听器来监听
        container.setMessageListener(sysNoticeListener);
        return container;
    }
}

当队列中有消息时，会进行消费，程序运行后like this
在这里插入图片描述

场景模拟

我们虚拟一个场景，用RabbitMQ实现一下
故事是这样的，当用户上线时,获得系统未读消息数量，上线期间，可以实时获取消息，下线后不再实时获取

也就是说，当用户上线时，返回当前队列中消息总数，上线期间，实时监听消息

具体实现

  • 编写RabbitConfig
@Configuration
public class RabbitConfig {
    //注入自定义的监听器
    @Resource
    private SysNoticeListener sysNoticeListener;

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Bean("sysListenerContainer")
    public SimpleMessageListenerContainer listenerContainer(ConnectionFactory connectionFactory) {
        //创建监听器工厂
        SimpleRabbitListenerContainerFactory factory=new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);

        //ack机制  自动消费 或 手动消费
        //自动消费：无论消费是否成功都进行确认
        //手动消费：由程序员来判断消费是否成功
        //设置为无ACK机制
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);


        //设定消费者的线程数
        factory.setMaxConcurrentConsumers(5); //设置最大其实也不生效
        factory.setConcurrentConsumers(3);  //3个消费者

        //使用工厂生 成监听器容器
        SimpleMessageListenerContainer container = factory.createListenerContainer();
        //绑定监听队列  监听器监听哪个队列
        //container.setQueueNames("sys.msg.userId");
        //绑定监听器  用哪个监听器来监听
        container.setMessageListener(sysNoticeListener);
        return container;
    }

    /**
     * 当服务器启动时，为每个用户生成一个队列用于接收系统消息
     * 队列名称规则：[sys.msg.userId]  sys.msg.1 sys.msg.2
     */
    @Bean("rabbitAdmin")
    public RabbitAdmin rabbitAdmin() {
        RabbitAdmin admin = new RabbitAdmin(rabbitTemplate);
        List<Queue> queues = new ArrayList<>();
        //创建队列
        IntStream.range(0,2).forEach(i->{
            queues.add(new Queue("sys.msg."+i));
        });

        //创建交换机
        //因是系统通知，所以创建Fanout交换机
        FanoutExchange exchange = new FanoutExchange("sys.notice.fanout");

        //交换机和队列绑定
        List<Binding> bindings = new ArrayList<>();
        for (Queue q : queues) {
            bindings.add(BindingBuilder.bind(q).to(exchange));
        }

        admin.declareExchange(exchange);
        IntStream.range(0,2).forEach(i->{
            admin.declareQueue(queues.get(i));
            admin.declareBinding(bindings.get(i));
        });
        return admin;
    }

}

rabbitAdmin方法中可以根据实际情况，增大循环数，为每一个用户创建一个接收系统通知的队列

  • 编写Controller
@RestController
@RequestMapping("user")
public class ConsumeController {
    //注入容器
    @Resource(name = "sysListenerContainer")
    private SimpleMessageListenerContainer container;
    //注入监听器
    @Resource
    private SysNoticeListener listener;
    //注入RabbitAdmin
    @Resource(name = "rabbitAdmin")
    private RabbitAdmin rabbitAdmin;

    /**
     * 登录时首先获得未读消息数量  然后进行实时消费
     * @param userId
     * @return
     */
    @GetMapping("login/{userId}")
    public String login(@PathVariable String userId) {
        /*
        登录成功后 首先获取离线消息 即消息的数量
         */

        //根据UserId拼接自己的队列名称
        String queueName = "sys.msg." + userId;
        Properties queueProperties = rabbitAdmin.getQueueProperties(queueName);
        //通过属性值获取消息总量
        int count = Integer.parseInt(queueProperties.get("QUEUE_MESSAGE_COUNT").toString());
        System.out.println("您未上线的时间里，有" + count + "条消息在等您");
        //清空队列 一定要清空
        rabbitAdmin.purgeQueue(queueName);

        /*
        上线后，消息是实时消费的
         */

        //监听容器绑定监听队列
        container.setQueueNames(queueName);

        return "success";

    }


    /**
     * 退出登录时 移除监听队列
     *
     * @return
     */
    @GetMapping("/logout/{userId}")
    public String logout(@PathVariable("userId") String userId) {
        String queueName = "sys.msg." + userId;
        container.removeQueueNames(queueName);
        return "logout success";
    }
}

也就是在用户成功登录后才进行将监听容器和队列相绑定，在用户退出登录后，从监听容器中移除该队列

  • 编写监听器Listener
@Component
public class SysNoticeListener implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

       /*
       模拟业务中对实时消息的处理
        */

        //根据队列名称获取用户id
        MessageProperties messageProperties = message.getMessageProperties();
        //获取队列名称
        String consumerQueue = messageProperties.getConsumerQueue();
        //获取消息体
        byte[] body = message.getBody();
        System.out.println(consumerQueue + "：收到实时消息【" + new String(body) + "]");
    }
}

监听器实际上处理的是实时消息的处理

  • 最终效果
    在这里插入图片描述
    登录哪一个用户，哪一个用户就可以接收实时消息

  • 补充一点关于ACK机制
    如果在RabbitConfig中设置了ACK为手动模式，那么就需要在监听器中增加try-catch进行手动处理

RabbitConfig中
在这里插入图片描述

监听器中
在这里插入图片描述
消息的处理需要放在try中，如果消息消费失败，则将消息返回给队列

Dean_xiu
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot集成RabbitMQ消息队列
AI天才研究院
07-30 1572
作者：禅与计算机程序设计艺术2021年7月，Spring官方宣布了 Spring Boot 的正式版本发布，这是目前最主流的 Java Web开发框架。它提供了非常方便的集成环境配置、自动化配置、starter依赖管理、健康检查等功能。基于这些优秀特性，越来越多的人开始使用 Spring Boot 来进行企业级开发。 Spring Boot 作为新时代 Java Web开发领域的先驱，在国内外都受到广泛关注，也被用于各种企业级项目的开发。其中集成消息队列的功能虽然有限，但依然可以提供高性能的分布式应用服务。
优雅封装RabbitMQ实现动态队列、动态生产者，动态消费者绑定
fu18889708485的博客
04-24 4512
优雅封装RabbitMQ实现动态队列、动态生产者，动态消费者绑定
springboot整合消息队列——RabbitMQ
Candyz7的博客
08-23 738
System.out.println("队列：fanout1 username:"+user.getUsername()+" password:"+user.getPassword());System.out.println("队列：fanout2 username:"+user.getUsername()+" password:"+user.getPassword());创建两个队列 topic1,topic2，创建一个topic交换器，绑定交换机和队列以及绑定规则。//创建一个topic交换器。
SpringBoot + RabbitMQ 简单实现创建队列的三种方式
热门推荐
老油条
11-20 3万+
  1、前提：安装：RabbitMQ 通过Docker方式快速安装    2、pox.xml 引入 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-cloud-starter-amqp&lt;/artifactId&gt;...
springboot 搭建rabbitmq
yy1209357299的博客
07-12 122
1、pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2、配置文件 spring.application.name=rabbitmq-produce server.port=8080
使用 RabbitMQ 在 Spring Boot 应用中实现消息队列
一个有兴趣的程序员男孩
08-15 345
消息队列（Message Queue，MQ）是一种用于在应用程序之间传递消息的通信机制，常用于解耦和异步处理。在 Java Spring Boot 应用中，结合 RabbitMQ 可以轻松实现消息队列功能。本文将介绍消息队列的现状与作用，讨论 RabbitMQ 的三种交换机类型，并详细解读 RabbitMQ 的配置文件。我们还会为每种交换机类型提供示例，包括监听者和消息发送测试。
springboot实现rabbitmq动态创建交换机，队列以及交换机、队列绑定
weixin_42552016的博客
04-05 2894
springboot实现rabbitmq动态创建交换机，队列以及交换机、队列绑定。
SpringBoot整合RabbitMQ广播队列消息积压问题
weixin_41392674的博客
07-05 846
关于RabbitMQ消息堆积问题的记录
SpringBoot整合Rabbitmq之死信队列
桐花思雨
09-25 3006
目录死信队列死信从何而来 死信队列 死信：无法被消费方消费掉的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功。所以 rabbitmq 专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange） 死信从何而来 消息被拒绝（调用 basicNack() 或 basicReject()，并且参数 requeue = false） 消息过期，过了 TTL 存活时间 队列设置了 x-max-length 最大消息数量且当前队列中的消息已经达到了这个数量，
springboot与rabbitmq消息队列的整合
08-05
SpringBoot+RabbitMQ，springboot与rabbitmq消息队列的整合。
第9节、springBoot整合 rabbitMQ消息队列
小小木的博客
07-19 444
作为一款能实现高性能存储分发消息的分布式中间件，具有异步通信、服务解耦、接口限流、消息分发和业务延迟处理等功能，在实际生产环境中具有很广泛的应用。
Spring Boot项目使用RabbitMQ队列
play_big_knife的博客
12-20 3358
Spring Boot项目中使用Rabbitmq做为消息队列。消费队列可以实现生产者和消费者之间的和谐通信。
Springboot + RabbitMq 消息队列
_binlong的博客
02-09 933
- AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。 - 可靠性（Reliability） RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认。
SpringBoot整合RabbitMQ（超详细）
海的那边，还是海吗
09-06 2236
创建交换机方法：ExchangeBuilder.交换机类型（交换机名字）.是否持久化，是否自动删除。BindingBuilder.bind(交换机名字).to(队列名字).with(路由K)消息的整个过程：消息先发送到交换机----交换机通过路口K发送到对应的队列里面去。发送消息方法:convertAndSend(交换机名字，路由K，消息内容)1、消息确认模式，消息发送到交换机时会返回回调函数（成功还是失败）2、退回模式，交换机发送给队列，只有失败时会触发。注入RabbitTemplate。
SpringBoot集成RabbitMQ
最新发布
abc_138的博客
07-02 2350
RabbitMQ官方提供的Java 客户端编码相对复杂，一般生产环境下我们更多会结合Spring 来使用。而Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具SpringAMQP。
spring boot rabbit mq 监听并且创建队列
攻城狮子的博客
05-24 1万+
正常情况下rabbit mq不会自动创建队列在监听队列的时候使用@RabbitListener(queuesToDeclare = @Queue("queue"))这样就会自己去创建这个队列的监听
springboot rabbitMQ rabbitAdmin客户端配置策略
12-30
以下是使用Spring Boot和RabbitMQ的RabbitAdmin客户端配置策略的示例： 首先，确保已经安装了RabbitMQ并启动了服务。 在Spring Boot项目中，首先需要添加RabbitMQ的依赖。在pom.xml文件中添加以下依赖项： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 然后，在application.properties文件中配置RabbitMQ的连接信息： ```properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 接下来，创建一个配置类来配置RabbitAdmin客户端： ```java import org.springframework.amqp.core.AmqpAdmin; import org.springframework.amqp.core.Queue; import org.springframework.amqp.rabbit.connection.ConnectionFactory; import org.springframework.amqp.rabbit.core.RabbitAdmin; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class RabbitMQConfig { @Bean public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) { return new RabbitAdmin(connectionFactory); } @Bean public Queue myQueue() { return new Queue("myQueue"); } } ``` 在上面的配置类中，我们创建了一个名为"myQueue"的队列，并将其注册到RabbitAdmin客户端中。 现在，您可以在您的应用程序中使用RabbitAdmin来管理RabbitMQ的队列、交换机等资源。例如，您可以使用RabbitAdmin来声明队列、绑定交换机等操作。 请注意，上述示例假设您已经正确配置了RabbitMQ的连接信息，并且您的应用程序已经正确引入了Spring Boot和RabbitMQ的依赖项。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值