RabbitMQ05 - 发布确认RabbitmqTemplate版

最新推荐文章于 2025-06-06 22:10:13 发布
原创 最新推荐文章于 2025-06-06 22:10:13 发布 · 751 阅读 · 29 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #rabbitmq #分布式 #消息队列

发布确认RabbitmqTemplate版

文章目录

一：RabbitmqTemplate版本发布确认

1：发布确认介绍

首先发布消息后进行备份在缓存里，如果消息成功发布确认到交换机，则从缓存里删除该消息

如果没有成功发布，则设置一个定时任务，重新从缓存里获取消息发布到交换机，直到成功发布到交换机

在这里插入图片描述

2：基础演示

2.1：准备说明

一个交换机：confirm.exchange，一个队列：confirm.queue，一个消费者：confirm.consumer

其中交换机类型时 direct，与队列关联的 routingKey 是 key1

在这里插入图片描述

在配置文件当中需要添加：

server:
  port: 8888
spring:
  rabbitmq:
    host: 192.168.91.200
    port: 5672
    username: root
    password: 123
    publisher-confirm-type: correlated  # 加入这行
  • none -> 值是禁用发布确认模式，是默认值
  • correlated -> 值是发布消息成功到交换器后会触发回调方法
  • simple -> 值经测试有两种效果
    • 其一效果和 correlated 值一样会触发回调方法
    • 其二在发布消息成功后使用 rabbitTemplate 调用 waitForConfirms() 或 waitForConfirmsOrDie() 方法等待 broker 节点返回发送结果，根据返回结果来判定下一步的逻辑
    • 注意 waitForConfirmsOrDie() 方法如果返回 false 则会关闭 channel，则接下来无法发送消息到 broker;
2.2：添加配置类
package rabbitMQ.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;

/**
 * <p>
 * 功能描述：声明交换机和队列，将交换机和队列进行绑定
 * </p>
 *
 * @author cui haida
 * @date 2024/08/01/11:11
 */
public class ConfirmConfig {
    //交换机
    public static final String CONFIRM_EXCHANGE_NAME = "confirm_exchange";
    //队列
    public static final String CONFIRM_QUEUE_NAME = "confirm_queue";
    //routingKey
    public static final String CONFIRM_ROUTING_KEY = "key1";

    //声明交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE_NAME);
    }

    //声明队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    //绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("confirmQueue") Queue confirmQueue,
                                        @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }
}
2.3：消息生产者/消费者
@Slf4j
@RequestMapping("/confirm")
@RestController
public class ProductController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    //开始发消息,测试确认
    @GetMapping("/sendMessage/{message}")
    public void sendMessage(@PathVariable("message") String message) {
        //指定消息 id 为 1
        CorrelationData correlationData1 = new CorrelationData("1");
        // 四个参数依次是：交换机的名称，路由键指定【告诉交换机要发送的队列】，message, 消息id
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME, ConfirmConfig.CONFIRM_ROUTING_KEY, message + "key1", correlationData1);
        log.info("发送消息内容:{}",message+"key1");

        //指定消息 id 为 2
        CorrelationData correlationData2 = new CorrelationData("2");
        String CONFIRM_ROUTING_KEY = "key2";
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME,CONFIRM_ROUTING_KEY,message+"key2",correlationData2);
        log.info("发送消息内容:{}",message+"key2");
    }
}

@Slf4j
@Component
public class Consumer {

    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE_NAME) // 监听指定队列
    // 对消息进行处理
    public void receiveConfirmMessage(Message message){
        String msg = new String(message.getBody());
        log.info("接受到的队列confirm.queue消息:{}",msg);
    }
}
2.4：发布消息后的回调接口

只要生产者发布消息，交换机不管是否收到消息，都会调用该类的 confirm 方法

package rabbitMQ.callback;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * <p>
 * 功能描述：发布确认的回调
 * </p>
 *
 * @author cui haida
 * @date 2024/08/01/11:17
 */
@Slf4j
@Component
public class MyCallBack implements RabbitTemplate.ConfirmCallback {

    //注入
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init() {
        //注入
        rabbitTemplate.setConfirmCallback(this);
    }

