SpringBoot集成RabbitMQ如何使用多线程进行消费

最新推荐文章于 2024-05-01 10:42:58 发布
最新推荐文章于 2024-05-01 10:42:58 发布
阅读量5.9k 收藏 23
点赞数 1
分类专栏： springboot web 文章标签： docker centos linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48329942/article/details/121476468
版权

文章目录

前言

SpringBoot家族对rabbitmq提供了非常好了集成，今天主要是针对springboot中如何使用rabbitmq以及在业务中如何多线程处理消息

一、安装RabbitMQ

老规矩，安装MQ

1.安装erlang语言

https://www.erlang.org/downloads

erlang语言需要设置环境，和jdk环境设置一样

2.安装MQ

https://www.rabbitmq.com/download.html

启动sbin目录下的rabbitmq-server.bat

3.可视化界面

http://localhost:15672

默认账户密码 ： guest

二、springboot集成RabbitMq简单使用

1.引入依赖

    <!--spirngboot集成rabbitmq-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>

2.yml配置

spring:
  rabbitmq:
    host: ${RABBIT_MQ_HOST:xxx.xxx.xxx}
    port: ${RABBIT_MQ_PORT:xxxx}
    username: ${RABBIT_MQ_USERNAME:xxxx}
    password: ${RABBIT_MQ_PASSWORD:xxxx}
    virtual-host: /    #类似于mysql的库
    listener:          
      direct:          #容器模型
        acknowledge-mode: MANUAL
      simple:
        acknowledge-mode: MANUAL
        retry:        #重试
          enabled: true
          max-attempts: 3
    publisher-confirms: true   #确认机制
    publisher-returns: true

如果紧使用简单的功能，那么可以省略virtual-host以下的部分

3.申明队列

    //声明队列：针对于转码的队列
    @Bean(QUEUE_WORKQUEUE_TRANSCODE)
    public Queue QUEUE_WORKQUEUE_TRANSCODE() {
        Queue queue = new Queue(QUEUE_WORKQUEUE_TRANSCODE,true,false,false);
        //参数为队列，持久化，排他性，自动删除
        return queue;
    }

使用默认交换机。所以不用申明交换机和绑定

4.发送消息和消息消费

rabbitTemplate.convertAndSend("交换机(不写为默认交换机)", "队列名", 
					"消息体",
					new CorrelationData(aiTask.getId())); // 可省略，确认机制使用

	@RabbitListener(queues = "队列名")
    public void handleMessage(byte[] message){
        System.out.println("消费消息");
        System.out.println(new String(message));
    }

三 rabbitmq高级使用

两种方式，使用container容器，使用注解@RabbitListener指定容器工厂

1.SimpleMessageListenerContainer

@Bean
    public SimpleMessageListenerContainer AiTaskListenerContainer() {
        SimpleMessageListenerContainer container = new  SimpleMessageListenerContainer(cachingConnectionFactory);
        // 监听队列名
        container.setQueueNames(AiMqConfig.QUEUE_WORK_AI_TASK);
        // 当前消费者数量 开启几个线程去处理数据 支持运行时动态修改
        container.setConcurrentConsumers(5);
        // 最大消费者数量  ,  消息堵塞太多的时候，会帮我自动扩展到我的最大消费者数量
        container.setMaxConcurrentConsumers(10);
        // 是否重回队列
        container.setDefaultRequeueRejected(true);
        // 手动确认
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        // 设置监听器
        container.setMessageListener(new ChannelAwareMessageListener(){
            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                // 消息的唯一性ID deliveryTag:该消息的index 自增长
                long deliveryTag = message.getMessageProperties().getDeliveryTag();
                String id  = "";
                try {
                    String msg = message.toString();
                    byte[] messageBody = message.getBody();
                    String s = new String(messageBody);
                    AiMqMessageVo mqMessageVo = JSONObject.parseObject(s, AiMqMessageVo.class);
                    System.out.println("消息: " + msg);
                    System.out.println("消息来自: "+message.getMessageProperties().getConsumerQueue());
                    System.out.println(mqMessageVo);
                    // 同一时刻服务器只会发一条消息给消费者,能者多劳模式
                    channel.basicQos(1);
                    // 手动确认
                    channel.basicAck(deliveryTag, true);
                } catch (Exception e) {
                    // 拒绝策略
                    //basicReject一次只能拒绝接收一个消息，而basicNack方法可以支持一次0个或多个消息的拒收，并且也可以设置是否requeue。
                    channel.basicReject(deliveryTag, false); //是否批量 false
                              System.out.println("签收失败");
                }
            }
        });
        return container;
    }

