Day96.RabbitMQ：高级特性: 消息可靠投递、Ack、死信队列、SpringBoot整合、集群_队列镜像

已于 2022-08-04 14:56:43 修改
阅读量960 收藏 2
点赞数 2
分类专栏： rabbitmq 文章标签： rabbitmq
于 2022-07-03 08:30:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a111042555/article/details/125580790
版权

目录

一、RabbitMQ高级特性

1、消息的可靠投递

2. 确认模式 (publisher-confirms="true")

3. 回退模式 (publisher-returns="true")

2、Consumer Ack (消费端确认方式)

1. 自动确认 (默认)

2. 手动确认 (acknowledge="manual"：手动签收)

3、消费端限流 (prefetch="2"限流为2)

4、TTL (消息存活时间)

1. 控制后台演示消息过期

2. 代码实现

5、死信队列 (DLX) ★

6、延迟队列

SpringBoot 微服务整合

1、搭建生产者工程

2、搭建消费者工程

3、消息百分百成功投递

消息幂等性保障

一、RabbitMQ高级特性

1、消息的可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

  • confirm 确认模式  确认模式是由exchange决定的
  • return 退回模式  回退模式是由routingKey决定的

rabbitMQ 整个消息投递的路径为：

producer—>rabbitmq broker—>exchange—>queue—>consumer

l消息从 producer 到 exchange 则会返回一个 confirmCallback 。

l消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

小结：

  • 设置 ConnectionFactory的publisher-confirms="true" 开启 确认模式。
  • 使用 rabbitTemplate.setConfirmCallback 设置回调函数。当消息发送到 exchange 后回调 confirm 方法。在方法中判断 ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。
  • 设置 ConnectionFactory 的 publisher-returns="true" 开启 退回模式。
  • 使用 rabbitTemplate.setReturnCallback 设置退回函数，当消息从exchange 路由到 queue 失败后，如果设置了 rabbitTemplate.setMandatory(true) 参数，则会将消息退回给 producer并执行回调函数returnedMessage

1. 配置文件 开启模式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory
     确认模式开启:publisher-confirms="true"
     回退模式开启: publisher-returns="true"
    -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"
                               publisher-confirms="true"  
                               publisher-returns="true"
    />
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>

    <!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

    <!--消息可靠性投递（生产端）-->
    <rabbit:queue id="test_queue_confirm" name="test_queue_confirm"></rabbit:queue>

    <rabbit:direct-exchange name="test_exchange_confirm">
        <rabbit:bindings>
            <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

</beans>

2. 确认模式 (publisher-confirms="true")

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:/spring-rabbitmq-producer.xml")
public class ProducerTest {
    //@Autowired   在配置文件配好了
    //RabbitAdmin rabbitAdmin;//用于操作交换机、队列
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //确认模式，收到消息与否都会被执行
    @Test
    public void testConfirm() {
        //1. 开启去确认回调函数  publisher-confirms="true"

        //2. 注册回调函数，当交换机收到消息，confirm方法会被调用
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("correlationData = " + correlationData); //关联数据，在发送消息时指定的
                //确认机制:ack true表示收到了 false表示没收到
                if (ack){
                    System.out.println("接收成功消息" + ack);
                }else {
                    System.out.println("接收失败消息" + cause);
                    //做一些处理,让消息再次发送。
                }
            }
        });

        //3. 发送消息
        rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm", "confirm info...");//成功

        //测试不正常情况
        //rabbitTemplate.convertAndSend("test_exchange_confirm000", "confirm", "message confirm....");//失败
    }
}

