RabbitMQ

最新推荐文章于 2023-08-16 14:39:23 发布
最新推荐文章于 2023-08-16 14:39:23 发布
阅读量820 收藏
点赞数
分类专栏： 中间件 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq15347747/article/details/126983698
版权

MQ

1. 简介

1.1 什么是消息队列

我们可以把消息队列看作是一个存放消息的容器，当我们需要使用消息的时候，直接从容器中取出消息供自己使用即可。

1.2 为什么要用消息队列

通常来说，使用消息队列能为我们的系统带来下面三点好处：

  1. 通过异步处理提高系统性能（减少响应所需时间）。
  • 扣减库存、记录日志等异步操作
  1. 削峰/限流
  • 上游大量的请求存放到队列中，下游从队列取数据
  1. 降低系统耦合性。
  • 增加业务功能订阅队列即可，取消功能 取消订阅即可。

因为用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败。因此，使用消息队列进行异步处理之后，需要适当修改业务流程进行配合，比如用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功，以免交易纠纷。

broker事件代理者

支付完成后，订单等其他服务就会异步执行，不会影响用户的体验

1.3 存在的问题

  • 系统可用性降低： 系统可用性在某种程度上降低，为什么这样说呢？在加入 MQ 之前，你不用考虑消息丢失或者说 MQ 挂掉等等的情况，但是，引入 MQ 之后你就需要去考虑了！
  • 系统复杂性提高： 加入 MQ 之后，你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题！
  • 一致性问题： 我上面讲了消息队列可以实现异步，消息队列带来的异步确实可以提高系统响应速度。但是，万一消息的真正消费者并没有正确消费消息怎么办？这样就会导致数据不一致的情况了!

2. 什么是MQ

MQ(MessageQueue),中文是消息队列,字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

怎么选？

  • 大量数据，要求不高：日志记录
  • 大型企业要定制：RocketMQ
  • 普通企业，要求可靠性：RabbitMQ

2.1 为啥叫消息队列

首先我问一个问题，消息队列为什么要叫消息队列？

你可能觉得很弱智，这玩意不就是存放消息的队列嘛？不叫消息队列叫什么？

的确，早期的消息中间件是通过 队列 这一模型来实现的，可能是历史原因，我们都习惯把消息中间件成为消息队列。

这里涉及到了两种模型：队列模型 主题模型

2.1.1 队列模型

就像我们理解队列一样，消息中间件的队列模型就真的只是一个队列

“广播” 的概念，也就是说如果我们此时我们需要将一个消息发送给多个消费者(比如此时我需要将信息发送给短信系统和邮件系统)，这个时候单个队列即不能满足需求了。

当然你可以让 Producer 生产消息放入多个队列中，然后每个队列去对应每一个消费者。问题是可以解决，创建多个队列并且复制多份消息是会很影响资源和性能的。

2.1.2 主题模型

有，那就是 主题模型 或者可以称为 发布订阅模型 。

在主题模型中，消息的生产者称为 发布者(Publisher) ，消息的消费者称为 订阅者(Subscriber) ，存放消息的容器称为 主题(Topic) 。

其中，发布者将消息发送到指定主题中，订阅者需要 提前订阅主题 才能接受特定主题的消息。

RocketMQ 中的消息模型就是按照 主题模型 所实现的。你可能会好奇这个 主题 到底是怎么实现的呢？你上面也没有讲到呀！

其实对于主题模型的实现来说每个消息中间件的底层设计都是不一样的，就比如 Kafka 中的 分区 ，RocketMQ 中的 队列 ，RabbitMQ 中的 Exchange 。我们可以理解为 主题模型/发布订阅模型 就是一个标准，那些中间件只不过照着这个标准去实现而已。

3. 部署

mq的docker镜像

pull

docker pull rabbitmq:3-management

或者直接下载

链接：https://pan.baidu.com/s/1C-hW4BiEc4WoQA_PPzXl2g?pwd=3bav
提取码：3bav

docker load -i mq.tar

3.1 启动MQ

docker run \
 -e RABBITMQ_DEFAULT_USER=aguomq \
 -e RABBITMQ_DEFAULT_PASS=1314520 \
 --name mq \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3-management

3.2 可视化页面

