SpringBoot整合RabbitMQ

置顶 已于 2023-06-28 11:48:26 修改
阅读量1k 收藏 2
点赞数
分类专栏： 技术栈 文章标签： RabbitMQ 队列 rabbitmq spring boot
于 2023-06-28 11:32:20 首次发布
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_34833599/article/details/82931347
版权

SpringBoot整合RabbitMQ

Docker 搭建 RabbitMQ

  1. 拉取 RabbitMQ 的镜像执行命令 docker pull rabbitmq:3.7-management
  2. 执行运行命令 docker run -d --hostname rabbit --name rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 rabbitmq:3-management
  3. 打开浏览器访问 http://localhost:15672 ，账号：admim, 密码: admin

RabbitMQ 消息类型

Topic

topic 既可以实现 direct，也可实现 Fanout，topic 通过 routing*key 进行路由，key 可以存在两种特殊字符“ * ”与“#”，用于做模糊匹配，其中“_”用于匹配一个单词，“#”用于匹配多个单词（可以是零个） *代表全部的

SpringBoot 整合

通过编写基本配置类，实现交换器和路由器绑定，和实现配置手动确认等，需要实现 RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback 接口，实现接口的方法，还需设置配置文件。

基本配置类

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

/**
 * @ClassName RabbitConfig
 * @Author zhangjiahao
 * @Description RabbitMQ基本配置类
 * @Date $ $
 **/
@Configuration
@Slf4j
public class RabbitConfig implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private CachingConnectionFactory connectionFactory;

    @PostConstruct
    public void init(){
        System.out.println("初始化rabbitmq");
        rabbitTemplate.setConfirmCallback(this);            // 指定 ConfirmCallback
        rabbitTemplate.setReturnCallback(this);             // 指定 ReturnCallback
    }

    /**
     * 如果消息到达 exchange, 则 confirm 回调, ack = true
     * 如果消息不到达 exchange, 则 confirm 回调, ack = false
     * 需要设置spring.rabbitmq.publisher-confirms=true
     * @param correlationData
     * @param ack
     * @param cause
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        Message returnedMessage = correlationData.getReturnedMessage();
        if (ack){
            System.out.println("消息是否到达Exchange:{}" +  "消息成功到达Exchange");
        }else {
            System.out.println("消息是否到达Exchange:{}" + "消息到达Exchange失败");
        }

        if (!ack) {
            System.out.println("消息到达Exchange失败原因:{}"+ cause);
            // 根据业务逻辑实现消息补偿机制

        }
    }

    /**
     * exchange 到达 queue, 则 returnedMessage 不回调
     * exchange 到达 queue 失败, 则 returnedMessage 回调
     * 需要设置spring.rabbitmq.publisher-returns=true
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {

        log.error("queuec处理失败");
        System.out.println("消息报文:{}"+ new String(message.getBody()));
        System.out.println("消息编号:{}"+ replyCode);
        System.out.println("描述:{}"+ replyText);
        System.out.println("交换机名称:{}"+exchange);
        System.out.println("路由名称:{}"+ routingKey);

        // 根据业务逻辑实现消息补偿机制
    }

    @Bean(name = "consumerlistenerContainer")
    public SimpleRabbitListenerContainerFactory mqConsumerlistenerContainer(){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setConcurrentConsumers(2);
        factory.setMaxConcurrentConsumers(3);
        factory.setPrefetchCount(5);
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        return factory;
    }

}

实现 Direct 队列

Direct 配置类

import io.renren.modules.generator.constant.MQConstant;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author zhangjiahao
 * @description DirectRabbitConfig
 * @date 2020-03-23 23:03:21
 */
@Configuration
public class DirectRabbitConfig {