3. 回退模式 (publisher-returns="true")

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:/spring-rabbitmq-producer.xml")
public class ProducerTest {
    //@Autowired   在配置文件配好了
    //RabbitAdmin rabbitAdmin;//用于操作交换机、队列
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //回退模式
    @Test
    public void testReturn() {
        //1.开启回退模式 publisher-returns="true"

        //2.注册回退函数(ReturnCallBack)，当没有任何队列与交换机绑定，或即使绑定也没有任何匹配时，将执行回退方法
        //      成功接收，不执行return方法

        //3. 必须设置强制回退 setMandatory(true)  设置交换机处理失败消息的模式
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText,
                                        String exchange, String routingKey) {
                System.out.println("消息对象message = " + message);
                System.out.println("错误码replyCode = " + replyCode);
                System.out.println("错误信息replyText = " + replyText);
                System.out.println("交换机exchange = " + exchange);
                System.out.println("路由键routingKey = " + routingKey);
                //处理
            }
        });

        //3. 发送消息
        //rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm", "confirm info...");//成功
        //测试不正常情况
        rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm123", "confirm info...");//成功

    }

}

2、Consumer Ack (消费端确认方式)

ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。

有二种确认方式：

  • 自动确认：acknowledge=“none” 默认
  • 手动确认：acknowledge=“manual”

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。

如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

1. 创建rabbitmq-consumer-spring项目 并配置

rabbitmq.host=192.168.86.86
rabbitmq.port=5672
rabbitmq.username=admin
rabbitmq.password=123456
rabbitmq.virtual-host=/
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <context:component-scan base-package="com.atguigu.listener" />

    <!--定义监听器容器
    默认为自动确认
    acknowledge="manual"：手动签收
    -->
    <rabbit:listener-container connection-factory="connectionFactory"
                               acknowledge="manual"
        <!--<rabbit:listener ref="ackListener" queue-names="test_queue_confirm"></rabbit:listener>-->
        <rabbit:listener ref="qosListener" queue-names="test_queue_confirm"></rabbit:listener>
    </rabbit:listener-container>
</beans>

1. 自动确认 (默认)

确认配置文件中为自动接收

//自动确认
@Component
//implements MessageListener 自动确认
//ChannelAwareMessageListener 手动确认
public class AckListener implements MessageListener {