之后可以打开 http://aguo.pro:15672来查看

  • 连接
    • 包含所有的连接，如生产者与消费者的连接信息。
  • 交换机
    • 负责提交消息给队列
  • 队列
    • 存放的任务等
  • 管理
    • 包含用户管理、虚拟主机管理

虚拟主机，对于不同用户使用同一个rabbitmq实现不同的业务功能时使用，起到隔离作用。

结果图如下

3.3 概念

  • channel:操作MQ的工具
  • exchange:路由消息到队列中
  • queue:缓存消息
  • virtual host:虚拟主机,是对queue、exchange等资源的泛辑分组

4. 常见消息模型

官网给出的消息模型

4.1 基本模型

基本消息队列（BasicQueue）

工作消息队列(WorkQueue)

4.1.1 HelloWord案例

官方的HelloWorld是基于最基础的消息队列模型来实现的,只包括三个角色:

  • publisher:消息发布者,将消息发送到队列queue
  • queue:消息队列,负责接受并缓存消息
  • consumer:订阅队列,处理队列中的消息

发布者

public static void main(String[] args) throws IOException, TimeoutException {
    // 1.建立连接
    ConnectionFactory factory = new ConnectionFactory();
    // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
    factory.setHost("aguo.pro");
    factory.setPort(5672);
    factory.setVirtualHost("/");
    factory.setUsername("aguomq");
    factory.setPassword("1314520");
    // 1.2.建立连接
    Connection connection = factory.newConnection();

    // 2.创建通道Channel
    Channel channel = connection.createChannel();

    // 3.创建队列
    String queueName = "simple.queue";
    channel.queueDeclare(queueName, false, false, false, null);

    // 4.订阅消息
    channel.basicConsume(queueName, true, new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope,
                                   AMQP.BasicProperties properties, byte[] body) throws IOException {
            // 5.处理消息
            String message = new String(body);
            System.out.println("接收到消息：【" + message + "】");
        }
    });
    System.out.println("等待接收消息。。。。");
}

消费者

public static void main(String[] args)throws IOException, TimeoutException {
    // 1.建立连接
    ConnectionFactory factory = new ConnectionFactory();
    // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
    factory.setHost("aguo.pro");
    factory.setPort(5672);
    factory.setVirtualHost("/");
    factory.setUsername("aguomq");
    factory.setPassword("1314520");
    // 1.2.建立连接
    Connection connection = factory.newConnection();

    // 2.创建通道Channel
    Channel channel = connection.createChannel();

    // 3.创建队列
    String queueName = "simple.queue";
    channel.queueDeclare(queueName, false, false, false, null);

    // 4.发送消息
    String message = "hello, rabbitmq!";
    channel.basicPublish("", queueName, null, message.getBytes());
    System.out.println("发送消息成功：【" + message + "】");

    // 5.关闭通道和连接
    channel.close();
    connection.close();

}

4.2 含有交换机模型

发布订阅(Publish、Subscribe),又根据交换机类型不同分为三种:

  • Fanout Exchange:广播
  • Direct Exchange:路由
  • Topic Exchange:主题

5.SpringAMQP

5.1 什么是SpringAMQP

类似JDBC是接口，MySQL实现这个接口。

核心：便捷得发送、便捷得接收、自动化队列声明

5.2 实现HelloWord

共三部分

  1. 导入依赖
  2. 配置rabbitmq地址
  3. 注入使用/监听

生产者

  1. 导入依赖
<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. 配置地址
spring:
  rabbitmq:
    host: aguo.pro
    username: aguomq
    password: 1314520
    virtual-host: /
    port: 5672
  1. 使用
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void sendMessage() {
        rabbitTemplate.convertAndSend("simple.queue","hello Springamqp");
    }

}

消费者

SpringAMOP如何接收消息?

  • 引入amgp的starter依赖
  • 配置RabbitMQ:地址
  • 定义类,添加@Component注解
  • 类中声明方法,添加@RabbitListener注解,方法参数就时消息

注意:消息一旦消费就会从队列删除,RabbitMQ没有消息回溯功能

同样都是要导入依赖、配置地址，主要是监听方法的实现，如下

@Component//被spring容器管理
public class rabbitConsumer {
    @RabbitListener(queues = "simple.queue")//定义监听器
    public void receiveMessage(String message){
        System.out.println("收到的消息是:"+message);
    }
}