    /**
     * 交换机不管是否收到消息的一个回调方法
     * 发消息 交换机接收到了 回调
     *
     * @param correlationData 保存回调信息的Id及相关信息
     * @param ack             交换机收到消息 为true
     * @param cause           未收到消息的原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData != null ? correlationData.getId() : "";
        if (ack) {
            log.info("交换机已经收到了ID为:{}的消息", id);
        } else {
            log.info("交换机还未收到ID为:{}的消息，由于原因:{}", id, cause);
        }
    }
}

在这里插入图片描述

可以看到，发送了两条消息，第一条消息的 RoutingKey 为 “key1”，第二条消息的 RoutingKey 为 “key2”

两条消息都成功被交换机接收，也收到了交换机的确认回调，但消费者只收到了一条消息，因为第二条消息的 RoutingKey 与队列的 BindingKey 不一致，也没有其它队列能接收这个消息，所有第二条消息被直接丢弃了。

丢弃的消息交换机是不知道的，需要解决告诉生产者消息传送失败。

2.5：其他说明
package rabbitMQ.consumer;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.converter.MessageConversionException;

/**
 * 消息确认
 */
@Slf4j
public class SimpleConsumer {
    @RabbitListener(queues = "simple.queue")
    public void listener(String msg) {
        // todo: 具体的消息处理
        System.out.println("simple.queue 消费消息：" + msg);
    }

    // 注解的方式创建交换机，队列，绑定关系
    // 使用@QueueBinding注解创建队列、交换机和绑定关系 <----
    // * value + @Queue 创建队列
    // * exchange + @Exchange 创建交换机，可以声明交换机的名称和类型
    // * key 绑定关系的指定，是一个数组，可以指定多个路由键
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("direct.queue1"), // 声明队列
            exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT), // 声明交换机
            key = {"red", "blue"} // 绑定关系
    ))
    public void listenerDirect(String msg) {
        // todo: 具体的消息处理
        System.out.println("direct.queue1 消费消息：" + msg);
    }

    // 消费持久性
    // 1：消费者确认机制
    // 2：消费失败处理
    // 3：业务幂等性

    // ===============> 消费者确认机制 <===============
    // 为了确认消费者是否成功处理消息，RabbitMQ提供了消息者确认机制（Consumer Ack）。
    // 当消费者处理消息结束之后，应该向RabbitMQ发送一个回执，告知自己的消息处理状态。回执有三种可选值：
    // 1：ACK：消息处理成功
    // 2：NACK：消息处理失败，需要再次投递
    // 3：REJECT：拒绝消息，消息处理失败，并从RabbitMQ的队列中删除这个消息
    // RabbitMQ已经实现了消息确认的功能，并允许我们通过配置文件选择ACK的处理方式，有三种方式：
    // spring.rabbitmq.listener.simple.acknowledge-mode = ???【none / manual / auto】
    // 1：none：不处理，消息投递给消费者之后立刻ack，消息会立刻从MQ删除，非常的不安全，不建议使用
    // 2：manual：手动处理，消费者处理完消息之后，需要手动发送ack或者reject，存在业务的入侵，但是更加的灵活
    // 3：auto：自动处理，Spring AMQP利用AOP对我们的消息进行了环绕增强，当业务正常执行的时候则自动返回ACK，当业务出现异常的时候，根据异常判断返回不同的结果：
    // 3.1：如果是业务异常，会自动返回nack
    // 3.2：如果是消息处理或者异常校验，自动返回reject
    @RabbitListener(queues = "ack_queue")
    public void listenerForAck(String msg) {
        System.out.println("simple.queue 消费消息：" + msg);
        // none模式断点运行到此处，消息已经从队列中被移除掉了
        // auto模式断点运行到此处，状态将会变成un_ack，会给MQ回执un_ack，然后会一直进行消息的投递尝试，直到重试次数达到上限
        throw new RuntimeException("故意设置一个运行时异常，检测ack模式对消息造成的影响");
        // 消息处理异常抛出测试 -> reject -> 拒绝消息，消息处理失败，并从RabbitMQ的队列中删除这个消息
        // throw new MessageConversionException("这是一个消息转换异常，用来测试reject的");
    }

    // 失败重试机制
    // 当消费者出现nack异常之后，消息会不断的进行requeue到队列，再次重新发送给消费者，然后再次处理异常，无限循环，导致mq的消息处理飙升
    // 我们可以利用spring amqp的retry机制，在消费者出现异常的时候利用本地重试，而不是无限的requeue到MQ队列
    // 开启消息重试模式之后，重试次数耗尽的话，如果消息依然失败，则需要有MessageRecoverer接口来处理，包括三种实现：
    // 1：RejectAndDontRequeueRecover：重试耗尽之后，直接reject，消息将会被丢弃，默认就是用的这种方式
    // 2：ImmediateAcknowledgeRecover：重试耗尽之后，直接nack，消息重新入队
    // 3：RepublishMessageRecover：重试耗尽之后，将失败消息投递到指定的交换机
}

3：消息回退

3.1：消息回退介绍

