深入解析@RabbitListener:从基础配置到高级应用实战

RabbitMQ--@RabbitListener及@RabbitHandle Spring AMQP中@RabbitListener与@RabbitHandler的核心区别:前者负责绑定队列与启动监听,后者处理消息类型分发。@RabbitListener可单独用于方法级监听(处理单一消息类型),类级使用时需配合@RabbitHandler实现多类型消息处理。关键差异在于:@RabbitListener定义监听目标,@RabbitHandler定义处理方法。在Fanout广播场景下,多个@RabbitListener可绑定不同队列接收相同消息;而同一队列的多类型消息处理则需要类级@Ra 阅读详情

1. 初识@RabbitListener:你的第一个消息监听器

如果你正在用Spring Boot和RabbitMQ,那@RabbitListener这个注解绝对是你绕不开的“神器”。简单来说,它就像给你的方法装上了一对耳朵,专门用来监听RabbitMQ队列里的消息。一旦有消息进来,这个方法就会被自动调用,处理消息内容。我刚开始用的时候,觉得这简直太方便了,以前还得手动创建连接、通道、消费者,现在一个注解全搞定。

咱们先来看一个最基础的例子,让你感受一下它有多简单。假设你有一个订单系统,订单创建成功后需要发个通知。你可以在Spring Boot项目里这么写:

@Component
public class OrderNotificationConsumer {

    @RabbitListener(queues = "order.notification.queue")
    public void handleOrderNotification(String orderMessage) {
        System.out.println("收到新订单通知,订单信息:" + orderMessage);
        // 这里可以调用你的业务逻辑,比如发邮件、发短信
    }
}

看到了吗?就这么几行代码。@RabbitListener(queues = "order.notification.queue") 这行注解告诉Spring:“嘿,帮我监听名叫 order.notification.queue 的这个队列。” 当有消息到达这个队列时,handleOrderNotification 方法就会被触发,参数 orderMessage 就是消息体内容。这里我用了 String 类型,Spring AMQP会自动把消息体转换成字符串传给你。

但实际项目中,消息内容往往更复杂,可能是一个JSON对象。这时候,你可以直接定义一个对应的Java类来接收。Spring Boot默认集成了Jackson,能自动完成JSON到对象的转换。比如订单消息可能包含订单ID、金额、用户信息,你可以这样:

public class OrderMessage {
    private String orderId;
    private BigDecimal amount;
    private String userId;
    // 省略getter/setter和toString
}

@Component
public class OrderNotificationConsumer {

    @RabbitListener(queues = "order.notification.queue")
    public void handleOrderNotification(OrderMessage order) {
        System.out.println("处理订单,订单号:" + order.getOrderId() + ", 金额:" + order.getAmount());
        // 进行具体的业务处理
    }
}

这种自动转换的能力,让代码变得非常干净。你不需要在方法里手动解析JSON字符串,直接操作对象就行。我实测下来,这种开发体验非常流畅,能让你更专注于业务逻辑本身,而不是消息处理的细节。

当然,你可能会问,队列 order.notification.queue 在哪定义的?通常有两种方式。一种是在RabbitMQ的管理界面手动创建;另一种更推荐,在Spring Boot配置类里用代码声明,让应用启动时自动创建。这样能确保队列存在,避免因队列不存在而报错。我一般喜欢用代码声明,因为这样配置和代码在一起,维护起来一目了然。

2. 进阶配置:玩转多队列与绑定关系

只会监听一个队列可不够,真实场景往往更复杂。比如,一个客服系统可能需要同时监听“用户咨询队列”和“投诉建议队列”。@RabbitListener 很贴心地支持同时监听多个队列,语法也很直观。

@Component
public class CustomerServiceConsumer {

    @RabbitListener(queues = {"user.inquiry.queue", "user.complaint.queue"})
    public void handleUserMessage(String message) {
        System.out.println("客服收到消息: " + message);
        // 根据消息来源(队列)不同,可以在这里做分支处理
    }
}

把 queues 属性从一个字符串改成字符串数组就行了。这样,无论消息进入哪个队列,都会由同一个 handleUserMessage 方法来处理。不过这里有个小细节,方法内部可能无法直接区分消息来自哪个队列。如果需要区分,可以在方法参数里加入 @Header(AmqpHeaders.RECEIVED_ROUTING_KEY) 或者获取消息的其他属性来判断。