5.2.1 消息预取

rabbitmq中，消费者先从队列拿过来放着，然后再处理，弊端就是消费者没有根据自己的能力来取任务，通通预取了出来。

配置：

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 #可以任意配置值

5.3 发布与订阅

publish、subscribe

交换的转发规则要根据其类型来决定：

  • Fanout:广播
  • Direct:路由
  • Topic:话题

API中的交换机继承结构图

注意:exchange负责消息路由,而不是存储,路由转发失败那么消息就会丢失！

  • 交换机的作用
    • 接收oublisher发送的消息
    • 将消息按照规则路由到与之绑定的队列
    • 不能缓存消息,路由失败,消息丢失
    • FanoutExchange的会将消息路由到每个绑定的队列
  • 声明队列、交换机、绑定关系的Bean是什么？
    • Queue
    • FanoutExchange
    • Binding

5.4 广播（FanoutExchange）

实现思路如下:

  1. 在consumer服务中,利用代码声明队列、交换机,并将两者绑定
  2. 在consumer服务中,编写两个消费者方法,分别监听fanout.queue1和fanout.queue2
  3. 在publisher中编写测试方法,向litcast.fanout发送消息

可以看出，主要是在consumer中配置，publisher不关心任务放在哪个队列，也不关心谁来处理，只需要告诉交换机是谁然后丢任务给他

Consumer配置类

注意Queue的类型！

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Queue;
@Configuration
public class FanoutConfig {
    //声明交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("itcast.fanout");
    }
    //声明队列1
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("itcast.qunue1");
    }

    //绑定队列1
    @Bean
    public Binding fanoutBinding1(FanoutExchange fanoutExchange,
                                 Queue fanoutQueue1) {

        return BindingBuilder
                .bind(fanoutQueue1)
                .to(fanoutExchange);

    }
    //声明队列2
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("itcast.qunue2");
    }
    //绑定队列2
    @Bean
    public Binding fanoutBinding2(FanoutExchange fanoutExchange,
                                 Queue fanoutQueue2) {

        return BindingBuilder
                .bind(fanoutQueue2)
                .to(fanoutExchange);

    }

}

consumer监听

跟之前的监听配置一样，没啥区别就是绑定的额队列不一样罢了

@Component
public class rabbitConsumer {
    @RabbitListener(queues = "aguo.qunue1")
    public void receiveMessage(String message){
        System.out.println("收到的消息11是:"+message);
    }
    @RabbitListener(queues = "aguo.qunue2")
    public void receiveMessage2(String message){
        System.out.println("收到的消息22是:"+message);
    }
}

publisher发布者

//交换机名称
String exchangeName = "itcast.fanout";
//消息
String message = "Hello rabbitMq";
//发送消息
rabbitTemplate.convertAndSend(exchangeName,"",message);

5.5 路由（DirectExchange）

Direct Exchange会将接收到的消息根据规则路由到指定的Queue,因此称为路由模式(routes)。

  • 每一个Queue都与Exchangei设置一个BindingKey
  • 发布者发送消息时,指定消息的RoutingKey
  • Exchange将消息路由到Binding Key与消息Routing Key一致的队列

aguo大白话

就是我们给队列标记不同的key，发布者发消息要指定key,交换机将该消息丢到拥有这个key的队列中（可以重复）

实现

这里我们使用注解来实现

consumer

//消费者1
@RabbitListener(bindings = @QueueBinding(
    exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
    value = @Queue(name = "direct.queue1"),
    key = {"red","blue"}
))
public void receiveMessage2(String message){
    System.out.println("消费者 red blue:"+message);
}
//消费者2
@RabbitListener(bindings = @QueueBinding(
    exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
    value = @Queue(name = "direct.queue2"),
    key = {"red","yellow"}
))
public void receiveMessage3(String message){
    System.out.println("消费者 red yellow:"+message);
}

解释下注解

@RabbitListener(
    bindings = @QueueBinding(//绑定注解
        //指定交换机、指定交换机的模式 Fanout、direct
        exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
        //指定该消费者所绑定的队列名称
        value = @Queue(name = "direct.queue1"),
        //指定该队列有什么key
        key = {"red","blue"}
))

publisher