    //自动确认
    @Override
    public void onMessage(Message message) {
        try {
            System.out.println(new String(message.getBody(),"UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

2. 手动确认 (acknowledge="manual"：手动签收)

//手动确认
@Component
//implements MessageListener 自动确认
//ChannelAwareMessageListener 手动确认
public class AckListener implements ChannelAwareMessageListener {

    //手动确认
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        //消息唯一标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            System.out.println(new String(message.getBody(),"UTF-8"));
            //消息得到后需要进行业务逻辑处理，如存储数据库，发送邮件、短信、保存到Redis等等

            int i = 1/0;//模拟业务异常

            //业务逻辑成功，才会确认，否则不予确认
            channel.basicAck(deliveryTag,true);//消息唯一标识和是否确认多个
        } catch (Exception e) {
            e.printStackTrace();
            //NoAck 不予确认
            /*
             * @param deliveryTag 消息标签，唯一标识，类似数据库主键
             * @param multiple true 拒绝接收的所有消息 false，拒绝刚刚的消息
             * @param requeue true 表示是否重回原有队列，false表示丢弃或成为死信 (被死信队列接收)
             */
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

3、消费端限流 (prefetch="2"限流为2)

1. 修改spring-rabbitmq-consumer.xml，connectionFactory添加限流属性

prefetch: 预先载入 (fetch 取来)

    <!--定义监听器容器
    默认为自动确认
    acknowledge="manual"：手动签收
    prefetch="2"限流为2
    -->
    <rabbit:listener-container connection-factory="connectionFactory"
                               acknowledge="manual"
                               prefetch="2">
        <!--<rabbit:listener ref="ackListener" queue-names="test_queue_confirm"></rabbit:listener>-->
        <rabbit:listener ref="qosListener" queue-names="test_queue_confirm"></rabbit:listener>
    </rabbit:listener-container>

2. 新建 com.atguigu.listener.QosListener

/**
 * Consumer 限流机制
 *  1. 确保消息被确认。不确认是不继续处理其他消息的
 *  2. listener-container配置属性
 *      prefetch=1,表示消费端每次从mq拉去一条消息来消费,直到手动确认消费完毕后,才会继续拉取下一条消息。
 */
@Component
public class QosListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //1.获取消息
            System.out.println(new String(message.getBody()));
            //2.确认消息
            channel.basicAck(deliveryTag,true);
        }catch (Exception e){
            e.printStackTrace();
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

 每处理一个，再分配一个，保证手中一直有两个。而不是处理完两个再分配两个

4、TTL (消息存活时间)

TTL 全称 Time To Live（存活时间/过期时间）。

当消息到达存活时间后，还没有被消费，会被自动清除。

RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

1. 控制后台演示消息过期

① 修改管理后台界面，增加队列

参数：表示过期时间，单位毫秒 ，10000表示10秒

② 增加交换机

③ 绑定队列

④ 发送消息
Delivery mode：2-Persistent表示需要进行持久化

⑤ 查看消息，可以看到消息，但十秒之后，消息自动消失，因为我们设置了十秒消息过期

2. 代码实现

1. 修改配置文件 spring-rabbitmq-producer.xml

    <!--TTL 队列-->
    <rabbit:queue name="test_queue_ttl" id="test_queue_ttl">
        <!--设置queue的参数-->
        <rabbit:queue-arguments>
            <!--
              设置x-message-ttl队列的过期时间
              默认情况下value-type的类型是String类型,但时间的类型是number类型,所以需要设置成integer类型
            -->
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>
            <!--指定类型?因为队列已经存在，配置队列需要和已存在队列属性相同-->
            <entry key="x-queue-type" value="classic" value-type="java.lang.String"></entry>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <!--设置交换机-->
    <rabbit:topic-exchange name="test_exchange_ttl">
        <!--交换机绑定队列-->
        <rabbit:bindings>
            <rabbit:binding pattern="ttl.#" queue="test_queue_ttl"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

2. 在测试类 ProducerTest 中,添加测试方法,发送消息

    /**
     * TTL：过期时间
     *  1. 队列统一过期
     *  2. 消息单独过期
     * 如果设置了消息的过期时间,也设置了队列的过期时间,它以时间短的为准。
     */
    @Test
    public void testTTL() {
         //队列统一过期
         for (int i = 0; i < 10; i++) {
           rabbitTemplate.convertAndSend("test_exchange_ttl","ttl.hehe","message ttl");
         }
    }
    @Test
    public void testMessageTtl() {
        // 消息后处理对象,设置一些消息的参数信息
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {

            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //1.设置message的信息
                // 第二个方法：消息的过期时间 ,5秒之后过期
                message.getMessageProperties().setExpiration("5000");
                //2.返回该消息
                return message;
            }
        };

5、死信队列 (DLX) ★

死信队列，英文缩写：DLX 。DeadLetter Exchange（死信交换机），无法被消费的消息，当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。

面试题: 消息成为死信的三种情况： ★

  1. 队列消息数量到达限制；比如队列最大只能存储10条消息，而发了11条消息，根据先进先出，最先发的消息会进入死信队列。
  2. 消费者拒接消费消息，basicNack/basicReject，并且不把消息重新放入原目标队列，requeue=false；
  3. 消息超时，原队列存在消息过期设置，消息到达超时时间未被消费；

死信的处理方式

死信的产生既然不可避免，那么就需要从实际的业务角度和场景出发，对这些死信进行后续的处理，常见的处理方式大致有下面几种，

① 丢弃，如果不是很重要，可以选择丢弃

② 记录死信入库，然后做后续的业务分析或处理

③ 通过死信队列，由负责监听死信的应用程序进行处理

综合来看，更常用的做法是第三种，即通过死信队列，将产生的死信通过程序的配置路由到指定的死信队列，然后应用监听死信队列，对接收到的死信做后续的处理，

1. spring-rabbitmq-producer.xml ，增加如下代码

    <!--死信队列-->
    <!--1. 声明正常的队列(test_queue_dlx)和交换机(test_exchange_dlx)-->
    <rabbit:queue name="test_queue_dlx" id="test_queue_dlx">
        <!--3. 正常队列绑定死信交换机 设置条件-->
        <rabbit:queue-arguments>
            <!--3.1 x-dead-letter-exchange：死信交换机名称-->
            <entry key="x-dead-letter-exchange" value="exchange_dlx"/>
            <!--3.2 x-dead-letter-routing-key：发送给死信交换机的routingkey-->
            <entry key="x-dead-letter-routing-key" value="dlx.hehe"></entry>
            <!--4.1 设置队列的过期时间 ttl-->
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"/>
            <!--4.2 设置队列的长度限制 max-length -->
            <entry key="x-max-length" value="10" value-type="java.lang.Integer"/>
        </rabbit:queue-arguments>
    </rabbit:queue>
    
    <!--正常交换机-->
    <rabbit:topic-exchange name="test_exchange_dlx">
        <rabbit:bindings>
            <rabbit:binding pattern="test.dlx.#" queue="test_queue_dlx"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>
    
    <!--2. 声明死信队列(queue_dlx)和死信交换机(exchange_dlx)-->
    <rabbit:queue name="queue_dlx" id="queue_dlx"></rabbit:queue>
    <rabbit:topic-exchange name="exchange_dlx">
        <rabbit:bindings>
            <rabbit:binding pattern="dlx.#" queue="queue_dlx"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

三种成为死信情况 测试

//发送测试死信消息: 1、过期时间 2、长度限制 3、消息拒收
    @Test
    public void testDlx(){
        //1. 测试过期时间,死信消息
        //rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息,我会死吗？");

        //2. 测试长度限制后,消息死信
        /*for (int i = 0; i < 11; i++) {
            rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息,我会死吗？i =" + i);
        }*/

        //3.发送消息:拒收情况
        rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息,我会死吗？");

    }

消费端拒收:

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        //消息唯一标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            System.out.println(new String(message.getBody(),"UTF-8"));
            //消息得到后需要进行业务逻辑处理，如存储数据库，发送邮件、短信、保存到Redis等等

            int i = 1/0;//模拟业务异常

            //业务逻辑成功，才会确认，否则不予确认
            channel.basicAck(deliveryTag,true);//消息唯一标识和是否确认多个
        } catch (Exception e) {
            e.printStackTrace();
            //NoAck 不予确认
            /*
             * @param deliveryTag 消息标签，唯一标识，类似数据库主键
             * @param multiple true 拒绝接收的所有消息 false，拒绝刚刚的消息
             * @param requeue true 表示是否重回原有队列，false表示丢弃或成为死信 (被死信队列接收)
             */
            channel.basicNack(deliveryTag,true,false);
        }
    }

6、延迟队列

延迟队列存储的对象肯定是对应的延时消息，所谓”延时消息”是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。

场景：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行取消处理。这时就可以使用延时队列将订单信息发送到延时队列。

需求场景：
1. 下单后，30分钟未支付，取消订单，回滚库存。
2. 新用户注册成功30分钟后，发送短信问候。

实现方式：
1. 延迟队列

但是RabbitMQ没有提供延迟队列功能。

但是可以使用：TTL+死信队列 组合实现延迟队列的效果。

SpringBoot 微服务整合

1、搭建生产者工程

实现步骤：

  1. 创建生产者SpringBoot工程
  2. 引入依赖坐标
  3. 编写yml配置，基本信息配置
  4. 定义交换机，队列以及绑定关系的配置类
  5. 注入RabbitTemplate，调用方法，完成消息发送

1. 创建项目producer-springboot 添加依赖

<!--1. 父工程依赖-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.6.RELEASE</version>
</parent>

<dependencies>
    <!--2. rabbitmq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

2. 配置整合

spring:
  rabbitmq:
    host: 192.168.86.86
    port: 5672
    username: admin
    password: 123456
    virtual-host: /

3. 创建配置类

package com.atguigu.config;

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

/**
 * @Date 2022/7/3 14:32
 * @Author by:Plisetsky
 */
@Configuration
public class RabbitMQConfig {
    public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public static final String QUEUE_NAME = "boot_queue";

    //创建交换机 注意导包amqp
    @Bean("bootExchange") //设置beanId，方便引用
    public Exchange bootExchange(){
        Exchange exchange = ExchangeBuilder.topicExchange(EXCHANGE_NAME).
                durable(true).build();

        return exchange;
    }

    //创建队列 注意导包amqp
    @Bean("bootQueue")
    public Queue bootQueue(){
        Queue queue = QueueBuilder.durable(QUEUE_NAME).build();
        return queue;
    }

    //设置绑定  @Qualifier 指定Bean的name
    @Bean
    public Binding bootBinding(@Qualifier("bootExchange") Exchange exchange,
                               @Qualifier("bootQueue") Queue queue){

        Binding binding = BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
        return binding;
    }

}

4. 创建入口类

package com.atguigu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProducerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class);
    }
}

5. 测试类发送消息

package com.atguigu.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @Date 2022/7/3 14:43
 * @Author by:Plisetsky
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class ProducerTest {

    //springBoot框架底层会创建模板对象
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void testSend(){
        rabbitTemplate.convertAndSend("boot_topic_exchange","boot.haha","boot info v587");
    }

}

2、搭建消费者工程

1. 创建项目consumer-springboot 添加依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.6.RELEASE</version>
    </parent>
    <dependencies>
        <!--RabbitMQ 启动依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

2. 配置整合

spring:
  rabbitmq:
    host: 192.168.86.86
    port: 5672
    username: admin
    password: 123456
    virtual-host: /

3. 创建消息监听器

package com.atguigu.listener;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;


@Component
public class RabbitMQListener {

