RabbitMQ学习笔记_handledelivery，2024年最新2024年大数据开发知识体系总结

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

public class Consumer\_2 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "logs\_direct";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();


        //绑定交换机和队列
        //临时队列和交换机绑定
        channel.queueBind(queueName, exchangeName, "info");
        channel.queueBind(queueName, exchangeName, "error");
        channel.queueBind(queueName, exchangeName, "warning");
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2" + new String(body));
            }
        });
    }
}

消费者1接收routingKey为error的消息，消费者2接收info,error,warning三种routingKey

首先启动生产者，routingKey为info，此时消费者2能收到消息

消费者2这是direct模型发布的基于route key: [info] 发送的消息

生产者，routingKey为error，消费者1和2都能收到消息

消费者1这是direct模型发布的基于route key: [error] 发送的消息

消费者2这是direct模型发布的基于route key: [error] 发送的消息

3.6第五种模式-Topic/主题（交换机-topic类型）

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey
把消息路由到不同的队列。只不过Topic类型Exchange可以让
队列在绑定Routing key的时候使用通配符！这种模型Routingkey
一般都是由一个或多个单词组成，多个单词之间以”.”分割，
例如： item.insert

在Direct模型下：队列与交换机的绑定，不能是任意绑定了，
而是要指定一个RoutingKey（路由key）
消息的发送方在 向 Exchange发送消息时，
也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，
而是根据消息的Routing Key进行判断，
只有队列的Routingkey与消息的 Routing key完全一致，
才会接收到消息

P：生产者，向Exchange发送消息，发送消息时，
会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，
然后把消息递交给 与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、
error、warning 的消息

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "topics";
        //将通道声明指定交换机
        //参数1: 交换机名称 参数2: 交换机类型 TOPIC 主题类型
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);

        String routingKey = "user.save";
        //发消息
        channel.basicPublish(exchangeName, routingKey, null, ("这是topic模型发布的基于route key: [" + routingKey + "] 发送的消息").getBytes());
        channel.basicPublish(exchangeName, "a.pp", null, ("这是topic模型发布的基于route key: [" + "a.pp" + "] 发送的消息").getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel, connection);
    }
}

消费者1

public class Consumer\_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "topics";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();

        String routingKey = "user.\*";

        //绑定交换机和队列
        channel.queueBind(queueName, exchangeName, routingKey);
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1" + new String(body));
            }
        });
    }
}

消费者2

public class Consumer\_2 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "topics";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();

        String routingKey = "a.\*";

        //绑定交换机和队列
        channel.queueBind(queueName, exchangeName, routingKey);
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2" + new String(body));
            }
        });
    }
}

生产者发布了routingKey为user.save和a.pp的消息
消费者1使用routingKey 通配符 user.*接收,所以收到了以下消息

消费者1这是topic模型发布的基于route key: [user.save] 发送的消息

消费者2使用routingKey 通配符 a.*接收,所以收到了以下消息

消费者2这是topic模型发布的基于route key: [a.pp] 发送的消息

4.SpringBoot中使用RabbitMQ

4.1 环境搭建

pom

<?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/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>springboot-rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbitmq</name>
    <description>springboot-rabbitmq</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.4.2</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

yml

spring:
  application:
    name: springboot_rabbitmq
  rabbitmq:
    host: 127.0.0.1
    port: 5673
    username: root
    password: 123
    virtual-host: /

4.1第一种-Hello World!/基础队列（生产者-队列-消费者）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /\*\*
 \* 生产端没有指定交换机只有routingKey和Object。
 \* 消费方产生hello队列，放在默认的交换机(AMQP default)上。
 \* 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 \* 交换机的队列有相同的名字，他就会自动路由上。
 \* 生产端routingKey 叫hello ，消费端生产hello队列。
 \* 他们就路由上了
 \*/
    @Test
    void producer() {
        rabbitTemplate.convertAndSend("hello", "hello world");
    }

}

消费者
Spring Boot中@RabbitHandler注解的介绍、原理和使用

/\*\*
 \* 生产端没有指定交换机只有routingKey和Object。
 \* 消费方产生hello队列，放在默认的交换机(AMQP default)上。
 \* 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 \* 交换机的队列有相同的名字，他就会自动路由上。
 \* 生产端routingKey 叫hello ，消费端生产hello队列。
 \* 他们就路由上了
 \*/
@Component
@RabbitListener(queuesToDeclare = @Queue(value = "hello"))
public class ConsumerHelloWord {

    @RabbitHandler
    public void receive(String message) {
        System.out.println("message = " + message);
    }

}

先运行消费者，在运行生产者

4.2第二种-Work Queues/工作队列/任务队列

生产者

/\*\*
 \* 生产端没有指定交换机只有routingKey和Object。
 \* 消费方产生work队列，放在默认的交换机(AMQP default)上。
 \* 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 \* 交换机的队列有相同的名字，他就会自动路由上。
 \* 生产端routingKey 叫work ，消费端生产work队列。
 \* 他们就路由上了
 \*/
@Component
public class ConsumerWorkQueues {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive1(String message) {
        System.out.println("work message1 = " + message);
    }


    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message) {
        System.out.println("work message2 = " + message);
    }
}

消费者