@Test
public void sendMessage() throws InterruptedException {
    //交换机名称
    String exchangeName = "itcast.direct";
    //发送的key
    String key ="red";
    //消息
    String message = "Hello rabbitMq:"+key;
    //发送消息
    rabbitTemplate.convertAndSend(exchangeName,key,message);
}

5.6 话题（TopicExchange）

TopicExchange与DirectExchange:类似,区别在于routing Key必须是多个单词的列表,并且以,分割。Queue与Exchange指定BindingKey时可以使用通配符:

  • #:  代指0个或多个单词
  • *:  代指一个单词

就是给一个队列一个统配的key,如china.#，发布者发消息指定具体的key，交换机去匹配队列的统配路径，匹配成功则把消息丢过去

如

China.news 中国所有新闻

China.# :中国所有东西

*.weather 所有国家的天气

consumer

@RabbitListener(bindings = @QueueBinding(
    exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
    value = @Queue(name = "topic.queue1"),
    key = "china.#"
))
public void receiveMessage1(String message){
    System.out.println("消费者 china:"+message);
}
@RabbitListener(bindings = @QueueBinding(
    exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
    value = @Queue(name = "topic.queue2"),
    key = "#.news"
))
public void receiveMessage2(String message){
    System.out.println("消费者 news"+message);
}

注解解释

@RabbitListener(
    bindings = @QueueBinding(//绑定注解
        //指定交换机、指定交换机的模式 Fanout、direct
        exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),//交换机类型指定是topic
        value = @Queue(name = "topic.queue2"),
        //指定队列的队列统配名
        key = "#.news"
))

publisher

@Test
public void sendMessage() throws InterruptedException {
    //交换机名称
    String exchangeName = "itcast.topic";
    //发送的key
    String key ="beijing.news";
    //消息
    String message = "Hello rabbitMq Topic"+key;
    //发送消息
    rabbitTemplate.convertAndSend(exchangeName,key,message);
}

5.7 消息者想都消费

消费者不指定队列名称

@RabbitListener(bindings = @QueueBinding(
    exchange = @Exchange(name = "aguo.fanout",type = ExchangeTypes.FANOUT),
    value = @Queue()
))
public void repeatMessage1(String message){
    System.out.println("多次消费者消费1"+message);
}

@RabbitListener(bindings = @QueueBinding(
    exchange = @Exchange(name = "aguo.fanout",type = ExchangeTypes.FANOUT),
    value = @Queue()
))
public void repeatMessage2(String message){
    System.out.println("多次消费者消费2"+message);
}

最后会自动随机生成一个队列

消费者指定交换机即可

@Test
public void sendMessage() throws InterruptedException {
    //交换机名
    String exchangeName = "aguo.fanout";
    rabbitTemplate.convertAndSend(exchangeName,"","广播消息");
}
  • 缺点
    • 消费者必须先与生成者运行，这样才能创建出临时队列出来

6. 消息转化器

java是面向对象的，如果我们直接传入对象的话，那么默认会使用JDK的序列化方式，而我们希望的是使用的是JSON的系列化方式

一定要注意发送发与接收方必须使用相同的MessageConverter解析器

6.1 配置JSON转化器

导入Jackson依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

配置类中配置JSON转化器

@Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}

6.2 使用

发送消息时候，会自动转化为JSON格式的字符串

接收消息时候，会自动将JSON字符串转为Bean对象

publisher

@Test
public void sendMessage() throws InterruptedException {
    //交换机名
    String exchangeName = "itcast.fanout";
    //对象名
    User user = new User(1, "aguo");
    //发送消息
    rabbitTemplate.convertAndSend(exchangeName,"",user);
}

看看管理页面

消费者