2.@RabbitListener

@Configuration
public class RabbitMQConfig {
    public static final String QUEUE_WORK_AI_TASK = "queue_work_ai_task";
    // 声明交换机
    // 声明队列
	@Bean("AIContainerFactory")
	public SimpleRabbitListenerContainerFactory containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, 
		ConnectionFactory connectionFactory) {
   		SimpleRabbitListenerContainerFactory container= new SimpleRabbitListenerContainerFactory();
   		container.setConcurrentConsumers(5);
   		container.setMaxConcurrentConsumers(10);
  		configurer.configure(factory, connectionFactory);
  		// 是否重回队列
        container.setDefaultRequeueRejected(true);
        // 手动确认
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
   		return factory;
 	}
 }

@Component
public class ReceiveHandler {
    private static final Logger LOGGER = LoggerFactory.getLogger(ReceiveHandler.class);
    // 在@RabbitListener注解中指定容器工厂
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_WORK_AI_TASK },
                    containerFactory = "AIContainerFactory")
   //@RabbitListener(queues = {MqConstants.OA_TAB_REFRESH}, concurrency = "10") 也能实现十个并发
    public void aiTask(String msg,Message message,Channel channel){
        LOGGER.info("receive message is:"+msg);
    }
}

3.手动确认机制

在rabbitmqconfig中添加确认机制，所以在发送消息时，要添加消息的id作为唯一标识

//消息发送确认模式  ConfirmCallback确认模式
    @PostConstruct
    public void initRabbitTemplate(){
        /**
         * @param correlationData  当前消息的唯一关联数据  ，这个是消息的唯一id
         * @param ack 消息是否成功收到
         * @param cause 失败原因
         */
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (!ack){
                    //修改数据库
                    aiTaskService.update(new UpdateWrapper<AiTask>()
                            .eq("id",correlationData.getId())
                            .set("cause",cause)
                            .set("state", AiTask.AI_WORK_FAILURE));
                }
            }
        });
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * 只要消息没有投递给指定的队列，就会触发这个失败回调
             * @param message   投递失败的消息
             * @param replyCode  回复的状态码
             * @param replyText  回复的文本内容
             * @param exchange  消息发送的交换机
             * @param routingKey  消息走的路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                //修改数据库
                String s = new String(message.getBody());
                AiMqMessageVo aiMqMessageVo = JSONObject.parseObject(s, AiMqMessageVo.class);
                aiTaskService.update(new UpdateWrapper<AiTask>()
                        .eq("id",aiMqMessageVo.getId())
                        .set("cause","未成功投递给指定队列。信息 - > 状态码:"+replyCode + " 文本内容:"+replyText  + "  交换机:"+exchange  + "  路由:"+routingKey)
                        .set("state", AiTask.AI_WORK_FAILURE));
            }
        });
    }

总结

写这些代码已经过去一两个月了，回看一下也有点蒙蔽，有很多不足的地方,代码也是以我目前做的项目来的，一些变量名可以换成你自己的变量名，主要是理清思路。一些难理解的地方，我已经做了详细的注释，不懂可以再次百度。