/\*\*
 \* 生产端没有指定交换机只有routingKey和Object。
 \* 消费方产生work队列，放在默认的交换机(AMQP default)上。
 \* 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 \* 交换机的队列有相同的名字，他就会自动路由上。
 \* 生产端routingKey 叫work ，消费端生产work队列。
 \* 他们就路由上了
 \*/
@Component
public class ConsumerWorkQueues {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive1(String message) {
        System.out.println("work message1 = " + message);
    }


    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message) {
        System.out.println("work message2 = " + message);
    }
}

4.3第三种模式-Publish/Subscribe/发布订阅（交换机-fanout类型）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void producer() {
        for (int i = 0; i < 10; i++) {
            //参数1为交换机
            //参数2为路由key,“”表示为任意路由
            //参数3为消息内容
            rabbitTemplate.convertAndSend("logs","","这是日志广播");
        }
    }

}

消费者

@Component
public class ConsumerWorkQueuesFanout {

    //使用@RabbitListener注解中的bindings声明并绑定交换机和队列
    @RabbitListener(bindings = @QueueBinding(value = @Queue, // 创建临时队列
            exchange = @Exchange(name = "logs", type = ExchangeTypes.FANOUT)
    ))
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = @QueueBinding(value = @Queue, // 创建临时队列
            exchange = @Exchange(name = "logs", type = ExchangeTypes.FANOUT)
    ))
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}

4.4第四种模式-Routing/路由（交换机-Direct类型）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void producer() {
        for (int i = 0; i < 10; i++) {
            //参数1为交换机
            //参数2为路由key,“”表示为任意路由
            //参数3为消息内容
            rabbitTemplate.convertAndSend("directs","error","error 的日志信息");
        }
    }

}

消费者

@Component
public class ConsumerRouting {

    //使用@RabbitListener注解中的bindings声明并绑定交换机和队列
    @RabbitListener(bindings = @QueueBinding(value = @Queue("directsQueue"),//指定队列名
            key = {"info", "error"},
            exchange = @Exchange(name = "directs", type = ExchangeTypes.DIRECT)
    ))
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = @QueueBinding(value = @Queue("directsQueue"),
            key = {"error"},
            exchange = @Exchange(name = "directs", type = ExchangeTypes.DIRECT)
    ))
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}

4.5第五种模式-Topic/主题（交换机-topic类型）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void producer() {
        for (int i = 0; i < 10; i++) {
            //参数1为交换机
            //参数2为路由key,“”表示为任意路由
            //参数3为消息内容
            rabbitTemplate.convertAndSend("topics","user.save.findAll","user.save.findAll 的消息");
        }
    }

}

消费者

@Component
public class ConsumerTopics {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    key = {"user.\*"},
                    exchange = @Exchange(type = ExchangeTypes.TOPIC, name = "topics")
            )
    })
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    key = {"user.#"},
                    exchange = @Exchange(type = ExchangeTypes.TOPIC, name = "topics")
            )
    })
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}

5.死信队列，延迟队列

5.1 死信概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到
broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue
中的某些消息无法被消费，这样的消息如果没有 后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景:为了保证订单业务的消息数据不丢失，需要使用到
RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

5.2死信的来源

1. 消息 TTL 过期
2. 队列达到最大长度(队列满了，无法再添加数据到 mq 中)
3. 消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

5.3入门实战

5.3.1 架构图

5.3.2 代码

生产者

public class Producer {
    private static final String NORMAL\_EXCHANGE = "normal\_exchange";

    public static void main(String[] argv) throws Exception {
        try (Channel channel = RabbitMQUtils.getConnection().createChannel()) {
            channel.exchangeDeclare(NORMAL\_EXCHANGE,
                    BuiltinExchangeType.DIRECT);
            //设置消息的 TTL 时间
            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
            //该信息是用作演示队列个数限制
            for (int i = 1; i < 11; i++) {
                String message = "info" + i;
                channel.basicPublish(NORMAL\_EXCHANGE, "zhangsan", properties, message.getBytes());
                System.out.println("生产者发送消息:" + message);
            }
        }
    }
}

消费者1

public class Consumer01 {
    //普通交换机名称
    private static final String NORMAL\_EXCHANGE = "normal\_exchange";
    //死信交换机名称
    private static final String DEAD\_EXCHANGE = "dead\_exchange";

    public static void main(String[] argv) throws Exception {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        //声明死信和普通交换机 类型为 direct
        channel.exchangeDeclare(NORMAL\_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD\_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明死信队列
        String deadQueue = "dead-queue";
        channel.queueDeclare(deadQueue, false, false, false, null);
        //死信队列绑定死信交换机与 routingKey
        channel.queueBind(deadQueue, DEAD\_EXCHANGE, "lisi");

        Map<String, Object> params = new HashMap<>();
        //正常队列设置死信交换机 参数 key 是固定值
        params.put("x-dead-letter-exchange", DEAD\_EXCHANGE);
        //正常队列设置死信 routing-key 参数 key 是固定值
        params.put("x-dead-letter-routing-key", "lisi");
        String normalQueue = "normal-queue";
        //正常队列绑定死信队列信息
        channel.queueDeclare(normalQueue, false, false, false, params);
        channel.queueBind(normalQueue, NORMAL\_EXCHANGE, "zhangsan");

        System.out.println("等待接收消息........... ");

        DeliverCallback deliverCallback = (consumerTag, delivery) ->
        {
            String message = new String(delivery.getBody(), StandardCharsets.UTF\_8);
            System.out.println("Consumer01 接收到消息" + message);
        };
        channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {
        });
    }
}