@RabbitListener(queues = "itcast.qunue2")
public void receiveMessage11(User user){
    System.out.println("收到的对象是:"+user);
}
阿果子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring-Kafka系列(3)—— SpringKafka消费者监听MessageListener
SpringBoy的博客
06-23 6050
之前已经介绍了通过和工具来消费数据。下面介绍SpringKafka消费数据的方式——kafka消息监听器。Kafka的消息监听一般可以分为：1.单条数据监听；2.批量数据监听。是的消息监听器接口，也是一个函数式接口，利用接口的方法可以实现消费数据。 基于此接口可以实现单条数据消息监听器接口、多条数据消息监听器接口、带ACK机制的消息监听器和MessageListenerGenericMessageListener单条数据监听器BatchMessageListener批量数据监听器AckowledgingMe
springboot2.x +rabbitmq使用和源码分析四(消费者-Listener使用)
F_Hello_World的博客
07-17 1555
序言： 当数据通过生产者产生到发送到exchange交换器，再通过设定的路由规则，经过routingKey，最终会落地到queue 中。这个时候引出了Listener消费者了。在第一章中有对RabbitAnnotationDrivenConfiguration该类中源码做过基本分析，该类最大的作用就是通过配置文件的设定用于构建RabbitListenerContainerFactory(该接口的实现，工厂设计模式用以创建核心的MessageListenerContainer 容器类，而该类Message
Apche Kafka + Spring的消息监听容器
一起学习一起进步~
08-16 2122
例如，如果有 3 个主题，每个主题有 5 个分区，并且我们想要使用 concurrency=15，但是我们只会看到 5 个活动使用者，每个使用者从每个主题分配一个分区，而其他 10 个使用者处于空闲状态。TopicPartitionOffset提供了一个带有附加参数的构造函，boolean如果是true，则在容器启动时相对于该消费者的当前位置初始偏移（正或负）。使用事务（transactions）时，偏移量将发送到事务，语义相当于 RECORD 或 BATCH，具体取决于侦听器类型（记录或批处理）。
kafka监听topic消费_Spring-Kafka（六）—— @KafkaListener的花式操作
weixin_39918928的博客
12-22 1716
消息监听对于Kafka中Topic的数据消费，我们一般都选择使用消息监听器进行消费，怎么把消息监听器玩出花来呢，那就得看看它所实现的功能了。Spring-Kafka中消息监听大致分为两种类型，一种是单条数据消费，一种是批量消费；两者的区别只是在于监听器一次性获取消息的数量。GenericMessageListener是我们实现消息监听的一个接口，向上扩展的接口有非常多，比如：单数据消费的Messa...
RabbitMQ：@RabbitListener 与 @RabbitHandler 及 消息序列化
u012794845的专栏
09-27 3838
添加 @RabbitListener 注解来指定某方法作为消息消费的方法，例如监听某 Queue 里面的消息 MessageConvert 涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析 RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个 MessageConvert 接口处理消息的序列化，其实现有 SimpleMessageConverter
RabbitMQ Server3.13.0
最新发布
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
rabbitmq安装包
09-22
**RabbitMQ基础介绍** RabbitMQ是一款广泛应用的消息中间件，基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中实现可靠的消息传递。它由Erlang编程语言开发，提供高可用性、可扩展性和稳定...
rabbitmq 3.10.2 window安装包
07-05
RabbitMQ是一个开源的消息代理和队列服务器，广泛用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）标准，允许应用程序之间异步通信，并提供了高可用性、可扩展性和容错性。RabbitMQ的...
rabbitmq安装
02-21
RabbitMQ，作为一款广泛使用的开源消息队列系统，是基于AMQP（Advanced Message Queuing Protocol）协议的实现。它允许不同应用程序之间通过发送和接收消息进行通信，从而实现异步处理、解耦组件以及负载均衡等功能...
RabbitMq
01-20
Java操作RabbitMq simple 简单队列 work queues 工作队列 公平分发 轮询分发 public/subscribe 发布订阅 routing 路由选择 通配符模式 topics 主题 手动和自动确认消息 队列的持久化和非持久化 RabbitMq的延迟队列 ...
Spring-Kafka消费者端源码分析
Silence的博客
12-26 3822
本文按照源码分析三部曲：核心类->核心流程->核心逻辑，对spring-kafka消费端的源码实现进行分析。
Springboot Kafka整合（二）( Receiving Messages)—官方原版
深圳市多克创新科技有限公司
04-02 632
Springboot Kafka整合（二）—官方原版
2020-09-18
nb7474的博客
09-18 359
@RabbitListener注解和ChannelAwareMessageListener之间的关系 两者本质上是同级的，比如监听了同一个queue，那么生产者发到这个queue的消息会轮询这两个消费方式。 不同的点是**@RabbitListener注解想实现手动ack必须在配置文件中配置**： spring: rabbitmq: listener: simple: acknowledge-mode: manual 增加配置后才可以在代码中进行手动ack： @Component pu
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值