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

已于 2022-08-04 14:56:43 修改
阅读量973 收藏 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
    评论
专栏目录
RabbitMQ实战教程
09-02
本课程适用于RabbitMQ实战者以及SpringBoot整合RabbitMQ实战需求者。课程将首先带领大家拜读RabbitMQ官网的技术开发手册，之后会将学到的知识深入的实战到实际的各种应用场景中，从而加深知识点的理解，其中包括如何实现单一队列多个消费者监听消费、业务服务模块解耦通信、抢单高并发方案的解决、登录成功异步写日志、异步发送邮件、死信队列实战以及实现用户下单超时未支付自动失效等等。
rabbitmq整合springboot:ChannelAwareMessageListener和@RabbitListener的使用
qq_41358574的博客
01-26 2963
rabbitmq两种监听器的写法
SpringCloudAlibaba+RocketMQ实现对消息中间件的整合
最新发布
huxian1234的专栏
04-21 1011
视频号2023年度优秀创作者，互联网大厂P8技术专家，Spring Cloud Alibaba微服务架构实战派(上下册)和RocketMQ消息中间件实战派(上下册)的作者，资深架构师，技术负责人，极客时间训练营讲师，四维口袋KVP最具价值技术专家，技术领域专家团成员，2021电子工业出版社年度优秀作者，获得2023电子工业出版技术成长领路人称号。
Spring-amqp 1.6.1消费者手工对消息进行确认
Revivedsun的专栏
11-19 3229
在使用Spring amqp创建消费者并接收消息时，通常会用到下面两个接口。public interface MessageListener { void onMessage(Message message);}public interface ChannelAwareMessageListener { void onMessage(Message message, Channel c
SpringBoot RabbitMQ ChannelAwareMessageListener onMessage同步消息返回结果 rpc模式
lyll3269的博客
06-09 9408
说明 1、此例前提条件：你已实现rabbitmq消息的手动确认模式相关代码，已完成消息监听类和队列的绑定。 2、此例解决：实现ChannelAwareMessageListener接口进行消息监听，消息生产者发送同步消息，阻塞等待接收返回结果。参考官方文档：https://www.rabbitmq.com/tutorials/tutorial-six-java.html 3、使用@RabbitListener注解进行消息监听的同步消息处理更简单，可查看官方文档：https://www.rabbitmq
Rabbitmq的一些笔记
m0_65300193的博客
03-02 2933
一些概念： 消息队列三大功能： 流量消峰：超过极限之后，后续的访问人员需要等待；可以避免宕机，但是需要更多的时间； 应用解耦：可以使系统之间解耦，一个系统调用别的系统的时候不会因为被调用的系统故障而一起发生故障；这样在调用的时候，会通过队列去访问别的系统，那么需要调用的系统只需要将这样的一个请求交给了队列则就完成了他的操作，后续的出错不会影响它。 异步处理：可以使得模块之间调用的时候，调用的模块不再需要等待被调用的模块执行结束，而是被调用的模块执行结束以后由队列去通知调用的模块； MQ的四大核心概念.
RabbitMQ高级（消息可靠性、死信交换机、惰性队列、MQ集群部署）
06-30
在本篇中，我们将深入探讨 RabbitMQ 的几个高级特性：消息可靠性、死信交换机、惰性队列以及MQ集群部署。 ### 1. 消息可靠性 确保消息传递的可靠性是 RabbitMQ 的核心功能之一。这主要通过以下几种方式实现： - *...
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消息确认机制详解
m0_72397750的博客
01-05 1576
RabbitMQ消息确认详解：消费者在获取到消息后，会向服务端发送ACK确认，这时消息会立刻删除。消息发布确认要确保消息成功发送到服务端broker。确保RabbitMQ消息的可靠性。开启生产者确认机制，确保生产者的消息能到达队列；设置备份交换机，将无法路由到队列的消息送到备份队列；开启持久化功能，确保消息未消费前在队列中不会丢失；开启消费者应答机制，设置自动应答或手动应答回调；开启消费者失败重试机制，设置重试次数和间隔时间；开启消息恢复机制，重试机会耗尽的消息投递到异常交换机，交由人工处理。
四：RabbitMQ 高级特性
Xx__WangQi的博客
04-14 664
目录 1、RabbitMQ 高级特性 1.1 消息的可靠投递 1.2 Consumer Ack 1.3 消费端限流 1.4 TTL 1.5 死信队列 1.6 延迟队列 1.7 消息幂等性保障 1.8 消息积压 1、RabbitMQ 高级特性 1.1 消息的可靠投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。 RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 ..
Rabbitmq- 消费者ack机制与发布者消息确认
程序员路同学
11-13 2861
RabbitMq消息ack机制与confirm确认/return返回
ActiveMQ之发布/订阅实现（监听模式MessageListener）
haishiyizhenfeng的博客
01-17 1093
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/Afox4l/article/details/79078379 一.模式图 二.相关概念 1，主题（Topic） 2，发布者（Publisher） 3，订阅者（Subscriber） 客户端将消息发送到主题。多个发布者将消息发送到To...
RabbitMQ 发送给延迟交换机的消息调用returnedMessage 方法及returnedMessage() 方法的作用
从码农到码到成功
03-23 1430
1:RabbitMQ 发送给延迟交换机的消息调用returnedMessage 方法 2：returnedMessage() 方法的作用 交换机返回消息的方法-消息未送达队列触发回调 （1）常用于交换机无法路由回退消息。 （2）如果交换机绑定了备用交换机则是路由到备用交换机，此方法不回调。 （3）如果是发送到延迟交换机则回调此方法，所以如果使用延迟交换机则要对延迟交换机回调的消息过滤。
Rabbitmq的消息确认机制（十一）
weixin_41979002的博客
10-14 3028
一、前言 RabbitMq提供了消息确认机制，主要分为生产者端发送消息确认和消费者端的消费消息确认。 生产者端发送消息确认又分为Confirm 消息确认机制和Return 消息机制； 消费者端 则分为Ack 和 Nack 机制。 二、生产者端消息确认机制 1.1 引入 rabbitmq 依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"
rabbitMq消息应答--ack机制
qq_28227405的博客
01-07 2170
消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了，会导致消息丢失。RabbitMq可以通过消费者在消费完消息后再手动应答(ack机制)的方式通知Broker服务端消息已经消费完。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值