消费者2

public class Consumer02 {
    //死信交换机名称
    private static final String DEAD\_EXCHANGE = "dead\_exchange";

    public static void main(String[] argv) throws Exception {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        channel.exchangeDeclare(DEAD\_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明死信队列
        String deadQueue = "dead-queue";
        channel.queueDeclare(deadQueue, false, false, false, null);
        //死信队列绑定死信交换机与 routingKey
        channel.queueBind(deadQueue, DEAD\_EXCHANGE, "lisi");

        System.out.println("等待接收消息........... ");

        DeliverCallback deliverCallback = (consumerTag, delivery) ->
        {
            String message = new String(delivery.getBody(), StandardCharsets.UTF\_8);
            System.out.println("Consumer01 接收到消息" + message);
        };
        channel.basicConsume(deadQueue, true, deliverCallback, consumerTag -> {
        });
    }
}

流程
启动消费者1，生产交换机和队列

启动消费者，发现10条消息没被消费

等待10S后，发现没被消费就转移到死信队列

启动消费者2，消费者2去消费死信队列的消息

5.4 SpringBoot实现延迟队列

5.4.1 延迟队列概念

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

5.4.2 延迟队列使用场景

1.订单在十分钟之内未支付则自动取消
2.新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
3.用户注册成功后，如果三天内没有登陆则进行短信提醒。
4.用户发起退款，如果三天内没有得到处理则通知相关运营人员。
5.预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务

5.4.3 RabbitMQ 中的 TTL

TTL 是什么呢？TTL 是 RabbitMQ 中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间，单位是毫秒。

换句话说，如果一条消息设置了 TTL 属性或者进入了设置TTL 属性的队列，那么这条消息如果在TTL 设置的时间内没有被消费，则会成为"死信"。如果同时配置了队列的TTL 和消息的TTL，那么较小的那个值将会被使用，有两种方式设置 TTL。

如果设置了队列的 TTL 属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队 列中)，而第二种方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者 之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需 要注意的一点是，如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以 直接投递该消息到消费者，否则该消息将会被丢弃。

前一小节我们介绍了死信队列，刚刚又介绍了 TTL，至此利用 RabbitMQ 实现延时队列的两大要素已 经集齐，接下来只需要将它们进行融合，再加入一点点调味料，延时队列就可以新鲜出炉了。想想看，延 时队列，不就是想要消息延迟多久被处理吗，TTL 则刚好能让消息在延迟多久之后成为死信，另一方面， 成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就完事了，因为 里面的消息都是希望被立即处理的消息。

5.4.3 架构图

创建两个队列 QA 和 QB，两者队列 TTL 分别设置为 10S 和 20S，然后在创建一个交换机 X 和死信交换机 Y，它们的类型都是direct，创建一个死信队列 QD，它们的绑定关系如下：

5.4.4 实现代码

用上面的springboot项目继续搞这个延迟队列
配置类 用于生命交换机、队列以及之间的绑定关系

@Configuration
public class DeadQueueConfig {
    public static final String EXCHANGE\_X = "X";
    public static final String ROUTING\_KEY\_XA = "XA";
    public static final String ROUTING\_KEY\_XB = "XB";
    public static final String QUEUE\_A = "QA";
    public static final String QUEUE\_B = "QB";
    public static final String EXCHANGE\_Y = "Y";
    public static final String QUEUE\_D = "QD";
    public static final String ROUTING\_KEY\_YD = "YD";
    public static final int X\_MESSAGE\_TTL\_QA = 10;
    public static final int X\_MESSAGE\_TTL\_QB = 20;

    // 声明 交换机X
    @Bean
    public DirectExchange exchangeX() {
        return new DirectExchange(EXCHANGE\_X);
    }

    //声明队列 A ttl 为 10s 并绑定到对应的死信交换机
    @Bean
    public Queue queueA() {
        return QueueBuilder.durable(QUEUE\_A)
                //声明当前队列绑定的死信交换机
                .deadLetterExchange(EXCHANGE\_Y)
                //声明当前队列的死信路由 key
                .deadLetterRoutingKey(ROUTING\_KEY\_YD)
                //声明队列的 TTL
                .ttl(X\_MESSAGE\_TTL\_QA \* 1000)
                .build();
    }

    // 声明队列 A 绑定 X 交换机
    @Bean
    public Binding queueABindExchangeX(Queue queueA, DirectExchange exchangeX) {
        return BindingBuilder.bind(queueA).to(exchangeX).with(ROUTING\_KEY\_XA);
    }

    //声明队列 B ttl 为 20s 并绑定到对应的死信交换机
    @Bean
    public Queue queueB() {
        return QueueBuilder.durable(QUEUE\_B)
                .deadLetterExchange(EXCHANGE\_Y)
                .deadLetterRoutingKey(ROUTING\_KEY\_YD)
                .ttl(X\_MESSAGE\_TTL\_QB \* 1000)
                .build();
    }

    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queueBBindExchangeX(Queue queueB, DirectExchange exchangeX) {
        return BindingBuilder.bind(queueB).to(exchangeX).with(ROUTING\_KEY\_XB);
    }