但上面这种写法,队列还是需要预先创建好。@RabbitListener 更强大的地方在于,它能直接在注解里声明队列、交换机以及它们之间的绑定关系!这意味着你连配置类的 @Bean 都可以省了,一切都在注解里完成。这对于快速开发和小型项目特别有用。

@Component
public class LogConsumer {

    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "app.log.queue", durable = "true"),
        exchange = @Exchange(value = "app.log.exchange", type = ExchangeTypes.TOPIC),
        key = "app.log.#"
    ))
    public void processLog(String logMessage) {
        System.out.println("应用日志: " + logMessage);
    }
}

我来拆解一下这个 @QueueBinding:

  • value = @Queue(...):这里声明了一个队列。value 指定队列名,durable = "true" 表示队列是持久化的,即使RabbitMQ服务器重启,队列也不会丢失。
  • exchange = @Exchange(...):声明了一个交换机。type = ExchangeTypes.TOPIC 指定这是一个Topic类型的交换机,非常适合做日志这种根据路由键模式匹配的场景。
  • key = "app.log.#":这就是路由键(Routing Key)。# 是通配符,表示匹配零个或多个单词。所以所有以 app.log. 开头的路由键发来的消息,都会被路由到这个队列。

通过这种方式,你不仅定义了一个监听器,还顺便把RabbitMQ的拓扑结构(队列、交换机、绑定)都定义好了。应用启动时,Spring会确保这些资源都存在。我有个项目就用这种方式管理了十几种不同业务的消息路由,代码结构非常清晰。

3. 消息确认(ACK)模式:手动掌控消费成败

消息消费成功与否,是需要明确告诉RabbitMQ的,这就是消息确认(Acknowledgment),简称ACK。这是保证消息可靠性的核心环节。@RabbitListener 支持三种ACK模式,在 application.yml 里配置:

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: manual # 推荐生产环境使用手动确认
  • AUTO(自动确认,默认):Spring框架会根据方法执行是否抛出异常来决定ACK还是NACK。没异常就自动ACK,有异常就自动NACK(通常会导致消息重新入队)。这个模式简单,但控制粒度粗,有时候异常被捕获了,框架可能还会认为消费成功。
  • MANUAL(手动确认):开发者需要自己在代码里调用 channel.basicAck() 或 channel.basicNack()。这是生产环境我最推荐的模式,因为它让你能完全掌控何时确认消息,尤其是在消费逻辑涉及数据库事务、外部API调用等复杂操作时。
  • NONE:相当于RabbitMQ的自动确认(autoAck),消息一推送给消费者,服务端就认为消费成功。这个模式有丢失消息的风险,一般不推荐使用。

重点说说手动确认怎么用。你需要修改监听方法,增加 Channel 和 Message(或 @Header(AmqpHeaders.DELIVERY_TAG))参数。

@Component
public class OrderProcessorConsumer {

    @RabbitListener(queues = "order.process.queue")
    public void handleOrder(OrderMessage order, Message message, Channel channel) throws IOException {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            System.out.println("开始处理订单: " + order.getOrderId());
            // 1. 检查订单数据合法性
            // 2. 扣减库存(调用库存服务)
            // 3. 生成发货单(操作数据库)
            // 假设这里都是成功的
            System.out.println("订单处理成功");

            // 手动确认消息,第二个参数multiple=false表示只确认当前这一条
            channel.basicAck(deliveryTag, false);
        } catch (InventoryException e) {
            // 库存不足,属于业务异常,消息应该被拒绝且不重新入队(比如走人工审核流程)
            System.err.println("库存不足,订单处理失败: " + order.getOrderId());
            // 拒绝消息,requeue=false 表示不重新放回队列
            channel.basicNack(deliveryTag, false, false);
        } catch (Exception e) {
            // 其他未知异常(如网络抖动、数据库连接失败),可能重试后会成功
            System.err.println("处理订单时发生系统异常: " + order.getOrderId(), e);
            // 拒绝消息,requeue=true 表示重新放回队列,等待下次消费
            channel.basicNack(deliveryTag, false, true);
        }
    }
}