    //队列 起名：TestDirectQueue
    @Bean
    public Queue directQueue() {
        return new Queue(MQConstant.MQQueueAndExchange.DIRECT_QUEUE, true);  //true 是否持久
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange directExchange() {
        return new DirectExchange(MQConstant.MQQueueAndExchange.DIRECT_QUEUE_EXCHANGE);
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(MQConstant.MQQueueAndExchange.DIRECT_QUEUE_ROUTING_KEY);
    }
}

实现 Fanout 队列

Fanout 配置类

import io.renren.modules.generator.constant.MQConstant;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @ClassName FanoutRabbitConfig
 * @Author zhangjiahao
 * @Description //TODO $
 * @Date $ $
 **/
@Configuration
public class FanoutRabbitConfig {

    @Bean
    public Queue fanoutQueue(){
        return new Queue(MQConstant.MQQueueAndExchange.FANOUT_QUEUE);
    }

    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(MQConstant.MQQueueAndExchange.FANOUT_QUEUE_EXCHANGE);
    }

    @Bean
    public Binding fanoutBinding(){
        return BindingBuilder.bind(fanoutQueue()).to(fanoutExchange());
    }
}

实现 Topic 队列

Topic 配置类

import io.renren.modules.generator.constant.MQConstant;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @ClassName TopicRabbitConfig
 * @Author zhangjiahao
 * @Description //TODO $
 * @Date $ $
 **/
@Configuration
public class TopicRabbitConfig {

    @Bean
    public Queue topicQueue(){
        return new Queue(MQConstant.MQQueueAndExchange.TOPIC_QUEUE);
    }

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(MQConstant.MQQueueAndExchange.TOPIC_QUEUE_EXCHANGE);
    }

    @Bean
    public Binding topicBinding(){
        return BindingBuilder.bind(topicQueue()).to(topicExchange()).with(MQConstant.MQQueueAndExchange.TOPIC_QUEUE_ROUTING_KEY);
    }
}

配置文件 yml

spring:
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: 127.0.0.1
    port: 5672
    ## 手动确认
    publisher-confirms: true
    publisher-returns: true

编写消费者

消费端的代码基本一致，所以写个 Topic 的代码模板。

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.rabbitmq.client.Channel;
import io.renren.modules.generator.constant.MQConstant;
import io.renren.modules.generator.entity.BrokerMessageLogEntity;
import io.renren.modules.generator.entity.SysMessageEntity;
import io.renren.modules.generator.service.BrokerMessageLogService;
import io.renren.modules.generator.service.SysMessageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Date;
import java.util.Map;

/**
 * @ClassName TopicConsumer
 * @Author zhangjiahao
 * @Description //TODO $
 * @Date $ $
 **/
@Slf4j
@Component
public class TopicConsumer {

    @Autowired
    private SysMessageService sysMessageService;
    @Autowired
    private BrokerMessageLogService brokerMessageLogService;

    @RabbitHandler
    @RabbitListener(queues = "topic_queue",containerFactory = "consumerlistenerContainer")
    public void topicConsumer(SysMessageEntity msg, Channel channel, Message message) throws IOException {
        System.out.println(msg.toString());
        BrokerMessageLogEntity one =
                brokerMessageLogService.getOne(new QueryWrapper<BrokerMessageLogEntity>().lambda().eq(BrokerMessageLogEntity::getMessageId, msg.getMessageId()).eq(BrokerMessageLogEntity::getStatus, 0));
        if (one == null) {
            one = new BrokerMessageLogEntity();
            one.setCreateTime(msg.getGmtCreate());
            one.setUpdateTime(msg.getGmtModified());
            one.setStatus("0");
            one.setMessageId(msg.getMessageId());
            one.setMessage(JSON.toJSONString(msg));
            one.setTryCount(MQConstant.MQ_TRY_COUNT);
            one.setNextRetry(new Date(System.currentTimeMillis() + MQConstant.MQ_TIME_SPACE));
        }
        try {
            log.info("正常处理数据，{}", msg);
            //处理完成 消息设置为已处理
            msg.setState(1);
            sysMessageService.updateById(msg);
            // MQ日志状态已处理
            one.setStatus("4");
            brokerMessageLogService.saveOrUpdate(one);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        } catch (Exception e) {
            if(one.getTryCount()<1){
                log.error("已超过尝试次数，在此失败{}",msg);
                msg.setState(-1);
                sysMessageService.updateById(msg);
                one.setStatus("-1");
                brokerMessageLogService.updateById(one);
                channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
            }
            // 消息重新放回队列
            try {
                one.setTryCount(one.getTryCount() - 1);
                one.setNextRetry(new Date(System.currentTimeMillis() + MQConstant.MQ_TIME_SPACE));
                brokerMessageLogService.updateById(one);
                System.out.println("消息[{}]处理失败，重新放回队列" + msg);
                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
                e.printStackTrace();
            } catch (IOException ex) {
                log.error("消费失败,{}", msg);
                ex.printStackTrace();
            }

        }
    }
}