    // 声明 交换机Y
    @Bean
    public DirectExchange exchangeY() {
        return new DirectExchange(EXCHANGE\_Y);
    }

    //声明死信队列 QD
    @Bean
    public Queue queueD() {
        return new Queue(QUEUE\_D);
    }

    //声明死信队列 QD 绑定关系
    @Bean
    public Binding queueDBindExchangeX(Queue queueD, DirectExchange exchangeY) {
        return BindingBuilder.bind(queueD).to(exchangeY).with(ROUTING\_KEY\_YD);
    }

}

消费者

@Slf4j
@Component
public class DeadLetterQueueConsumer {

    @RabbitListener(queues = DeadQueueConfig.QUEUE\_D)
    public void receiveD(Message message, Channel channel){
        String msg = StrUtil.str(message.getBody(), StandardCharsets.UTF\_8);
        log.info("当前时间：{},收到死信队列信息{}", DateUtil.now(), msg);
    }
}

生产者

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message) {
        log.info("当前时间：{},发送一条信息给两个 TTL 队列:{}", DateUtil.now(), message);
        //第三个参数：要发送的消息
        rabbitTemplate.convertAndSend(DeadQueueConfig.EXCHANGE\_X, DeadQueueConfig.ROUTING\_KEY\_XA, "消息来自 ttl 为 " + DeadQueueConfig.X\_MESSAGE\_TTL\_QA + "S 的队列: " + message);
        rabbitTemplate.convertAndSend(DeadQueueConfig.EXCHANGE\_X, DeadQueueConfig.ROUTING\_KEY\_XB, "消息来自 ttl 为 " + DeadQueueConfig.X\_MESSAGE\_TTL\_QB + "S 的队列: " + message);
    }
}

发送请求 http://127.0.0.1:8080/ttl/sendMsg/姬霓太美

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息， 然后被消费掉，这样一个延时队列就打造完成了。

不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S 两个时间选项，如果需要一个小时后处理，那么就需要增加TTL 为一个小时的队列，如果是预定会议室然 后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？
0

5.4.5 优化，由生产者定义消息存活时间

5.4.5.1 代码架构图

在这里新增了一个队列 QC,绑定关系如下,该队列不设置TTL 时间,有生产者设定消息ttl

5.4.5.2 代码

配置类新增

    //声明队列C，ttl为生产者设置，并绑定到对应的死信交换机
    @Bean
    public Queue queueC() {
        return QueueBuilder.durable(QUEUE\_C)
                //声明当前队列绑定的死信交换机
                .deadLetterExchange(EXCHANGE\_Y)
                //声明当前队列的死信路由 key
                .deadLetterRoutingKey(ROUTING\_KEY\_YD)
                .build();
    }

    //声明队列 QC 绑定关系
    @Bean
    public Binding queueCBindExchangeX(Queue queueC, DirectExchange exchangeX) {
        return BindingBuilder.bind(queueC).to(exchangeX).with(ROUTING\_KEY\_XC);
    }

消费者新增

    @GetMapping("sendExpirationMsg/{message}/{ttlTimeMillisecond}")
    public void sendMsg(@PathVariable String message, @PathVariable String ttlTimeMillisecond) {
        rabbitTemplate.convertAndSend(DeadQueueConfig.EXCHANGE\_X, DeadQueueConfig.ROUTING\_KEY\_XC, message, correlationData -> {
            correlationData.getMessageProperties().setExpiration(ttlTimeMillisecond);
            return correlationData;
        });
        log.info("当前时间：{},发送一条时长{}秒 TTL 信息给队列 C:{}", DateUtil.now(), TimeUnit.MILLISECONDS.toSeconds(Long.parseLong(ttlTimeMillisecond)), message);
    }

启动应用，按顺序请求以下接口
http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/2000
http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/20000
可以发现，正常消费，2秒后的消费了，20秒后的也消费了

此时看着正常，但是我们反顺序过来请求，先请求20秒的，在请求2秒的

http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/20000
http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/2000
结果如下，发现2秒的并没有先消费，而是消费完20秒的，再消费2秒的，因为mq底层就是FIFO，所以只能这样

结论
使用这种由生产者定义消息ttl的方式，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

5.4.6 Rabbitmq 插件实现延迟队列

上文中提到的问题，确实是一个问题，如果不能实现在消息粒度上的 TTL，并使其在设置的TTL 时间及时死亡，就无法设计成一个通用的延时队列。那如何解决呢，接下来我们就去解决该问题。

5.4.6.1 安装延时队列插件

在官网上下载 https://www.rabbitmq.com/community-plugins.html，下载
rabbitmq_delayed_message_exchange 插件，注意对应当前mq版本，然后到 RabbitMQ 的插件目录。
可以使用搜索命令，查找插件目录

find / -name plugins

/usr/lib/rabbitmq/lib/rabbitmq_server-3.7.18/plugins

执行下面命令让该插件生效

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

5.4.6.2 代码架构图

在这里新增了一个队列delayed.queue,一个自定义交换机delayed.exchange，绑定关系如下:

5.4.6.3 代码

在我们自定义的交换机中，这是一种新的交换类型，该类型消息支持延迟投递机制 消息传递后并不会立即投递到目标队列中，而是存储在 mnesia(一个分布式数据系统)表中，当达到投递时间时，才投递到目标队列中。