获取回退的消息，首先在配置文件开启该功能mandatory:true，然后需要自定义类实现 RabbitTemplate.ReturnsCallback 接口

并且初始化时，使用该自定义类作为回退消息的处理类，同时开启 Mandatory，设置为 true

在启动开启 Mandatory，或者在代码里手动开启 Mandatory 参数，或者都开启

# 新版
spring:
  rabbitmq:
  	template:
      mandatory: true
      
# 旧版
spring:
  rabbitmq:
    mandatory: true

rabbitTemplate.setMandatory(true);

在仅开启了生产者确认机制的情况下，交换机接收到消息后，会直接给消息生产者发送确认消息

如果发现该消息不可路由，那么消息会被直接丢弃，此时生产者是不知道消息被丢弃这个事件的。

那么如何让无法被路由的消息帮我想办法处理一下？最起码通知我一声，我好自己处理啊。

通过设置 mandatory 参数可以在当消息传递过程中不可达目的地时将消息返回给生产者

3.2：实际演示

修改配置文件

spring:
	rabbitmq:
		host: 192.168.91.200
		port: 5762
		username: root
		password: 123
		publisher-confirm-type: correlated # 异步回调自动确认
		publisher-returns: true # 消息回退
		template:
			mandatory: true # 消息回退
server:
	port: 8888

修改回调接口

实现 RabbitTemplate.ReturnsCallback 接口，并实现方法

package rabbitMQ.callback;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * <p>
 * 功能描述：发布确认的回调
 * </p>
 *
 * @author cui haida
 * @date 2024/08/01/11:17
 */
@Slf4j
@Component
public class MyCallBack implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback {

    //注入
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init() {
        //注入
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    /**
     * 交换机不管是否收到消息的一个回调方法
     * 发消息 交换机接收到了 回调
     *
     * @param correlationData 保存回调信息的Id及相关信息
     * @param ack             交换机收到消息 为true
     * @param cause           未收到消息的原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData != null ? correlationData.getId() : "";
        if (ack) {
            log.info("交换机已经收到了ID为:{}的消息", id);
        } else {
            log.info("交换机还未收到ID为:{}的消息，由于原因:{}", id, cause);
        }
    }

    //可以在当消息传递过程中不可达目的地时将消息返回给生产者
    //只有不可达目的地的时候 才进行回退
    /*
     * 当消息无法路由的时候的回调方法
     *  message      消息
     *  replyCode    编码
     *  replyText    退回原因
     *  exchange     从哪个交换机退回
     *  routingKey   通过哪个路由 key 退回
     */
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        log.error("消息{},被交换机{}退回，退回原因:{},路由key:{}",
                new String(returned.getMessage().getBody()),returned.getExchange(),
                returned.getReplyText(),returned.getRoutingKey());
    }
}

在这里插入图片描述

4：备份交换机

4.1：备份交换机简介

有了 mandatory 参数和回退消息，我们获得了对无法投递消息的感知能力，有机会在生产者的消息无法被投递时发现并处理。

但有时候，我们并不知道该如何处理这些无法路由的消息，最多打个日志，然后触发报警，再来手动处理。

而通过日志来处理这些无法路由的消息是很不优雅的做法，特别是当生产者所在的服务有多台机器的时候，手动复制日志会更加麻烦而且容易出错。而且设置 mandatory 参数会增加生产者的复杂性，需要添加处理这些被退回的消息的逻辑。

如果既不想丢失消息，又不想增加生产者的复杂性，该怎么做呢？

前面在设置死信队列的文章中，我们提到，可以为队列设置死信交换机来存储那些处理失败的消息，可是这些不可路由消息根本没有机会进入到队列，因此无法使用死信队列来保存消息。

在 RabbitMQ 中，有一种备份交换机的机制存在，可以很好的应对这个问题。

什么是备份交换机呢？

备份交换机可以理解为 RabbitMQ 中交换机的“备胎”，当我们为某一个交换机声明一个对应的备份交换机时，就是为它创建一个备胎

当交换机接收到一条不可路由消息时，将会把这条消息转发到备份交换机中，由备份交换机来进行转发和处理

通常备份交换机的类型为 Fanout ，这样就能把所有消息都投递到与其绑定的队列中，然后我们在备份交换机下绑定一个队列，这样所有那些原交换机无法被路由的消息，就会都进入这个队列了。

当然，我们还可以建立一个报警队列，用独立的消费者来进行监测和报警

4.2：备份交换机实战

需要一个备份交换机 backup.exchange，类型为 fanout，该交换机发送消息到队列 backup.queue 和 warning.queue

在这里插入图片描述

根据上图声明交换机和队列，并进行绑定

package rabbitMQ.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;