    //监听多个值加入{}，用读逗号隔开
    @RabbitListener(queues = {"boot_queue"})
    //massage导包注意amqp
    public void listenerInfo(Message message) throws Exception {
        System.out.println(new String(message.getBody(),"UTF-8"));
    }
}

4. 创建入口类，启动测试

package com.atguigu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

3、消息百分百成功投递

谈到消息的可靠性投递，无法避免的，在实际的工作中会经常碰到，比如一些核心业务需要保障消息不丢失，接下来我们看一个可靠性投递的流程图，说明可靠性投递的概念：

Step 1： 首先把消息信息(业务数据）存储到数据库中，紧接着，我们再把这个消息记录也存储到一张消息记录表里（或者另外一个同源数据库的消息记录表）

Step 2：发送消息到MQ Broker节点（采用confirm方式发送，会有异步的返回结果）

Step 3、4：生产者端接受MQ Broker节点返回的Confirm确认消息结果，然后进行更新消息记录表里的消息状态。比如默认Status = 0 当收到消息确认成功后，更新为1即可！

Step 5：但是在消息确认这个过程中可能由于网络闪断、MQ Broker端异常等原因导致 回送消息失败或者异常。这个时候就需要发送方（生产者）对消息进行可靠性投递了，保障消息不丢失，100%的投递成功！（有一种极限情况是闪断，Broker返回的成功确认消息，但是生产端由于网络闪断没收到，这个时候重新投递可能会造成消息重复，需要消费端去做幂等处理）所以我们需要有一个定时任务，（比如每5分钟拉取一下处于中间状态的消息，当然这个消息可以设置一个超时时间，比如超过1分钟 Status = 0 ，也就说明了1分钟这个时间窗口内，我们的消息没有被确认，那么会被定时任务拉取出来）

Step 6：接下来我们把中间状态的消息进行重新投递 retry send，继续发送消息到MQ ，当然也可能有多种原因导致发送失败

Step 7：我们可以采用设置最大努力尝试次数，比如投递了3次，还是失败，那么我们可以将最终状态设置为Status = 2 ，最后 交由人工解决处理此类问题（或者把消息转储到失败表中）。

消息幂等性保障

幂等性指一次和多次请求某一个资源,对于资源本身应该具有同样的结果。也就是说,其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

在MQ中指,消费多条相同的消息,得到与消费该消息一次相同的结果。

消息幂等性保障 乐观锁机制

生产者发送消息：

id=1,money=500,version=1

消费者接收消息

id=1,money=500,version=1

id=1,money=500,version=1

消费者需要保证幂等性：第一次执行SQL语句

第一次执行：version=1

update account set money = money - 500 , version = version + 1

where id = 1 and version = 1

消费者需要保证幂等性：第二次执行SQL语句

第二次执行：version=2

update account set money = money - 500 , version = version + 1

where id = 1 and version = 1

RabbitMQ集群搭建 | 镜像集群配置

用户权限、交换机可以自动同步，但是队列数据不会，需要配置镜像集群策略

详见课件

焰火青年·
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot-RabbitMQ06-持久化和ACK确认机制
2401_84006732的博客
04-05 1070
阿里伤透我心，疯狂复习刷题，终于喜提offer 哈哈~好啦，不闲扯了1、JAVA面试核心知识整理（PDF）：包含JVMJAVA集合JAVA多线程并发，JAVA基础，Spring原理微服务，Netty与RPC，网络，日志，ZookeeperKafkaRabbitMQ，Hbase，MongoDB设计模式负载均衡数据库一致性哈希JAVA算法数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算共30个章节。2、Redis学习笔记及学习思维脑图。
RabbitMQ高级（消息可靠性、死信交换机、惰性队列、MQ集群部署）
06-30
在本篇中，我们将深入探讨 RabbitMQ 的几个高级特性：消息可靠性、死信交换机、惰性队列以及MQ集群部署。 ### 1. 消息可靠性 确保消息传递的可靠性是 RabbitMQ 的核心功能之一。这主要通过以下几种方式实现： - *...
Spring-amqp 1.6.1消费者手工对消息进行确认
Revivedsun的专栏
11-19 3224
在使用Spring amqp创建消费者并接收消息时，通常会用到下面两个接口。public interface MessageListener { void onMessage(Message message);}public interface ChannelAwareMessageListener { void onMessage(Message message, Channel c
【踩坑记】RabbitMQ整合Springboot，实现ReturnsCallback报错
最新发布
fxl1561068992的博客
04-17 191
RabbitMQConfirmAndReturnConfig不是抽象的, 并且未覆盖org.springframework.amqp.rabbit.core.RabbitTemplate.ReturnCallback中的抽象方法returnedMessage(org.springframework.amqp.core.Message,int,java.lang.String,java.lang.String,java.lang.String)
RabbitMQ消息确认机制详解
m0_72397750的博客
01-05 1507
RabbitMQ消息确认详解：消费者在获取到消息后，会向服务端发送ACK确认，这时消息会立刻删除。消息发布确认要确保消息成功发送到服务端broker。确保RabbitMQ消息的可靠性。开启生产者确认机制，确保生产者的消息能到达队列；设置备份交换机，将无法路由到队列的消息送到备份队列；开启持久化功能，确保消息未消费前在队列中不会丢失；开启消费者应答机制，设置自动应答或手动应答回调；开启消费者失败重试机制，设置重试次数和间隔时间；开启消息恢复机制，重试机会耗尽的消息投递到异常交换机，交由人工处理。
RabbitMQ exchange交换机机制
gaohl0501的博客
10-10 782
目录 RabbitMQ 概念 exchange交换机机制 什么是交换机 binding？ Direct Exchange交换机 Topic Exchange交换机 Fanout Exchange交换机 Header Exchange交换机 RabbitMQ 的 Hello - Demo（springboot实现） RabbitMQ 的 Hello Demo（spri...
15.RabbitMQ 消费端手动ACK消息确认机制
自能生羽翼，何必仰云梯
07-21 3782
  ack——acknowledge（vt. 承认；答谢；报偿；告知已收到；确认的意思），在RabbitMQ中指代的是消费者收到消息后确认的一种行为，关注点在于消费者能否实际接收到MQ发送的消息。   其提供了三种确认方式：   自动确认acknowledge=“none”：当消费者接收到消息的时候，就会自动给到RabbitMQ一个回执，告诉MQ我已经收到消息了，不在乎消费者接收到消息之后业务处理的成功与否。   手动确认acknowledge=“manual”：当消费者收到消息后，不会立刻告诉Rabbit
RabbitMQ高级
c1210283911的博客
03-05 860
RabbitMQ
RabbitMQ二、RabbitMQ高级特性与集群搭建
东风麦芽糖
12-24 896
RabbitMQ消息可靠性投递 RabbitMQACK机制 RabbitMQTTL详解 RabbitMQ死信队列 RabbitMQ延迟队列 RabbitMQ消息幂等性保障 RabitMQ 集群搭建 Spring整合RabbitMQ SpringBoot整合RabbitMQ haproxy.cfg配置详解
AMQPClient.jl：Julia AMQP（高级消息队列协议）RabbitMQ客户端
02-03
AMQPClient.jl 是一个专门为 Julia 语言设计的库，它实现了 AMQP（Advanced Message Queuing Protocol，高级消息队列协议），允许用户与使用 AMQP 协议的消息中间件进行交互，如 RabbitMQ。AMQP 是一种开放标准，...
springboot整合rabbitmq使用死信队列
11-06
// 处理死信消息的逻辑，如记录日志、通知管理员等 } } ``` 通过这种方式，我们可以确保即使在处理消息时出现异常，也能捕获并处理这些异常，保持系统的稳定运行。在微服务架构中，这种错误处理机制对于提高系统...
springboot整合stream使用rabbitmq作为消息中间件
12-13
当我们谈论"SpringBoot整合stream使用rabbitmq作为消息中间件"时，我们涉及的关键技术点主要包括Spring Boot的Stream模块、RabbitMQ的使用以及它们如何协同工作来实现高效的微服务通信。 Spring Boot Stream模块是...
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程
06-28
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程，参考博客：https://blog.csdn.net/qq_29914837/article/details/93334313
RabbitMq使用方法
thebinso的博客
05-23 843
1.RabbitMq运行机制 2.交换机(Exchange) 类型 direct（直接）：消息精确发送，而且只能到达一个队列 fanout（扇出）：消息会分发到所有绑定的队列上。 topic（主题）：与fanout类似，但是多了个属性路由key绑定，消息会发送到路由key对应的队列上 3.spring整合rabbitmq 3.1 导入amqp依赖 <dependency> <groupId>org.springframework.boot&l.
Springboot下RabbitMQ的使用及解决消息丢失问题
热门推荐
東₂₀₂₃²⁰²³
04-25 5万+
导航基础环境消息发送消费消息队列、交换器声明及绑定通过实现ChannelAwareMessageListener接口实现消息消费总结 基础环境 RabbitMQ的安装 Springboot：2.2.5.RELEASE 示例代码：springboot-mq RabbitMQ：3.8.3 application.yml文件配置 spring: rabbitmq: host: localho...
RabbitMQ消息确认机制
Abdulaziz的博客
11-21 752
【代码】RabbitMQ消息确认机制。
RabbitMQ中方法channel.basicAck的使用说明
liqinglonguo的博客
10-25 2526
通过设置multiple参数，可以实现批量确认消息的功能。如果消费者处理消息的速度很快，可以将其设置为true,一次性确认多条消息，提高处理效率。但如果消费者处理消息的速度比较慢，可能会导致消息堆积，造成内存占用过高。因此，在实际使用中需要根据实际情况来确定是否需要批量确认消息。在RabbitMQ中，channel.basicAck方法用于确认已经接收并处理了消息。
「RabbitMQ」实现消息确认机制以确保消息的可靠发送、接收和拒收
技术路上的探险家
06-08 1931
RabbitMQ的消息确认机制应用场景非常广泛，尤其是在需要确保消息可靠性和避免消息丢失的场合下更为重要，例如：金融系统、电商交易系统等。
【RabbitMq 篇六】-消息确认（发送确认与接收确认）
晏霖/胖虎的博客
06-21 1万+
前言 消息确认是保证消息传递可靠性的重要步骤，上一节我们说到持久化，持久化只能保证消息不丢失，但是如果消息如果投递失败我们怎么进行补偿操作呢？解决办法就是实现回调函数进行操作，在消息的发送和消息的消费都可以进行补偿操作，下面我们就要讲解消息确认。 正文 目录 前言 正文 消息确认种类 消息发送确认 ConfirmCallback ReturnCallback ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值