配置类

@Configuration
public class DelayedQueueConfig {
    public static final String DELAYED\_QUEUE\_NAME = "delayed.queue";
    public static final String DELAYED\_EXCHANGE\_NAME = "delayed.exchange";
    public static final String DELAYED\_ROUTING\_KEY = "delayed.routingkey";

    @Bean
    public Queue delayedQueue() {
        return new Queue(DELAYED\_QUEUE\_NAME);
    }

    //自定义交换机 我们在这里定义的是一个延迟交换机
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        //自定义交换机的类型
        args.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(DELAYED\_EXCHANGE\_NAME, "x-delayed-message", true, false,
                args);
    }

    @Bean
    public Binding bindingDelayedQueue(Queue delayedQueue, CustomExchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED\_ROUTING\_KEY).noargs();
    }
}

生产者

@Slf4j
@RequestMapping("ttl")
@RestController
public class DelayedQueueProducerController {


    @Autowired
    private RabbitTemplate rabbitTemplate;
    public static final String DELAYED\_EXCHANGE\_NAME = "delayed.exchange";
    public static final String DELAYED\_ROUTING\_KEY = "delayed.routingkey";

    @GetMapping("sendDelayMsg/{message}/{delayTime}")
    public void sendMsg(@PathVariable String message, @PathVariable Integer delayTime) {
        rabbitTemplate.convertAndSend(DELAYED\_EXCHANGE\_NAME, DELAYED\_ROUTING\_KEY, message,
                correlationData -> {
                    correlationData.getMessageProperties().setDelay(delayTime);
                    return correlationData;
                });
        log.info(" 当 前 时 间 ： {}, 发 送 一 条 延 迟 {} 秒的信息给队列 delayed.queue:{}", DateUtil.now(), TimeUnit.MILLISECONDS.toSeconds(delayTime), message);
    }
}

消费者

@Slf4j
@Component
public class DelayedQueueConsumer {
    public static final String DELAYED\_QUEUE\_NAME = "delayed.queue";

    @RabbitListener(queues = DELAYED\_QUEUE\_NAME)
    public void receiveDelayedQueue(Message message) {
        String msg = StrUtil.str(message.getBody(), StandardCharsets.UTF\_8);
        log.info("当前时间：{},收到延时队列的消息：{}", DateUtil.now(), msg);
    }

}

启动应用，分别访问
http://localhost:8080/ttl/sendDelayMsg/come on baby1/20000
http://localhost:8080/ttl/sendDelayMsg/come on baby1/2000
结果如下，20秒的先访问，2秒后访问，但是还是2秒快的先消费了

5.4.7 总结

延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用 RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正 确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为 单个节点挂掉导致延时队列不可用或者消息丢失。
     当然，延时队列还有很多其它选择，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz 或者利用 kafka 的时间轮，这些方式各有特点,看需要适用的场景

6 发布确认高级

springboot + rabbitmq 消息确认机制（避坑指南）
发送消息确认：用来确认生产者 producer 将消息发送到 broker ，broker 上的交换机 exchange 再投递给队列
queue的过程中，消息是否成功投递。

消息从 producer 到 rabbitmq broker有一个 confirmCallback 确认模式。

消息从 exchange 到 queue 投递失败有一个 returnCallback 退回模式。

我们可以利用这两个Callback来确保消的100%送达。

在生产环境中由于一些不明原因，导致 rabbitmq 重启，在 RabbitMQ 重启期间生产者消息投递失败，
导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投递呢？ 特
别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢:

6.1 确认机制方案

6.2 代码架构图

简单来说就是，生产者发送消息到交换机这一步，不论成功失败，都会有个回调方法被调用，从回调方法可以知道是否发送成功，从而进行下一步处理，比如重新发送

6.3 开启发布确认配置

spring:
  rabbitmq:
    publisher-confirm-type: correlated

枚举类ConfirmType定义了三种RabbitMQ发布确认类型：

• NONE：表示不使用发布确认。当配置为该类型时，生产者发送消息后将不会等待或接收任何确认通知。
• SIMPLE：表示使用简单的发布确认。当配置为该类型时，生产者发送消息后将等待Broker的确认通知，并根据确认通知进行下一步的操作。simple模式下如果消息成功到达Broker后一样会触发
• CORRELATED：表示消息成功到达Broker后触发ConfirmCalllBack回调；表示使用关联ID的发布确认。当配置为该类型时，生产者发送消息后将等待Broker的确认通知，并通过关联ID来确定是哪条消息被确认。

6.4 代码编写

队列交换机配置

@Configuration
public class QueueConfig {
    public static final String CONFIRM\_EXCHANGE\_NAME = "confirm.exchange";
    public static final String CONFIRM\_QUEUE\_NAME = "confirm.queue";
    public static final String ROUTING\_KEY = "key1";

    //声明业务 Exchange
    @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 queueBinding(@Qualifier("confirmQueue") Queue queue,
                                @Qualifier("confirmExchange") DirectExchange exchange) {

        return BindingBuilder.bind(queue).to(exchange).with(ROUTING\_KEY);
    }
}

消息生产者
发送了三条消息

1. 第一条可达
2. 第二条路由不到
3. 第三条没有指定的交换机