这段代码展示了手动确认的典型模式。deliveryTag 是消息在通道内的唯一标识,确认或拒绝时必须提供。在 try-catch 块中,根据不同的异常类型,我们做出了不同的处理:

  • 业务处理成功,调用 basicAck 确认消费。
  • 明确的业务失败(如库存不足),调用 basicNack 并设置 requeue=false,让消息进入死信队列或直接被丢弃,避免无效重试。
  • 系统级异常(如网络问题),调用 basicNack 并设置 requeue=true,让消息重新回到队列,等待稍后重试。

这种精细化的控制,是确保消息队列系统稳定和数据一致性的关键。我踩过的坑就是早期用了AUTO模式,某个第三方服务超时导致异常被捕获,消息却被自动确认了,结果数据不一致,排查了好久。换成手动模式后,心里踏实多了。

4. 并发与性能调优:让消费者多线程工作

默认情况下,一个 @RabbitListener 对应一个消费者(线程)。如果队列里消息堆积很多,单个消费者处理不过来,就会成为瓶颈。这时候就需要提高并发消费能力。Spring AMQP提供了非常灵活的并发配置。

最简单的方式是在注解上直接设置 concurrency 属性。

@Component
public class HighVolumeConsumer {

    @RabbitListener(queues = "image.process.queue", concurrency = "5-10")
    public void processImage(byte[] imageData) {
        // 处理图片,可能是CPU密集型或IO密集型操作
        System.out.println("线程" + Thread.currentThread().getName() + " 正在处理图片");
    }
}

concurrency = "5-10" 这个配置非常直观,它表示:

  • 启动时,会创建 5个 消费者线程(最小并发数)。
  • 当消息堆积,处理不过来时,容器会动态增加消费者线程,最多增加到 10个(最大并发数)。
  • 当负载降下来后,多余的消费者线程会被回收,但最少保持5个。

这比写死一个线程数要智能得多,能更好地应对流量波动。我处理过一个图片缩略图生成的服务,就是用了这种弹性并发配置,白天高峰期线程数自动涨上去,晚上低谷期又降下来,既保证了处理速度,又节省了系统资源。

除了在注解上配置,更全局的方式是在 application.yml 中配置,这样会对所有 @RabbitListener 生效(除非在注解上单独覆盖)。

spring:
  rabbitmq:
    listener:
      simple:
        concurrency: 5        # 最小消费者数量
        max-concurrency: 20   # 最大消费者数量
        prefetch: 10          # 每个消费者每次预取的消息数

这里多了一个 prefetch 配置,它至关重要。它决定了每个消费者一次能从RabbitMQ服务器拉取多少条消息到本地缓存。设置得太小(比如1),会导致消费者频繁向Broker请求消息,增加网络开销。设置得太大,如果某个消费者处理很慢,会导致大量消息堆积在该消费者的本地缓存,而其他消费者却空闲,造成负载不均。

根据我的经验,prefetch 的值需要结合业务处理耗时和并发数来权衡:

  • 对于处理非常快(毫秒级)的消息,可以设置大一点,比如50-100。
  • 对于处理慢(秒级以上)的消息,应该设置小一点,比如5-10,避免单个消费者占用太多未确认的消息。
  • 一个常用的经验法则是:prefetch 值最好小于等于 concurrency * 2。

我曾经遇到过一个坑,把 prefetch 设成了200,而业务处理一个消息要2秒。结果就是第一个消费者瞬间预取了200条消息,其他消费者没活干,而第一条消息处理完确认之前,这200条都处于“未确认”状态,严重影响了消息的流转效率。后来调到10,整个系统的吞吐量反而上去了。

5. 动态启停监听器:应对运维与调试场景

你有没有遇到过这种场景:线上某个消息消费者出了问题,你想临时停掉它进行修复,但又不想重启整个应用?或者,在开发调试时,不希望本地的测试代码消费线上队列的消息?这就需要动态控制监听器的启停。

@RabbitListener 的 autoStartup 属性就是为这种场景准备的。把它设为 false,监听器在应用启动时就不会自动开始消费。