满小超的代码世界
关注
  • 1
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合RabbitMQ
java小白翻身
04-07 1199
我们就以平时常见的商品购买为例，订单下完了，需要通知发货，我们就可以使用消息队列对其进行解耦。这边我们就定义订单队列。代码概览如下图所示@Bean@Bean//创建队列构造器并指定队列名称//如果队列持久化,这边不用设置队列过期时间//设置死信队列的RouteKey//设置死信队列的Exchange//创建队列。
springboot+rabbitmq两小时入门（二）：消费者多线程
leo的博客
08-09 1万+
概要： 消费一条消息往往比产生一条消息慢很多，为了防止消息积压，一般需要开启消费者多线程同时消费消息。 application.properties配置： spring.rabbitmq.host=localhost # TCP/IP端口为5672，http端口为15672 spring.rabbitmq.port=5672 spring.rabbitmq.username=ro...
RabbitMQ之消费者并发消费
最新发布
CSDN_LiMingfly的博客
05-01 803
当生产者的推送速度是远远超过消费者的能力的，可以提高消费者的消费速度。比如在java中我们可以启动多个 JVM 进程，实现多进程的并发消费，从而加速消费的速度，在mq中也可以通过设置配置。Consumer 线程，负责从 RabbitMQ Broker 获取 Queue 中的消息，存储到内存中的 BlockingQueue 阻塞队列中。@RabbitListener 注解中，有 concurrency 属性，它可以指定并发消费的线程数。若需完整代码 可识别二维码后 给您发代码。
RabbitMQ配置多线程消费
一起coding，一起嗨。
04-04 2809
【代码】RabbitMQ配置多线程消费。
RabbitMQ实现多线程消费
weixin_42324471的博客
11-28 4521
本文实现多线程消费，其实原理就在同一个项目中建立多个@RabbitListener(queues = RabbitMqQueueConfig.FANOUT_EMAIL_QUEUE)，多个消费者处理统一队列中的消息 其利用RabbitMq中SimpleRabbitListenerContainerFactory建立多个同一队列的监听连接 @Configuration public class RabbitConsumerConfig { //并发数量 public static final i
RabbitMQ设置多线程处理队列消息
Kaysen_7
05-17 6265
@RabbitListener注解指定消费方法，默认是单线程监听队列，可以观察当队列有多个任务时消费端每次只消费一个消息，单线程处理消息容易引起消息处理缓慢，消息堆积，不能最大利用硬件资源 可以配置mq的容器工厂参数，增加并发处理数量即可实现多线程处理监听队列，实现多线程处理消息。 1、RabbitmqConfig.java中添加容器工厂配置： @Bean("customContainerFac...
RabbitMQ实现(并发)多线程处理消息
weixin_45711444的博客
10-05 9882
@RabbitListener默认是单线程监听队列 缺点: 当消息队列有多个任务时消费端监听队列每次只消费一个消息 , 容易引起消息堆积 , 处理效率慢… 解决方法 : 配置mq容器工厂参数 , 增加并发处理量 , 多线程处理消息 . @Configuration public class RabbitMQConfig { public static final String QUEUE...
RabbitMQ消费者多线程
PowerJ的博客 希望对你有帮助
01-18 8445
RabbitMQ并发起因通过注解并发配置工厂的时候设置并发 起因 项目中有一个业务需要先把数据从接口入到原始表，再通过MQ机制，让业务处理程序监听并处理。跑了几天以后发现有大量消息堆积，通过rabbitmq控制台看到Ready了几万条数据，Pulish是3/s左右，但Consumer ack则1/s左右，代码分析后发现有很多mysql的查询操作，但是优化起来比较有难度，于是考虑到消息并发处理 通过注解并发 搜了一些方法，最多的就是在RabbitListeners注解上加上concurrency属性 @Ra
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
SpringBoot集成RabbitMQ的方法是指使用SpringBoot框架集成RabbitMQ消息队列的方法，RabbitMQ是一种基于AMQP协议的开源消息队列软件。该方法可以实现消息的异步处理，提高系统的可扩展性和可靠性。 在SpringBoot中...
SpringBoot集成RabbitMQ实现用户注册的示例代码
08-25
本文主要介绍了使用SpringBoot集成RabbitMQ实现用户注册的示例代码，通过详细的示例代码，帮助读者学习和工作。该示例代码介绍了如何使用RabbitMQ实现用户注册功能，提供了详细的实现步骤和代码示例。 SpringBoot...
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
SpringBoot之RabbitMQ的使用方法
08-26
SpringBoot之RabbitMQ的使用方法 RabbitMQ是消息中间件的一种，消息中间件即分布式系统中完成消息的发送和接收的基础软件，消息中间件的工作过程可以用生产者消费者模型来表示。即，生产者不断的向消息队列发送信息...
springboot集成rabbitMQ之对象传输的方法
08-28
本文将详细介绍 Spring Boot 集成 RabbitMQ 之对象传输的方法，从 RabbitMQ 的安装、依赖配置、生产者配置、消费者配置等方面进行讲解，并结合实例代码进行说明。 一、RabbitMQ 的安装 RabbitMQ 的安装方法网上有...
springboot集成rabbitMQ-消费者
sinat_34397278的博客
10-16 3913
springboot集成rabbitmq消费者，使用注解和template类进行消费
工作随笔——rabbitmq的多线程监听（Springboot）
TIANQIcode
10-21 3611
一、需求 使用rabbitmq转发大量消息，提高效率。由于springboot中rabbitmq是单线程监听，所以需要我们加以配置。 二、方案 配置rabbitmq多线程监听，提供SimpleRabbitListenerContainerFactory类的bean，为数据量大的队列指定这个bean。 设置多线程批量处理。在任意配置类中，提供这个bean。 // 配置批量监听容器 @Bean("batchQueueRabbitListenerContainerFactory") pub
SpringBoot整合RabbitMQ并实现生产消费
是云猿实战
11-02 1827
首先项目开源地址：https://gitee.com/shenzhanwang/Spring-rabbitMQ 大佬写的非常NICE，很适合参考学习，赞不绝口啊，很适合对RabbitMQ入门实战。 这里对该项目进行一个简单的学习总结。 项目简介 该项目实现了SpringBoot框架下整合RabbitMQ，并且对四种生产消费模式做了可视化页面进行测试，同时还配备相关的图解，对新手十分友好，代码通俗易懂，部署运行起来也非常简单！ 四种生成消费模式如下： ①生产者消费者模型 生产者生产消息到队列，然后消费者直接从
spring rabbitmq为listener配置并发消费者数量
热门推荐
tszxlzc的专栏
03-30 5万+
我们的项目原来插入队列的消息相对少，随着插入队列消息的不断增多，发现队列中消息堆积越来越多，最多时高大30多万条。 寻找问题瓶颈在于队列消费者比较少，每个监听器只有一个消费者，当队列消费的速度小于队列生产者插入队列中消息个数时就造成了队列消息堆积。 通过设置listener-container的concurrency属性来设置消费者并发数
Springboot+rabbitmq如何实现高并发的rpc调用
CSDNOFZHC的博客
03-02 1万+
2019年5月最新更新：注意！并不推荐RPC式的mq调用，这么做完全没有发挥mq异步削峰的作用。之所以会有这篇文章完全是因为架构无法更改。 RPC式的mq调用，会使调用端的线程一直阻塞，中间还过了一层mq。虽然仍旧是rpc式的通信，但是效果还不如dubbo，建议需要同步的业务直接使用dubbo。 2018年8月： 一.背景 公司项目的收单前置服务A与收单服务B之间是通过ra...
springboot rabbitmq使用 springboot rabbitmq使用 springboot集成rabbitmq一对多
07-09
Spring Boot集成RabbitMQ可以通过以下步骤完成： 1. 添加Maven依赖：在pom.xml文件中添加RabbitMQ的Spring Boot Starter依赖。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置RabbitMQ连接信息：在application.properties（或application.yml）文件中配置RabbitMQ的连接信息。 ```properties spring.rabbitmq.host=your_rabbitmq_host spring.rabbitmq.port=your_rabbitmq_port spring.rabbitmq.username=your_rabbitmq_username spring.rabbitmq.password=your_rabbitmq_password ``` 3. 创建RabbitMQ发送者：创建一个发送消息的类，使用`RabbitTemplate`发送消息到指定的交换机和队列。 ```java import org.springframework.amqp.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class RabbitMQSender { @Autowired private RabbitTemplate rabbitTemplate; public void sendMessage(String exchange, String routingKey, Object message) { rabbitTemplate.convertAndSend(exchange, routingKey, message); } } ``` 4. 创建RabbitMQ接收者：创建一个接收消息的类，使用`@RabbitListener`注解监听指定的队列，处理接收到的消息。 ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class RabbitMQReceiver { @RabbitListener(queues = "your_queue_name") public void receiveMessage(Object message) { // 处理接收到的消息 System.out.println("Received message: " + message.toString()); } } ``` 5. 发送和接收消息：在需要发送或接收消息的地方调用对应的方法。 ```java @Autowired private RabbitMQSender rabbitMQSender; public void sendMessage() { rabbitMQSender.sendMessage("your_exchange_name", "your_routing_key", "Hello, RabbitMQ!"); } ``` 以上是基本的使用方式，你可以根据实际需求进行扩展和配置。注意，你还需要安装并启动RabbitMQ服务。 希望对你有所帮助！如果有任何疑问，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值