@RestController
@RequestMapping("/confirm")
@Slf4j
public class Producer {
    public static final String CONFIRM\_EXCHANGE\_NAME = "confirm.exchange";
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private MyCallBack myCallBack;

    //依赖注入 rabbitTemplate 之后再设置它的回调对象
    @PostConstruct
    public void init() {
        rabbitTemplate.setConfirmCallback(myCallBack);
    }

    @GetMapping("confirmCallback/{message}")
    public void confirmCallback(@PathVariable String message) throws InterruptedException {
        /\*
 \*此消息正常发送到队列
 \*/
        //指定消息 id 为 1
        CorrelationData correlationData1 = new CorrelationData("1");
        String routingKey = "key1";
        rabbitTemplate.convertAndSend(CONFIRM\_EXCHANGE\_NAME, routingKey, message + routingKey, correlationData1);
        log.info("发送消息内容:{}", message);
        TimeUnit.SECONDS.sleep(3);
        log.info("\n");

        /\*
 \*此消息发到交换机了，但是路由失败，没发送到队列
 \*/
        CorrelationData correlationData2 = new CorrelationData("2");
        routingKey = "key2";
        rabbitTemplate.convertAndSend(CONFIRM\_EXCHANGE\_NAME, routingKey, message + routingKey, correlationData2);
        log.info("发送消息内容:{}", message + routingKey);
        TimeUnit.SECONDS.sleep(3);
        log.info("\n");

        /\*
 \*没有这个交换机，发送失败
 \*/
        CorrelationData correlationData3 = new CorrelationData("3");
        routingKey = "key3";
        rabbitTemplate.convertAndSend(CONFIRM\_EXCHANGE\_NAME + 3, routingKey, message + routingKey, correlationData3);
        log.info("发送消息内容:{}", message + routingKey);
    }
}

不管发没发到都有的回调确认类

@Component
@Slf4j
public class MyCallBack implements RabbitTemplate.ConfirmCallback {
    /\*\*
 \* 交换机不管是否收到消息的一个回调方法
 \* CorrelationData
 \* 消息相关数据
 \* ack
 \* 交换机是否收到消息
 \*/
    @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);
        }
    }
}

消息消费者

@Component
@Slf4j
public class ConfirmConsumer {
    public static final String CONFIRM\_QUEUE\_NAME = "confirm.queue";

    @RabbitListener(queues = CONFIRM\_QUEUE\_NAME)
    public void receiveMsg(Message message) {
        String msg = new String(message.getBody());
        log.info("接受到队列 {} 消息:{}", CONFIRM\_QUEUE\_NAME, msg);
    }
}

启动运行，发送消息http://localhost:8080/confirm/confirmCallback/123

• 第一条消息，发送到了队列，回调接口的信息也打印了
• 第二条消息由于路由key不存在，无法发送到队列，没发送成功，但是发送到了交换机，所以回调函数依旧被执行，打印回调消息
• 第三条是连交换机都不存在，发不出去，但还是执行了回调方法

2023-07-18 21:53:15.296  INFO 16232 --- [nio-8080-exec-3] com.publisher_confirm.Producer           : 发送消息内容:123
2023-07-18 21:53:15.299  INFO 16232 --- [nectionFactory1] com.publisher_confirm.MyCallBack         : 交换机已经收到 id 为:1的消息
2023-07-18 21:53:15.300  INFO 16232 --- [tContainer#11-1] com.publisher_confirm.ConfirmConsumer    : 接受到队列 confirm.queue 消息:123key1
2023-07-18 21:53:18.301  INFO 16232 --- [nio-8080-exec-3] com.publisher_confirm.Producer           : 

2023-07-18 21:53:18.301  INFO 16232 --- [nio-8080-exec-3] com.publisher_confirm.Producer           : 发送消息内容:123key2
2023-07-18 21:53:18.304  WARN 16232 --- [nectionFactory1] o.s.amqp.rabbit.core.RabbitTemplate      : Returned message but no callback available
2023-07-18 21:53:18.304  INFO 16232 --- [nectionFactory2] com.publisher_confirm.MyCallBack         : 交换机已经收到 id 为:2的消息
2023-07-18 21:53:21.305  INFO 16232 --- [nio-8080-exec-3] com.publisher_confirm.Producer           : 

2023-07-18 21:53:21.305  INFO 16232 --- [nio-8080-exec-3] com.publisher_confirm.Producer           : 发送消息内容:123key3
2023-07-18 21:53:21.308 ERROR 16232 --- [168.80.131:5672] o.s.a.r.c.CachingConnectionFactory       : Shutdown Signal: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'confirm.exchange3' in vhost '/', class-id=60, method-id=40)
2023-07-18 21:53:21.308  INFO 16232 --- [nectionFactory1] com.publisher_confirm.MyCallBack         : 交换机还未收到 id 为:3消息,由于原因:channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'confirm.exchange3' in vhost '/', class-id=60, method-id=40)

6.5 回退消息

从上面例子可以看出，第二条消息找不到指定路由key的队列，导致消息不见了，但是生产者也不知道，这时候如果想通知生产者处理这种消息咋办呢，这时候通过设置开启回退配置，可以将无法路由的消息返回给生产者。

首先开启回退回调配置

spring:
  rabbitmq:
    publisher-returns: true

回退消息回调接口