@Component
public class MaintenanceModeConsumer {

    @RabbitListener(queues = "data.cleanup.queue", id = "cleanupListener", autoStartup = "false")
    public void cleanupData(String task) {
        System.out.println("执行数据清理任务: " + task);
    }
}

注意,我特意加了一个 id = "cleanupListener"。这个ID是监听器的唯一标识,后面我们动态控制时,就要靠这个ID找到它。

那么,如何动态启动它呢?我们需要用到 RabbitListenerEndpointRegistry 这个组件。它可以管理所有由 @RabbitListener 注册的监听器容器。

@Service
public class ListenerControlService {

    @Autowired
    private RabbitListenerEndpointRegistry registry;

    /**
     * 启动指定的监听器
     */
    public void startListener(String listenerId) {
        MessageListenerContainer container = registry.getListenerContainer(listenerId);
        if (container != null && !container.isRunning()) {
            container.start();
            System.out.println("监听器 " + listenerId + " 已启动");
        }
    }

    /**
     * 停止指定的监听器
     */
    public void stopListener(String listenerId) {
        MessageListenerContainer container = registry.getListenerContainer(listenerId);
        if (container != null && container.isRunning()) {
            container.stop();
            System.out.println("监听器 " + listenerId + " 已停止");
        }
    }

    /**
     * 获取所有监听器状态
     */
    public void listAllListeners() {
        registry.getListenerContainers().forEach(container -> {
            System.out.println("监听器ID: " + container.getListenerId() +
                             ", 运行状态: " + (container.isRunning() ? "运行中" : "已停止"));
        });
    }
}

有了这个 ListenerControlService,你就可以通过HTTP接口、JMX或者管理后台来调用 startListener("cleanupListener") 或 stopListener("cleanupListener"),实现监听器的动态启停。

更进一步,我们可以结合配置中心(比如Apollo、Nacos)实现更智能的控制。在配置中心设置一个开关,当开关变化时,自动启停对应的监听器。这样,运维人员只需要在配置中心点一下,就能完成对消息消费的控制,无需发版或重启。

@Component
public class ConfigCenterListenerController implements ApplicationRunner {

    @Autowired
    private RabbitListenerEndpointRegistry registry;
    @Value("${mq.listeners.cleanup.enabled:false}")
    private boolean cleanupListenerEnabled;

    @Override
    public void run(ApplicationArguments args) {
        // 应用启动时,根据配置决定是否启动监听器
        toggleListener("cleanupListener", cleanupListenerEnabled);
    }

    @ApolloConfigChangeListener // 假设使用Apollo配置中心
    private void onConfigChange(ConfigChangeEvent event) {
        if (event.isChanged("mq.listeners.cleanup.enabled")) {
            boolean newValue = Boolean.parseBoolean(event.getChange("mq.listeners.cleanup.enabled").getNewValue());
            toggleListener("cleanupListener", newValue);
        }
    }

    private void toggleListener(String listenerId, boolean enabled) {
        MessageListenerContainer container = registry.getListenerContainer(listenerId);
        if (container == null) return;

        if (enabled && !container.isRunning()) {
            container.start();
        } else if (!enabled && container.isRunning()) {
            container.stop();
        }
    }
}

这种模式在实际运维中非常有用。比如,在大促前,你可以暂时关闭一些非核心业务的消费者,将资源留给核心链路;或者在某个下游系统维护时,暂停相关消费者,避免大量错误和重试。

6. 错误处理与死信队列:给消息一个“兜底”方案

即使我们做了手动确认和异常捕获,仍然会有消息处理失败的情况。对于反复重试仍然失败的消息,我们不能让它无限循环,这时候就需要引入死信队列(Dead Letter Queue, DLQ) 机制。

死信队列就是一个普通队列,专门用来接收那些“死掉”的消息。一条消息变成死信通常有几种情况:

  1. 消息被消费者拒绝(basic.reject 或 basic.nack)并且设置了 requeue=false。
  2. 消息在队列中存活时间(TTL)过期。
  3. 队列长度超过限制,最早的消息会被丢弃或转移到DLQ。

配置死信队列需要两步。首先,在定义业务队列时,指定它的死信交换机和路由键。