/**
 * <p>
 * 功能描述：声明交换机和队列，将交换机和队列进行绑定
 * </p>
 *
 * @author cui haida
 * @date 2024/08/01/11:11
 */
public class ConfirmConfig {
    //交换机
    public static final String CONFIRM_EXCHANGE_NAME = "confirm_exchange";
    //队列
    public static final String CONFIRM_QUEUE_NAME = "confirm_queue";
    //routingKey
    public static final String CONFIRM_ROUTING_KEY = "key1";

    //关于备份的
    //交换机
    public static final String BACKUP_EXCHANGE_NAME = "backup_exchange";
    //队列
    public static final String BACKUP_QUEUE_NAME = "backup_queue";
    //报警队列
    public static final String WARNING_QUEUE_NAME = "warning_queue";


    //声明交换机,设置该交换机的备份交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.directExchange(CONFIRM_EXCHANGE_NAME)
                .durable(true).withArgument("alternate-exchange",BACKUP_EXCHANGE_NAME).build();
    }

    //声明队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    //绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("confirmQueue") Queue confirmQueue,
                                        @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }

    //备份交换机的创建
    @Bean("backupExchange")
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE_NAME);
    }

    //声明备份队列
    @Bean("backupQueue")
    public Queue backupQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE_NAME).build();
    }

    //声明报警队列
    @Bean("warningQueue")
    public Queue warningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE_NAME).build();
    }

    //绑定 备份队列绑定备份交换机
    @Bean
    public Binding backupQueueBindingBackupExchange(@Qualifier("backupQueue") Queue backupQueue,
                                                    @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }

    //绑定 报警队列绑定备份交换机
    @Bean
    public Binding warningQueueBindingBackupExchange(@Qualifier("warningQueue") Queue warningQueue,
                                                     @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(warningQueue).to(backupExchange);
    }
}

告警消费者

@Slf4j
@Component
public class WarningConsumer {
    //接收报警信息
    @RabbitListener(queues = ConfirmConfig.WARNING_QUEUE_NAME)
    public void receiveWarningMsg(Message message){
        String msg = new String(message.getBody());
        log.error("报警发现不可路由消息:{}",msg);
    }
}

由于之前写过 confirm.exchange 交换机，当更改配置了，需要删掉，不然会报错

Mandatory 参数与备份交换机可以一起使用的时候，备份交换机优先级高