@Component
@Slf4j
public class MyCallBack implements RabbitTemplate.ReturnsCallback {

    /\*\*
 \* 回退消息：当消息发送给Exchange后，Exchange路由到Queue失败后才执行returnedMessage
 \*/
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        log.info("没发送到队列的消息{}",returned);
    }
}

消息生产者
跟之前的一样，就多了个这是回退回调方法的设置，我不设置setMandatory为true也生效，因为配置文件里设置了publisher-returns: true，二选一方法设置即可，推荐用yml配置

@RestController
@RequestMapping("/confirm")
@Slf4j
public class Producer {
    public static final String CONFIRM\_EXCHANGE\_NAME = "confirm.exchange";
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private MyCallBack myCallBack;

    //依赖注入 rabbitTemplate 之后再设置它的回调对象
    @PostConstruct
    public void init() {
        /\*
 true：
 交换机无法将消息进行路由时，会将该消息返回给生产者
 false：
 如果发现消息无法进行路由，则直接丢弃
 \*/
        //我这个不设置也会执行回退方法，因为配置文件里设置了publisher-returns: true
// rabbitTemplate.setMandatory(true);
        //设置回退消息交给谁处理

        rabbitTemplate.setReturnsCallback(myCallBack);
    }

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message) throws InterruptedException {
        /\*
 \*此消息正常发送到队列
 \*/
        //指定消息 id 为 1
        CorrelationData correlationData1 = new CorrelationData("1");
        String routingKey = "key1";
        rabbitTemplate.convertAndSend(CONFIRM\_EXCHANGE\_NAME, routingKey, message + routingKey, correlationData1);
        log.info("发送消息内容:{}", message);
        TimeUnit.SECONDS.sleep(3);
        log.info("\n");

        /\*
 \*此消息发到交换机了，但是路由失败，没发送到队列
 \*/
        CorrelationData correlationData2 = new CorrelationData("2");
        routingKey = "key2";
        rabbitTemplate.convertAndSend(CONFIRM\_EXCHANGE\_NAME, routingKey, message + routingKey, correlationData2);
        log.info("发送消息内容:{}", message + routingKey);
        TimeUnit.SECONDS.sleep(3);
        log.info("\n");

        /\*
 \*没有这个交换机，发送失败
 \*/
        CorrelationData correlationData3 = new CorrelationData("3");
        routingKey = "key3";
        rabbitTemplate.convertAndSend(CONFIRM\_EXCHANGE\_NAME + 3, routingKey, message + routingKey, correlationData3);
        log.info("发送消息内容:{}", message + routingKey);
    }
}

运行，发送消息http://localhost:8080/confirm/sendMsg/123

• 第一条消息正常，不会回调
• 第二条消息无法路由，这时候就会触发returnedMessage回调方法
• 第三条消息连交换机都到不了，无法触发

2023-07-18 22:32:36.036  INFO 20564 --- [nio-8080-exec-2] com.publisher_confirm.Producer           : 发送消息内容:123
2023-07-18 22:32:36.039  INFO 20564 --- [tContainer#11-1] com.publisher_confirm.ConfirmConsumer    : 接受到队列 confirm.queue 消息:123key1
2023-07-18 22:32:39.051  INFO 20564 --- [nio-8080-exec-2] com.publisher_confirm.Producer           : 

2023-07-18 22:32:39.051  INFO 20564 --- [nio-8080-exec-2] com.publisher_confirm.Producer           : 发送消息内容:123key2
2023-07-18 22:32:39.053  INFO 20564 --- [nectionFactory1] com.publisher_confirm.MyCallBack         : 没发送到队列的消息ReturnedMessage [message=(Body:'123key2' MessageProperties [headers={spring_returned_message_correlation=2}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0]), replyCode=312, replyText=NO_ROUTE, exchange=confirm.exchange, routingKey=key2]
2023-07-18 22:32:42.062  INFO 20564 --- [nio-8080-exec-2] com.publisher_confirm.Producer           : 

2023-07-18 22:32:42.062  INFO 20564 --- [nio-8080-exec-2] com.publisher_confirm.Producer           : 发送消息内容:123key3
2023-07-18 22:32:42.067 ERROR 20564 --- [168.80.131:5672] o.s.a.r.c.CachingConnectionFactory       : Shutdown Signal: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'confirm.exchange3' in vhost '/', class-id=60, method-id=40)

6.6 org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback和com.rabbitmq.client.ConfirmCallback 区别

org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback 和 com.rabbitmq.client.ConfirmCallback 是用于处理 RabbitMQ 消息确认的回调接口，它们有以下区别：

包位置：这两个接口来自于不同的包。org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback属于 Spring AMQP 包，用于与 RabbitMQ 进行交互。org.springframework.amqp.rabbit.core.RabbitTemplate 是 Spring AMQP 提供的 RabbitMQ 操作模板类。而 com.rabbitmq.client.ConfirmCallback 属于 RabbitMQ Java 客户端库，用于原生的 RabbitMQ 客户端。

使用方式：org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback 是通过 Spring AMQP 提供的 RabbitTemplate 类来实现的回调，可以用于处理发送给 RabbitMQ 的消息是否成功确认的回调。而 com.rabbitmq.client.ConfirmCallback 是在原生的 RabbitMQ Java 客户端中使用的回调，用于处理 RabbitMQ 确认的回调。