@Configuration
public class DeadLetterConfig {

    // 1. 定义死信交换机(就是一个普通交换机)
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange("order.dlx.exchange");
    }

    // 2. 定义死信队列
    @Bean
    public Queue dlxQueue() {
        return new Queue("order.dlx.queue", true);
    }

    // 3. 将死信队列绑定到死信交换机
    @Bean
    public Binding dlxBinding() {
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("order.dead");
    }

    // 4. 定义业务队列,并指定它的死信参数
    @Bean
    public Queue orderQueue() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", "order.dlx.exchange"); // 指定死信交换机
        args.put("x-dead-letter-routing-key", "order.dead");      // 指定死信路由键
        args.put("x-message-ttl", 60000); // 可选:消息60秒没被消费就变成死信
        return new Queue("order.process.queue", true, false, false, args);
    }
}

然后,你需要一个消费者来处理死信队列里的消息。这些通常是需要人工干预或特殊处理的“坏消息”。

@Component
public class DeadLetterConsumer {

    @RabbitListener(queues = "order.dlx.queue")
    public void handleDeadLetter(OrderMessage deadOrder, Message message, Channel channel) throws IOException {
        System.err.println("收到死信消息,需要人工处理!");
        System.err.println("订单信息: " + deadOrder);
        System.err.println("死信原因: " + message.getMessageProperties().getReceivedRoutingKey());

        // 可以在这里发报警邮件、写入特殊数据库表等
        // 确认消费掉这条死信
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

除了死信队列,@RabbitListener 还支持更细粒度的错误处理。你可以通过 errorHandler 属性指定一个自定义的错误处理器。

@Component
public class CustomErrorHandler implements RabbitListenerErrorHandler {

    @Override
    public Object handleError(Message amqpMessage, org.springframework.messaging.Message<?> message,
                             ListenerExecutionFailedException exception) {
        System.err.println("监听器方法执行出错!");
        System.err.println("原始消息: " + new String(amqpMessage.getBody()));
        System.err.println("异常: " + exception.getCause().getMessage());

        // 你可以在这里记录错误日志、发送监控报警
        // 返回一个值,这个值会被用作回复消息(如果存在回复机制的话)
        // 或者直接抛出异常,让容器根据ACK模式决定是否重试
        throw exception; // 重新抛出,触发重试或进入死信队列
    }
}

// 在监听器中使用这个错误处理器
@Component
public class OrderConsumerWithErrorHandler {

    @RabbitListener(queues = "order.queue", errorHandler = "customErrorHandler")
    public void processOrder(OrderMessage order) {
        // 业务逻辑
    }
}

自定义错误处理器让你能统一处理所有监听器的异常,进行日志聚合、监控上报等操作,比在每个方法里写 try-catch 更优雅、更集中。

7. 结合@RabbitHandler实现多类型消息分发

有时候,一个队列可能会接收多种格式的消息。比如一个“任务队列”,可能包含“发送邮件”、“生成报表”、“清理数据”等不同类型的任务。如果为每种任务都单独建一个队列,管理起来会比较繁琐。这时候,@RabbitHandler 注解就派上用场了。

@RabbitHandler 需要和类级别的 @RabbitListener 配合使用。它标注在方法上,表示这个方法可以处理某种特定类型的消息。Spring会根据消息转换后的Java类型,自动选择匹配的 @RabbitHandler 方法来执行。

@Component
@RabbitListener(queues = "universal.task.queue")
public class UniversalTaskDispatcher {

    @RabbitHandler
    public void handleEmailTask(EmailTask emailTask) {
        System.out.println("处理邮件任务,收件人: " + emailTask.getTo());
        // 调用邮件发送服务
    }

    @RabbitHandler
    public void handleReportTask(ReportTask reportTask) {
        System.out.println("处理报表任务,报表类型: " + reportTask.getType());
        // 调用报表生成服务
    }

    @RabbitHandler
    public void handleCleanupTask(CleanupTask cleanupTask) {
        System.out.println("处理清理任务,清理范围: " + cleanupTask.getScope());
        // 调用数据清理服务
    }

    @RabbitHandler(isDefault = true)
    public void handleUnknownTask(Object unknownTask) {
        System.err.println("收到未知类型的任务,无法处理: " + unknownTask.getClass().getName());
        // 可以在这里将未知任务转入死信队列或记录日志
    }
}

这个设计非常巧妙。UniversalTaskDispatcher 类监听同一个队列,但内部根据消息体的实际类型,路由到不同的处理方法。@RabbitHandler(isDefault = true) 标注的方法是一个“兜底”方法,当没有其他方法能匹配消息类型时,就会调用它。这避免了因为消息格式不对而抛出异常,导致消息不断重试的问题。

使用这种方式,消息的发送方只需要将不同的任务对象发送到同一个队列,消费方就能自动识别并处理。它减少了队列的数量,让系统结构更简洁。但要注意,这要求发送方和消费方对任务类型的定义(类全路径名)要一致,或者使用统一的类库。如果类型不匹配,默认处理器会接手。

我在一个工作流引擎项目中就用了这种模式,将十几种不同的活动节点任务都发到同一个队列,由同一个分发器处理,代码维护性非常好。

@RabbitListener 注解详解 RabbitListener 注解是 Spring AMQP 提供的注解,用于简化 RabbitMQ 消息监听器的创建,我们在方法上添加 @RabbitListener 注解,就可以将方法注册为消息监听器,监听 RabbitMQ 的消息,本篇我们来分析一下 @RabbitListener 注解的使用详解。如有错误的地方欢迎指出纠正。 阅读详情

相关推荐

RabbitMQ:@RabbitListener注解简化消息监听

pom.xml: <?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/ma

kaven 5929

@RabbitListener注解

I. 配置 首先创建一个 SpringBoot 项目,用于后续的演示 springboot 版本为2.2.1.RELEASE rabbitmq 版本为3.7.5 依赖配置文件 pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ve..

Va1mZzz的博客 3万+

RabbitMQ死信队列原理与实战:从异常处理到延迟队列实现

消息队列作为分布式系统解耦与异步通信的核心组件,其可靠性设计至关重要。死信队列(DLX)机制正是保障消息可靠性的关键设计,它通过定义消息的三种异常状态(被拒绝、过期、队列满),将无法正常消费的消息路由至专用队列进行后续处理。这一原理不仅解决了消息丢失问题,更衍生出延迟队列、可靠重试等高级技术价值。在应用场景上,结合Spring Boot等主流框架,开发者可以便捷地配置死信交换机与队列,实现业务补偿与系统自愈。本文深入探讨了RabbitMQ死信队列的触发机制与配置实践,并针对消息堆积、性能优化等常见问题提供了

weixin_33748818的博客 453

Spring Boot 中的 @RabbitListener 注解是什么,原理,如何使用

RabbitListener 注解是 Spring AMQP 框架中的一个关键组件,它可以将一个方法标记为 RabbitMQ 的消息监听器。在 Spring Boot 应用程序中,可以使用 @RabbitListener 注解来监听队列,并在接收到消息时执行指定的方法。在本文中,我们介绍了 @RabbitListener 注解的原理、使用方法和常见应用场景。通过使用 @RabbitListener 注解,可以方便地实现异步任务处理、发布订阅模式等功能。

u013749113的博客 1万+

深入解析@RabbitListener:从基础配置到高级批处理应用

本文深入解析了Spring AMQP中的@RabbitListener注解,从基础的消息监听器配置讲起,逐步深入到高级应用。详细介绍了如何通过手动确认、并发控制、声明式绑定来构建健壮的消费者,并重点探讨了批处理技术以大幅提升消费性能。文章还涵盖了异常处理、重试机制、动态控制与监控等生产环境必备知识,为开发者提供了一套完整的RabbitMQ消息消费解决方案。

weixin_29256771的博客 429

深入解析@RabbitListener注解:从基础配置到高级消息处理

本文深入解析Spring AMQP中的@RabbitListener注解,涵盖从基础消息监听器搭建到高级配置的完整实践。详细介绍了如何通过自定义容器工厂、JSON消息转换器、参数绑定及自动声明绑定等功能,实现高效、可靠的消息消费,并提供了错误处理与性能调优的实战指南。

weixin_29290863的博客 365

@RabbitListener源码解析

参考:Spring整合rabbitmq实践(三):源码-@RabbitListener实现过程 rabbitmq consumer push模式还是pull模式 参考朱忠华老师 RabbitMQ之Consumer消费模式(Push &amp; Pull) 为什么一个普通的方法加上@RabbitListener注解就能接收消息了呢? 先总结来说,有一个BeanPostProcessor来处理这...

u013905744的专栏 1万+

RabbitMQ-深入解析@RabbitListener注解的消息消费机制

本文深入解析Spring Boot中@RabbitListener注解的消息消费机制。作为消息消费的“管家”,该注解通过声明监听端点并创建MessageListenerContainer,简化了队列监听、连接管理与线程调度。文章详细探讨了其参数配置、消息转换机制(如JSON处理),以及如何通过自定义容器工厂控制并发、预取和确认模式,以实现稳定高效的消息消费。

tgb3456789的博客 1105

RabbitMQ:@RabbitListener 与 @RabbitHandler 及 消息序列化

添加 @RabbitListener 注解来指定某方法作为消息消费的方法,例如监听某 Queue 里面的消息 MessageConvert 涉及网络传输的应用序列化不可避免,发送端以某种规则将消息转成 byte 数组进行发送,接收端则以约定的规则进行 byte[] 数组的解析 RabbitMQ 的序列化是指 Message 的 body 属性,即我们真正需要传输的内容,RabbitMQ 抽象出一个...

weixin_43343423的博客 3万+

RabbitMQ--@RabbitListener与@RabbitHandler的实战应用与最佳实践

本文深入探讨了RabbitMQ中@RabbitListener与@RabbitHandler的实战应用与最佳实践。通过详细对比两种注解的核心区别、高级应用技巧和性能优化方法,帮助开发者高效处理多类型消息,提升系统吞吐量。文章还提供了常见问题排查方案和配置模板,是RabbitMQ消息监听开发的实用指南。

weixin_26765287的博客 125

【福建dem】原始高程数据tif格式

DEM(Digital Elevation Model,数字高程模型)是一种地理信息系统中的关键数据集,它提供了地表地形的三维信息,通常用于分析地貌特征、模拟水文过程、规划建设、灾害预警等多个领域。这种数据对于地理分析非常有价值,例如,它可以用于计算坡度、坡向、地形粗糙度等地形特征,或者进行洪水模拟、地质灾害评估、太阳能辐射分析等。“福建dem原始高程数据tif格式”是研究和理解福建省地形地貌的重要资源,结合GIS工具,可以揭示丰富的地理信息,为科研、工程和决策提供有力支持。

鸿业远图科技 946

RabbitMQ - @RabbitListener 与 @RabbitHandler 的使用区别

RabbitMQ 是一个开源的消息代理和队列服务器,用来实现应用程序之间的消息传递。它实现了高级消息队列协议(AMQP),支持多种消息模式,包括点对点、发布/订阅、路由等。Producer(生产者):发送消息的应用程序Consumer(消费者):接收消息的应用程序Exchange(交换机):接收生产者的消息并根据规则路由到队列Queue(队列):存储消息的缓冲区Binding(绑定):连接交换机和队列的规则。

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

2023电视专用!安卓电子相册APP避坑指南(附开源代码)

本文针对2023年智能电视用户,提供安卓电子相册APP的避坑指南与实战教程。文章详细解析了电视端相册应用的常见广告与兼容性陷阱,并指导用户如何安全获取、部署纯净的APK应用,通过核心设置实现无广告的个性化图片轮播体验,最终打造专属的家庭回忆墙。

weixin_29012677的博客 498

RabbitMQ之监听和@RabbitListener解析

在没有引入spingboot时rabbitmq是通过ConnectionFactory建立连接创建通道channel.basicPublish等方法来发送消息,监听消息也是先建立连接和通道然后通过channel.basicConsume回调函数来监听消息,在引入springboot后发消息通过yaml配置来创建RabbitTemplate的bean对象来发送消息,通过配置文件来创建交换机和队列,那监听是通过什么样的bean来实现的

YDXD_C的博客 1646

Bootloader Design of PIC18 series MCU

注意:下列描述是在PIC单片机上启用Bootloader的一个相关知识的近似完备集。所有需要了解的,与bootloader与用户态程序交互的理论知识都已给出。包含内存组织,跳转,中断等必备功能的描述。

含光左卫的工作笔记集 1268

[NVME] CMBLOC-Controller Memory Buffer Location

CMBLOC-Controller Memory Buffer Location

jinyuya的博客 991

【RabbitMQ】@RabbitListener的使用及造成报错死循环的分析

问题复现: docker 下清空对应的队列信息 exec rabbitmq /bin/bash #rabbitmq是容器名,也可以指定为Id rabbitmqctl purge_queue queue.order # queue.order是队列名 RabbitMQ控制台新建消息,等待消费者消费 http://localhost:15672 前置知识: 一、 @RabbitListener的使...

chenghan_yang的博客 1万+

避开这5个坑!用MATLAB做核密度估计时90%人会犯的错误

本文详细解析了使用MATLAB进行核密度估计时常见的5个高频错误,包括三维数据可视化、带宽参数优化、大数据量处理、核函数选择及版本兼容性问题。特别针对核密度估计中的关键参数带宽(bandwidth)提供了数据驱动的优化策略,帮助用户提升分析精度与效率。

jenkins8butler的博客 278

@RabbitListener常用总结

是 Spring AMQP 提供的注解,用于简化 RabbitMQ 消息监听器的创建。通过在方法上添加注解,可以将方法注册为消息监听器,用于处理从 RabbitMQ 中接收到的消息。以下是。

m0_67920613的博客 7308

Windows11安装配置openclaw+deepseek(大龙虾)

密码可以随便设置(注意wsl系统本质上是linux系统,设置密码系统是不会像windows一样显示*点位符的),输入密码后敲回车再次输入密码,输入后敲回车。如果不小心关闭这个界面,可以再次进入powershell,输入wsl进行系统。在powershell中输入:curl -fssL https://openclaw.ai/install.sh | bash。下面是否通过第3方平台和openclaw交互,我选择j最后一项:skip for now。到下面这一步,可以通过键盘的左箭头选择Yes.

mahailiang的专栏 344

具身智能机器人算法控制研究进展综述

具身智能(Embodied Intelligence)作为人工智能与机器人学的交叉前沿领域,强调智能体通过物理身体与环境的持续交互涌现智能行为。近年来,随着基础模型(Foundation Models)、扩散策略(Diffusion Policy)、视觉-语言-动作(Vision-Language-Action, VLA)模型以及大规模机器人数据集(如Open X-Embodiment)的快速发展,具身智能机器人的算法控制范式正经历深刻变革。

VectorShift的博客 230

Spring Boot中@RabbitListener的5个高级用法,你可能还不知道

本文深入探讨了Spring Boot中@RabbitListener注解的5个高级用法,包括动态队列监听、自动声明交换机和绑定关系、消息转换与类型处理、消费端流量控制以及消费异常处理与重试机制。这些技巧能显著提升RabbitMQ在生产环境中的消息处理能力,适用于电商、金融等高并发场景。

weixin_30664051的博客 280

工业质检升级!C#上位机集成YOLOv8.3.138+Blob分析:尺寸测量+缺陷检测一步到位

工业场景的技术选型,从来不是“选最先进的”,而是“选最适配的”。这个项目的成功,不在于采用了多前沿的技术,而在于找对了“贴合场景的技术组合”和“落地导向的实施思路”。C#上位机的稳定性保障了系统长期运行,YOLOv8.3.138的精度解决了缺陷检测痛点,Blob分析的抗干扰能力确保了尺寸测量准确,三者结合实现了“1+1+1>3”的效果。先摸透场景,再选技术:不要盲目追求最新模型,先深入了解车间环境、生产节奏、精度要求,选择兼容性强、稳定性高的技术方案;数据质量决定模型性能。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 611
上一篇: NES(FC) FPGA游戏卡开发笔记(5)---- MMC1芯片功能解析与FPGA实现
下一篇: RTX3060显卡用户必看:Halcon22.11深度学习环境搭建避坑指南(Win10+CUDA11.7+cuDNN8.6)
寂静夜空35
博客等级 码龄3年 60粉丝 1797原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值