SpringBoot 整合 RabbitMQ-消费者
weixin_43389143的博客
09-24 3072
SpringBoot 整合 RabbitMQ-消费者前言一、RabbitMQ是什么？二、使用步骤1、首先引入 maven 依赖2、application.properties 中的配置3、后台代码4、Spring Boot + RabbitMQ 配置参数说明 前言 这里只介绍springboot整合rabbitmq消费端配置 一、RabbitMQ是什么？ RabbitMQ是实现了高级消息队列协议的开源消息代理软件（面向消息的中间件）。 二、使用步骤 1、首先引入 maven 依赖 <!--rab
RabbitMQ(二) - RabbitMQ与消息发布确认与返回、消费确认
玄霄
08-05 2597
SpringBoot与RabbitMQ整合后，对RabbitClient的“确认”进行了封装、使用方式与RabbitMQ官网不一致；
springAMQP中使用RabbitTemplate进行发布者确认
weixin_44877713的博客
06-17 510
springAMQP中使用RabbitTemplate进行发布者确认
RabbitMQ 发布确认高级
@小刘同学nice
07-22 306
发布确认高级 在生产环境中由于一些不明原因，导致 rabbitmq 重启，在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢: 应 用 [xxx] 在 [08-1516:36:04] 发 生 [ 错误日志异常 ] ， alertId=[xxx] 。 由 [org.springframework.amqp.rabbit.
RabbitMQ入门4.1.0版本（基于java、SpringBoot操作）
卿着飞翔
06-06 1183
RabbitMQ是一个开源消息代理系统，采用Erlang语言开发，支持AMQP等多种协议。核心功能包括异步消息处理、消息持久化、灵活路由和高可用性。其架构包含Broker、Virtual host、Connection、Channel等组件，通过交换机（Exchange）和队列（Queue）实现消息路由，支持四种交换机类型：直连、扇形、主题和头交换机。RabbitMQ提供六种工作模式：简单模式（单生产者-单消费者）、工作模式（多消费者负载均衡）、发布订阅（广播消息）、路由模式（按路由键分发）、主题模式（通配
rabbitmq的发布确认和事务
weixin_34409741的博客
05-06 462
2019独角兽企业重金招聘Python工程师标准>>> ...
09-rabbitMq-发布确认高级-springBoot版本
秃头之路
10-09 523
在生产环境中由于一些不明原因，导致 rabbitmq 重启，在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投递呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢？这就需要我们的rabbitMQ队列发布确认高级模式，消息投递失败的，是转发，转发失败，消息回退，缓存等等都是问题。 一、确认机制方案 1、确认机制方案 消息投递到我们交换机时，同时缓存我们的消息，一旦我们的
Linux安装rabbitmq整合版本
qq_41709084的博客
08-22 427
账号密码： guest guest。rabbitmq启动erl找不到。添加配置文件，解决只能本地访问。rabbitmq下载地址。4、创建erlang文件夹。erlang下载地址。erlang安装步骤。rabbitmq安装。
RabbitMQ 使用
qq_33753147的博客
10-02 3018
RabbitMQ 使用
springmvc整合rabbitmq实现消息发送消息确认
hyn150的博客
04-21 1346
springmvc整合rabbitmq实现消息发送消息确认 首先springmvc创建项目的教程，这里就不多说了，现在重点看一下springmvc整合rabbitmq的教程。 首先引入jar包我这里用的是2.1.6版本 <dependency> <groupId>org.springframework.amqp</groupId> ...
【RabbitMQ】SpringBoot整合RabbitMQ
p_fly的博客
08-16 713
对于RabbitMQ的开发,Spring方法提供了更为方便的操作.Spring官网介绍: Spring AMQPRabbitMQ官网介绍: RabbitMQ tutorial - "Hello World!"
【RabbitMQ】MQ的基本概念、RabbitMQ简介及安装
热门推荐
十八岁讨厌编程的博客
01-11 2万+
本文涉及MQ的基本概念、RabbitMQ简介、RabbitMQ的安装等内容
RabbitMQ教程大全看这一篇就够了-java版本
原名又逢乱世。不要放下学习的脚步，毕竟比天天打牌、钓鱼、打游戏更能从内在充实自己。
11-06 3222
rabbitmq
消息中间件--RabbitMQ总结
Simlier的博客
12-21 2645
基本知识 为什么使用消息中间件 解耦 异步 削峰 生产者/消费者 RabbitMQ 的安装 普通安装 直接去官网下载安装包。 https://www.rabbitmq.com/ docker安装 // 拉去镜像 docker pull rabbitmq // 启动容器 docker run -it --name rabbitmq \ -e RABBITMQ_DEFAULT_USER=admin \ -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5
RabbitTemplate类介绍、应用场景和示例代码
a_beiyo的博客
03-04 778
是 Spring AMQP（Advanced Message Queuing Protocol）提供的核心类之一，它是接口的主要实现，用于与 RabbitMQ 交互。它封装了消息的生产和消费逻辑，使得开发者可以更方便地与 RabbitMQ 进行通信。方法作用发送消息接收并转换消息receive()仅接收消息（不转换）发送消息并等待响应监听消息是否到达交换机监听消息是否到达队列开启事务支持适用于大多数 RabbitMQ 操作，结合 Spring Boot 配置可以大大简化开发。
springboot 整合最新rabbitMQ
baidu_41858046的博客
03-27 265
springboot 整合最新rabbitMQ pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <!--非必须--> <dependency> <groupId>org.proj
RabbitMQ之发布确认
weixin_60257072的博客
12-09 2028
可以看到，发送了两条消息，第一条消息的 RoutingKey 为 "key1"，第二条消息的 RoutingKey 为。"key2"，两条消息都成功被交换机接收，也收到了交换机的确认回调，但消费者只收到了一条消息，因为。有了 mandatory 参数和回退消息，我们获得了对无法投递消息的感知能力，有机会在生产者的消息。但有时候，我们并不知道该如何处理这些无法路由的消息，最多打个日志，然。后触发报警，再来手动处理。处理失败的消息，可是这些不可路由消息根本没有机会进入到队列，因此无法使用死信队列来保存消息。
RabbitMQ学习（八）--发布确认高级
行无所至，学无所尽。
07-29 1457
背景 在生产环境中由于一些不明原因，导致 rabbitmq 重启，在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投递呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢: 应 用 [xxx] 在 [08-1516:36:04] 发 生 [ 错误日志异常 ] ， alertId=[xxx] 。 由 [org.springframework.amqp.rabbit.li
Rabbitmq 生产者消息确认机制有哪些
最新发布
07-23
根据提供的引用，我们可以总结出RabbitMQ生产者消息确认机制包括两种：Publisher Confirm（发布者确认）和Publisher Return（发布者返回）。下面我将详细解释这两种机制。 ### 1. **Publisher Confirm（发布者确认...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值