这里其他的 service 是用于记录 RabbitMQ 的日志，用于处理投递失败和消费失败的情况。

编写测试的生产者

@GetMapping("direct")
public R direct() {
    for (int i = 0; i < 11; i++) {
        SysMessageEntity sysMessageEntity = new SysMessageEntity();
        sysMessageEntity.setCreator("1");
        sysMessageEntity.setGmtCreate(new Date());
        sysMessageEntity.setGmtModified(new Date());
        sysMessageEntity.setMessageId(snowFlake.nextId() + "");
        sysMessageEntity.setModifier("1");
        sysMessageEntity.setName("测试消费direct-" + i);
        sysMessageEntity.setType(0);
        sysMessageEntity.setState(0);
        CommonCorrelationData commonCorrelationData = new CommonCorrelationData();
        commonCorrelationData.setId(sysMessageEntity.getMessageId());
        commonCorrelationData.setData(sysMessageEntity);
        sysMessageService.save(sysMessageEntity);
        rabbitTemplate.convertAndSend(MQConstant.MQQueueAndExchange.DIRECT_QUEUE_EXCHANGE,
                MQConstant.MQQueueAndExchange.DIRECT_QUEUE_ROUTING_KEY, sysMessageEntity,commonCorrelationData);

    }
    return R.ok();
}

@GetMapping("/fanout")
public R fanout() {
    for (int i = 0; i < 11; i++) {
        SysMessageEntity sysMessageEntity = new SysMessageEntity();
        sysMessageEntity.setCreator("1");
        sysMessageEntity.setGmtCreate(new Date());
        sysMessageEntity.setGmtModified(new Date());
        sysMessageEntity.setMessageId(snowFlake.nextId() + "");
        sysMessageEntity.setModifier("1");
        sysMessageEntity.setName("测试消费fanout-" + i);
        sysMessageEntity.setType(0);
        sysMessageEntity.setState(0);
        sysMessageService.save(sysMessageEntity);
        rabbitTemplate.convertAndSend(MQConstant.MQQueueAndExchange.FANOUT_QUEUE_EXCHANGE,
                MQConstant.MQQueueAndExchange.FANOUT_QUEUE_ROUTING_KEY, sysMessageEntity);
    }
    return R.ok();
}

@GetMapping("topic")
public R topic() {
    for (int i = 0; i < 11; i++) {
        SysMessageEntity sysMessageEntity = new SysMessageEntity();
        sysMessageEntity.setCreator("1");
        sysMessageEntity.setGmtCreate(new Date());
        sysMessageEntity.setGmtModified(new Date());
        sysMessageEntity.setMessageId(snowFlake.nextId() + "");
        sysMessageEntity.setModifier("1");
        sysMessageEntity.setName("测试消费topic-" + i);
        sysMessageEntity.setType(0);
        sysMessageEntity.setState(0);
        sysMessageService.save(sysMessageEntity);
        rabbitTemplate.convertAndSend(MQConstant.MQQueueAndExchange.TOPIC_QUEUE_EXCHANGE,
                MQConstant.MQQueueAndExchange.TOPIC_QUEUE_ROUTING_KEY, sysMessageEntity);

    }
    return R.ok();
}