总的来说，org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback 是在 Spring AMQP 中用于处理 RabbitMQ 消息确认的回调，而 com.rabbitmq.client.ConfirmCallback 则是在原生的 RabbitMQ Java 客户端中用于处理消息确认的回调，都是为了再生产者到交换机或者队列之间保证消息不被丢失

6.7 RabbitMQ发布确认机制是一种用于解决消息可靠性传递的机制

它确保了消息在发送到消息队列之后是否成功被消息代理（Broker）接收和持久化。以下是通过RabbitMQ发布确认机制解决的几个问题：

• 可靠性传递：通过发布确认机制，生产者可以确保消息成功发送到消息代理，并且代理已经进行了持久化保存。如果消息发送失败或代理无法接收消息，生产者可以得到通知并采取相应的措施，如重新发送消息。
• 异步处理：发布确认机制使生产者能够以异步的方式发送消息，并在消息成功确认后得到通知。这样，生产者可以继续发送下一条消息，而无需等待确认结果，提高了消息发送的效率。
• 数据一致性：使用发布确认机制可以确保消息在发送和接收过程中的一致性。生产者可以在接收到消息确认之前保留消息的副本，以避免数据丢失或不一致的情况发生。
• 过载保护：发布确认机制还可以用于解决消息代理和消费者之间的不平衡问题。当消息代理无法处理更多的消息时，它可以通过发送确认来通知生产者减慢消息发送的速度，以防止消息代理过载。

综上所述，RabbitMQ发布确认机制有效地解决了消息可靠性传递、异步处理、数据一致性和过载保护等问题，确保了消息传递的可靠性和一致性。

实战代码

交换机-Direct类型，一个交换机，每个队列单独一个路由键

mq配置

@Configuration
public class RabbitMqConfig {
    //这段配置表示使用 Jackson 库将对象转换为 JSON 格式，以便在消息队列中进行传递
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    //声明交换机
    @Bean
    public DirectExchange mqttEquipmentMsgExchange() {
        return new DirectExchange(CommonConstant.MQTT\_EQUIPMENT\_MSG\_EXCHANGE);
    }

    /\*\*
 \* 开始 推送水质原始数据主题配置
 \*/
    // 声明队列
    @Bean
    public Queue mqttWaterDataRawQueue() {
        return QueueBuilder.durable(CommonConstant.MQTT\_WATER\_DATA\_RAW\_QUEUE).build();
    }

    // 队列绑定到交换机并设置路由键
    @Bean
    public Binding mqttWaterDataRawBinding(Queue mqttWaterDataRawQueue, DirectExchange mqttEquipmentMsgExchange) {
        return BindingBuilder.bind(mqttWaterDataRawQueue).to(mqttEquipmentMsgExchange).with(CommonConstant.MQTT\_WATER\_DATA\_RAW\_ROUTING\_KEY);
    }
    /\*\* 结束 推送水质原始数据主题配置 \*/

    /\*\*
 \* 开始 推送水质数据主题配置


**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/ff87708c0da1b4302ba9332605c2c6e5.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

，并在消息成功确认后得到通知。这样，生产者可以继续发送下一条消息，而无需等待确认结果，提高了消息发送的效率。
* 数据一致性：使用发布确认机制可以确保消息在发送和接收过程中的一致性。生产者可以在接收到消息确认之前保留消息的副本，以避免数据丢失或不一致的情况发生。
* 过载保护：发布确认机制还可以用于解决消息代理和消费者之间的不平衡问题。当消息代理无法处理更多的消息时，它可以通过发送确认来通知生产者减慢消息发送的速度，以防止消息代理过载。


综上所述，RabbitMQ发布确认机制有效地解决了消息可靠性传递、异步处理、数据一致性和过载保护等问题，确保了消息传递的可靠性和一致性。


## 实战代码


交换机-Direct类型，一个交换机，每个队列单独一个路由键


### mq配置

@Configuration
public class RabbitMqConfig {
//这段配置表示使用 Jackson 库将对象转换为 JSON 格式，以便在消息队列中进行传递
@Bean
public MessageConverter messageConverter() {
return new Jackson2JsonMessageConverter();
}

//声明交换机
@Bean
public DirectExchange mqttEquipmentMsgExchange() {
    return new DirectExchange(CommonConstant.MQTT\_EQUIPMENT\_MSG\_EXCHANGE);
}

/\*\*

* 开始 推送水质原始数据主题配置
*/
// 声明队列
@Bean
public Queue mqttWaterDataRawQueue() {
return QueueBuilder.durable(CommonConstant.MQTT_WATER_DATA_RAW_QUEUE).build();
}

// 队列绑定到交换机并设置路由键
@Bean
public Binding mqttWaterDataRawBinding(Queue mqttWaterDataRawQueue, DirectExchange mqttEquipmentMsgExchange) {
    return BindingBuilder.bind(mqttWaterDataRawQueue).to(mqttEquipmentMsgExchange).with(CommonConstant.MQTT\_WATER\_DATA\_RAW\_ROUTING\_KEY);
}
/\*\* 结束 推送水质原始数据主题配置 \*/

/\*\*

* 开始 推送水质数据主题配置

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）
[外链图片转存中…(img-VB6SPC03-1713320882530)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！