关于 RabbitMQ 的 UI 界面设置

基本页面1

自定义 CorrelationData

因为 MQ 完全监控的原因，可以通过手动确认来处理投递失败的。

 /**

      * 如果消息到达 exchange, 则 confirm 回调, ack = true
      * 如果消息不到达 exchange, 则 confirm 回调, ack = false
      * 需要设置spring.rabbitmq.publisher-confirms=true
      * @param correlationData
      * @param ack
      * @param cause

      */
     @Override
     public void confirm(CorrelationData correlationData, boolean ack, String cause) {
         Message returnedMessage = correlationData.getReturnedMessage();
         if (ack){
             System.out.println("消息是否到达Exchange:{}" +  "消息成功到达Exchange");
         }else {
             System.out.println("消息是否到达Exchange:{}" + "消息到达Exchange失败");
         }

         if (!ack) {
             System.out.println("消息到达Exchange失败原因:{}"+ cause);
             // 根据业务逻辑实现消息补偿机制

         }
     }

通过重写 CorrelationData 来实现完全的监控。

 public class CorrelationData implements Correlation {
     private final SettableListenableFuture<CorrelationData.Confirm> future = new SettableListenableFuture();
     @Nullable
     private volatile String id;
     private volatile Message returnedMessage;

     public CorrelationData() {
     }

     public CorrelationData(String id) {
         this.id = id;
     }

     @Nullable
     public String getId() {
         return this.id;
     }

     public void setId(String id) {
         this.id = id;
     }

     public SettableListenableFuture<CorrelationData.Confirm> getFuture() {
         return this.future;
     }

     @Nullable
     public Message getReturnedMessage() {
         return this.returnedMessage;
     }

     public void setReturnedMessage(Message returnedMessage) {
         this.returnedMessage = returnedMessage;
     }

     public String toString() {
         return "CorrelationData [id=" + this.id + "]";
     }

     public static class Confirm {
         private final boolean ack;
         private final String reason;

         public Confirm(boolean ack, @Nullable String reason) {
             this.ack = ack;
             this.reason = reason;
         }

         public boolean isAck() {
             return this.ack;
         }

         public String getReason() {
             return this.reason;
         }

         public String toString() {
             return "Confirm [ack=" + this.ack + (this.reason != null ? ", reason=" + this.reason : "") + "]";
         }
     }
 }

参考

RabbitMQ 消息路由机制流程总结

九夏lb
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合RabbitMQ——Topic 交换机
SK_Jaco的博客
07-17 1702
文章目录SpringBoot整合RabbitMQ——Topic交换机简介依赖application.yml配置消息生产者（发送端）SendConfig.java配置信息Controller层Service层消费者（接收端）测试 SpringBoot整合RabbitMQ——Topic交换机 简介 Topic交换机与Direct相似，通过与交换机绑定队列的路由键进行消息分发。不同的是Topic可以通过......
RabbitMQ---SpringBoot整合RabbitMQ(Topic交换器)
m0_67393828的博客
03-28 1847
Topic交换器特点： 各个队列与Topic交换器之间的路由键配置模糊，发送者发送一条消息，只要路由键符合规则的队列就能接收到消息。 创建消息生产者module：配置交换器名称和路由键信息。消息发送时，需要指定交换器和路由键。 pom.xml导入RabbitMQ坐标 <dependency> ?? ?<groupId>org.springframework.boot</groupId> ?? ?<artifactId>spring-boot-starter-
MQ如何保证可靠性
最新发布
m0_62645012的博客
05-06 1529
数据持久化和消费者的可靠性
springBoot集成rabbitMQ topic模式
ChenLong_0317的博客
05-31 2410
大家好 最近在学习rabbitMQ 的时候发现topic模式挺有意思的，贴出来学习过程和打架分享一下，希望一起学习交流和成长 首先pom.xml写入mq的maven <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star...
rabbitmq+topic+java_spring整合rabbitMq之topic模式
weixin_39598941的博客
02-27 86
说明：此模式实在路由key模式的基础上，使用了通配符来管理消费者接收消息。生产者P发送消息到交换机X，type=topic，交换机根据绑定队列的routing key的值进行通配符匹配；符号#：匹配一个或者多个词cn.# 可以匹配cn.新闻或者cn.新闻.国内新闻符号*：只能匹配一个词cn.* 可以匹配cn.新闻或者us.新闻1、maven依赖org.springframework.amqp...
RabbitMQ消息的可靠投递
Knight
03-28 620
其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。如果出现异常，则在catch中调用 basicNack，拒绝消息，让MQ重新发送消息。4.队列和交互机绑定。
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springBoot整合RabbitMQ案例
04-07
springBoot整合RabbitMQ案例
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springboot整合RabbitMQ
11-04
springboot整合RabbitMQ,测试实现Queue队列使用，Exchange交换器的基本使用。
Springboot整合RabbitMQ简单demo
01-22
Springboot整合RabbitMQ最简单demo
springBoot使用rabbitmq并保证消息可靠性
卷心菜投手
01-04 2610
1、rabbitmq在springboot中使用 2、rabbitmq数据可靠性投递
RabbitMQ可靠性投递
渡灬魂的博客
07-04 877
RabbitMQ可靠性投递
RabbitMQ-消息的可靠性投递实现方案
aileitianshi的博客
04-28 443
保障100%的消息可靠性投递方案落地实现 保障100%消息投递成功设计方案(一) 蓝色区域: 生产者 红色区域: broker(MQ服务) 总共有7个步骤 第一步: 存储业务数据(订单), 存储MQ消息记录(MQ日志) 第二步: 发送确认类型的MQ消息到broker 第三步: 监听该结果, broker收到消息,返回(应答)确认收到 第四步: 操作MQ消息记录表做状态更新(0消息发送中,1消息发送成功,2消息发送失败) 如果没有收到第三步的确认则会有定时任务定时轮询 第五步: 定时任务获取状态为0的消息,
三、RabbitMQ消息的可靠投递
qq_49723651的博客
11-06 1344
自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。生产者端在向Broker发送消息的时候，我们使用一个无缓冲的通道来接收来自Broker的回复，然后创建一个协程监听这个无缓冲通道。，即队列发送消息给消费者的时候，不再采用轮询机制，而是一个消费者消费完消息之后，会调用。在编码中，关于消息的确认方式，我们需要在消费者端调用。
五、Rabbitmq消息可靠性投递实践
ITCloud
10-17 1173
思路：将投递失败的消息存入数据库，利用定时任务去定时重试发送消息，重试三次，如果三次都无法投递的话，这时候需要人工干预，去处理消息为什么没有能够投递成功 1. 基础配置 SpringBoot版本：2.0.3 sql create table if not exists rabbit.msg_broker ( id int auto_increment primary key, retr...
RabbitMQ（10）RabbitMQ高级特性：消息可靠投递
учёба
01-25 218
消息可靠投递 在使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 rabbitmq整个消息投递的路径为: produer—> rabbitmq broker—> exchange—> queue—> consumer 消息从producer到exchange则会返回一个confirmCallback。 消息从exch
RabbitMq-进阶-03-消息的可靠投递
Echo
01-01 811
1、1 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。 RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 rabbitmq 整个消息投递的路径为： producer--->rabbitmq broker--->exchange--->queue--->consumer 1、2 confirm 确认模式 消息从 producer 到 exchange 则会返回一个 confirmCallback 。
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3625
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
springboot 整合rabbitmq
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值