【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】


持续学习&持续更新中…

守破离


【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】

  • Message Queue 消息队列
    • 异步处理
    • 应用解耦
    • 流量控制
  • 消息中间件概念
  • RabbitMQ概念
    • Message
    • Publisher
    • Exchange
    • Queue
    • Binding
    • Connection
    • Channel
    • Consumer
    • Virtual Host
    • Broker
    • 图示
  • 安装
  • RabbitMQ运行机制
    • AMQP 中的消息路由
    • Exchange类型
    • 练习
  • RabbitMQ整合
    • AmqpAdmin 管理组件
    • RabbitTemplate 消息发送处理组件
    • 监听消息
    • 注意
  • RabbitMQ消息确认机制-可靠抵达
    • 发送端—ConfirmCallback
    • 发送端—ReturnCallback
    • 发送端—代码配置
    • 消费端
  • 消息的TTL(Time To Live)
  • 什么是死信
  • 延时队列
  • 延时队列的实现
  • 如何保证消息可靠性
    • 消息丢失
    • 消息重复
    • 消息积压
  • MQ对比
  • 参考

Message Queue 消息队列

异步处理

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

应用解耦

在这里插入图片描述

在这里插入图片描述

这样不管库存系统的接口会不会发生改变,订单系统都不关心

流量控制

在这里插入图片描述

把用户请求流量存到消息队列中,后台服务根据它自身的处理能力去来进行消费处理,不会导致后台服务宕机

消息中间件概念

大多应用中,可通过消息服务中间件来提升系统异步通信、扩展解耦能力,消息服务中两个重要概念:消息代理(message broker)和目的地(destination)

当消息发送者发送消息以后,将由消息代理接管,消息代理保证消息传递到指定目的地。

消息队列主要有两种形式的目的地

  • 队列(queue):点对点消息通信(point-to-point)
  • 主题(topic):发布(publish)/订阅(subscribe)消息通信

点对点式:

  • 消息发送者发送消息,消息代理将其放入一个队列中,消息接收者从队列中获取消息内容,消息读取后被移出队列
  • 消息只有唯一的发送者和接收者
  • 很多人都可以监听队列,但是,消息谁抢到就是谁的

发布订阅式:

  • 发送者发送消息到主题,多个接收者(订阅者)监听(订阅)这个主题,那么就会在消息到达时,同时收到消息
  • (订阅者都会收到消息)

JMS(Java Message Service)JAVA消息服务:基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现

AMQP(Advanced Message Queuing Protocol)高级消息队列协议,也是一个消息代理的规范,兼容JMS
RabbitMQ是AMQP的实现

在这里插入图片描述

RabbitMQ概念

RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue Protocol)的开源实现。

Message

消息,消息是不具名的,它由消息头和消息体组成。消息体是不透明的,而消息头则由一系列的可选属性组成, 这些属性包括routing-key(路由键)、priority(相对于其他消息的优先权)、delivery-mode(指出该消息可能需要持久性存储)等。

Publisher

消息的生产者,也是一个向交换器发布消息的客户端应用程序。

Exchange

交换器,用来接收生产者发送的消息并将这些消息路由给服务器中的队列。

Exchange有4种类型:direct(默认),fanout, topic, 和headers,不同类型的Exchange转发消息的策略有所区别

Queue

消息队列,用来保存消息直到发送给消费者。它是消息的容器,也是消息的终点。一个消息可投入一个或多个队列。消息一直 在队列里面,等待消费者连接到这个队列将其取走。

Binding

绑定,用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则,所以可以将交 换器理解成一个由绑定构成的路由表。

Exchange 和Queue的绑定可以是多对多的关系。

Connection

网络连接,比如一个TCP连接。

客户端和消息中间件之间,一直保持一个长连接。1个客户端只会建立1条连接

长连接的好处:客户端宕机或下线,该长连接就会断开,RabbitMQ就会感知到,就不会再继续派发消息,可以防止大面积消息丢失问题。

Channel

(1条Connection上建立多个Channel,收发数据通过Channel进行)

信道,多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接,AMQP 命令都是通过信道 发出去的,不管是发布消息、订阅队列还是接收消息,这些动作都是通过信道完成。

因为对于操作系统来说建立和销毁 TCP 都 是非常昂贵的开销,所以引入了信道的概念,以复用一条 TCP 连接。

Consumer

消息的消费者,表示一个从消息队列中取得消息的客户端应用程序。

Virtual Host

虚拟主机,表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个Vhost 本质上就是一个 mini 版的 RabbitMQ 服务器,拥有自己的队列、交换器、绑定、配置和权限机制。VHost 是 AMQP 概念的基础,必须在连接时指定,RabbitMQ 默认的 vhost 是 /

虚拟主机跟虚拟主机之间是相互隔离的。可以用于生产环境和开发环境隔离等

类比,RabbitMQ类似一个多租户系统,各个用户相互隔离。每一个 RabbitMQ 服务器都能创建 虚拟的消息服务器,称之为 虚拟主机(virtual host),简称 vhost。vhost 本质上是一个独立的小型 RabbitMQ 服务器,vhost 可避免队列和交换器等命名冲突,vhost 之间是绝对隔离的

Broker

表示消息队列服务器实体

图示

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

安装

docker run -d --name rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p 25672:25672 -p 15671:15671 -p 15672:15672 rabbitmq:management
docker update rabbitmq --restart=always 

在这里插入图片描述

在这里插入图片描述

  • https://www.rabbitmq.com/networking.html
  • 4369, 25672 (Erlang发现&集群端口)
  • 5672, 5671 (AMQP端口)
  • 15672 (web管理后台端口)
  • 61613, 61614 (STOMP协议端口)
  • 1883, 8883 (MQTT协议端口)

在这里插入图片描述

RabbitMQ运行机制

AMQP 中的消息路由

AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS 存在一些差别,AMQP 中增加了 Exchange 和Binding 的角色。生产者把消息发布到 Exchange 上,消息最终到达队列并被消费者接收,而 Binding 决定交换器的消息应该发送到那个队列。

在这里插入图片描述

Exchange类型

Exchange分发消息时根据类型的不同分发策略有区别,目前共四种类型:direct、fanout、topic、headers 。headers 匹配 AMQP 的消息 header 而不是路由键,headers 交换器和 direct 交换器完全一致,但性能差很多,目前几乎用不到了,所以直接看另外三种类型:

在这里插入图片描述

消息中的路由键(routing key)如果和 Binding 中的 binding key 一致, 交换器就将消息发到对应的队列中。

路由键与队列名完全匹配,如果一个队列绑定到交换机要求路由键为“dog”,则只转发 routing key 标记为“dog”的消息,不会转发“dog.puppy”,也不会转发“dog.guard” 等等。它是完全匹配的模式。

在这里插入图片描述

每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。fanout 交换器不处理路由键,只是简单的将队列绑定到交换器上,每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播,每台子网内的主机都获得了一份复制的消息。

fanout 类型转发消息是最快的。

在这里插入图片描述

topic 交换器通过模式匹配分配消息的路由键属性,将路由键和某个模式进行匹配,此时队列需要绑定到一个模式上。 它将路由键和绑定键的字符串切分成单词,这些单词之间用点隔开。

它同样也会识别两个通配符:符号“#”和符号“*”,#匹配0个或多个单词,*匹配1个单词。

练习

在这里插入图片描述

RabbitMQ整合

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
spring.rabbitmq.host=192.168.56.10
# 都有默认配置
#spring.rabbitmq.port=5672
#spring.rabbitmq.virtual-host=/
#spring.rabbitmq.username=guest
#spring.rabbitmq.password=guest
/**
 * 使用RabbitMQ
 * 1、引入amqp场景启动器;RabbitAutoConfiguration 就会自动生效
 *
 * 2、给容器中自动配置了
 *      RabbitTemplate、AmqpAdmin、CachingConnectionFactory、RabbitMessagingTemplate;
 *      所有的属性都是 spring.rabbitmq
 *      @ConfigurationProperties(prefix = "spring.rabbitmq")
 *      public class RabbitProperties
 *
 * 3、给配置文件中配置 spring.rabbitmq 信息
 *
 * 4、@EnableRabbit: @EnableXxxxx;开启功能
 *
 * 5、监听消息:使用@RabbitListener;必须有@EnableRabbit
 *    @RabbitListener: 类+方法上(监听哪些队列即可)
 *    @RabbitHandler:配合@RabbitListener标在方法上(重载区分不同的消息)
 */

@EnableRabbit
@Configuration
public class MyRabbitConfig {

    /**
     * 使用JSON序列化机制,进行消息转换
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

AmqpAdmin 管理组件

    @Test
    public void createExchange() {
        /**
         * DirectExchange(String name, boolean durable, boolean autoDelete, Map<String, Object> arguments)
         */
        Exchange directExchange = new DirectExchange("hello-java-exchange", true, false);
        amqpAdmin.declareExchange(directExchange);
        log.info("Exchange[{}]创建成功", "hello-java-exchange");
    }

    @Test
    public void createQueue() {
        /**
         * public Queue(String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         */
        Queue queue = new Queue("hello-java-queue", true, false, false);
        amqpAdmin.declareQueue(queue);
        log.info("Queue[{}]创建成功", "hello-java-queue");
    }

    @Test
    public void createBinding() {
        /**
         * String destination【目的地】,
         * DestinationType destinationType【目的地类型】,
         * String exchange【交换机】,
         * String routingKey【路由键】,
         * Map<String, Object> arguments【自定义参数】
         *
         * 将exchange指定的交换机和destination目的地进行绑定,使用routingKey作为指定的路由键
         */
        Binding binding = new Binding("hello-java-queue", Binding.DestinationType.QUEUE, "hello-java-exchange", "hello.java", null);
        amqpAdmin.declareBinding(binding);
        log.info("Binding[{}]创建成功", "hello-java-binding");
    }

RabbitTemplate 消息发送处理组件

    @Test
    public void sendMessageTest() {

        //1、发送消息,如果发送的消息是个对象,我们会使用序列化机制,将对象写出去。对象必须实现Serializable
        String msg = "Hello World!";
		rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", msg);

//      2、发送的对象类型的消息,可以自动转成一个json【自定义MessageConverter即可】
//        OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
//        reasonEntity.setId(1L);
//        reasonEntity.setCreateTime(new Date());
//        reasonEntity.setName("哈哈-"+ 666);
//        rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java",
//                reasonEntity);

        log.info("消息发送完成{}");

    }

CorrelationData:消息的唯一ID【可以放在数据库或者Redis中,方便之后判断哪些消息没有可靠抵达】

@RestController
public class RabbitController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @GetMapping("/sendOneMq")
    public String sendOneMq(@RequestParam(value = "num", defaultValue = "10") Integer num) {
        OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
        reasonEntity.setId(1L);
        reasonEntity.setCreateTime(new Date());
        reasonEntity.setName("哈哈");
//        CorrelationData:消息的唯一ID【可以放在数据库或者Redis中,方便之后判断哪些消息没有可靠抵达】
        rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", reasonEntity, new CorrelationData(UUID.randomUUID().toString()));
        return "ok";
    }

监听消息

@RabbitListener + @RabbitHandler (重载区分不同的消息)

    @GetMapping("/sendMq")
    public String sendMq(@RequestParam(value = "num", defaultValue = "10") Integer num) {
        for (int i = 0; i < num; i++) {
            if (i % 2 == 0) {
                OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
                reasonEntity.setId(1L);
                reasonEntity.setCreateTime(new Date());
                reasonEntity.setName("哈哈-" + i);
                rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", reasonEntity, new CorrelationData(UUID.randomUUID().toString()));
            } else {
                OrderEntity entity = new OrderEntity();
                entity.setOrderSn(UUID.randomUUID().toString());
                rabbitTemplate.convertAndSend("hello-java-exchange", "hello22.java", entity, new CorrelationData(UUID.randomUUID().toString()));
            }
        }
        return "ok";
    }
@RabbitListener(queues = {"hello-java-queue"})
@Service("orderItemService")
public class OrderItemServiceImpl extends ServiceImpl<OrderItemDao, OrderItemEntity> implements OrderItemService {

    @RabbitHandler
    public void receiveMessage(Message message,
                               OrderReturnReasonEntity content,
                               Channel channel) throws InterruptedException {
//        接收到消息...(Body:'{"id":1,"name":"哈哈-666","sort":null,"status":null,"createTime":1720438632794}' MessageProperties [headers={__TypeId__=com.atguigu.gulimall.order.entity.OrderReturnReasonEntity}, contentType=application/json, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=hello-java-exchange, receivedRoutingKey=hello.java, deliveryTag=1, consumerTag=amq.ctag-ltQ3IQ4H1lvLGqYNyEH3nQ, consumerQueue=hello-java-queue])
        System.out.println("@RabbitListener接收到消息..." + message);
//        System.out.println("接收到消息...content:"+content);
//        byte[] body = message.getBody();
//        //消息头属性信息
//        MessageProperties properties = message.getMessageProperties();
//        Thread.sleep(3000);
//        System.out.println("消息处理完成=>"+content.getName());
    }


    @RabbitHandler
    public void receiveMessage2(OrderEntity content) throws InterruptedException {
        System.out.println("@RabbitHandler接收到消息..." + content);
    }

}

@RabbitListener写在方法上

@Service("orderItemService")
public class OrderItemServiceImpl extends ServiceImpl<OrderItemDao, OrderItemEntity> implements OrderItemService {

    @RabbitListener(queues = {"hello-java-queue"})
    public void receiveMessage(OrderEntity content) throws InterruptedException {
        System.out.println("接收到消息..." + content);
    }
    
}

注意

  1. Queue、Exchange、Binding可以 @Bean 注入进去
  2. 监听消息的方法可以有三种参数(不分数量,顺序):Object content, Message message, Channel channel
  3. channel可以用来拒绝或者签收消息

RabbitMQ消息确认机制-可靠抵达

保证消息不丢失,可靠抵达,可以使用事务消息,这样性能会下降250倍,为此引入确认机制:

  • publisher confirmCallback :确认模式
  • publisher returnCallback :未投递到 queue 退回模式
  • consumer 手动 ack 机制

在这里插入图片描述

发送端—ConfirmCallback

spring.rabbitmq.publisher-confirms=true

在创建 connectionFactory 的时候设置 PublisherConfirms(true) 选项,开启confirmcallback 。

CorrelationData:用来表示当前消息唯一性。

消息只要被 broker 接收到就会执行 confirmCallback,如果是 cluster 模式,需要所有 broker 接收到才会调用confirmCallback。

被 broker 接收到只能表示 message 已经到达服务器,并不能保证消息一定会被投递到目标 queue 里。所以需要用到接下来的 returnCallback 。

发送端—ReturnCallback

spring.rabbitmq.publisher-returns=true

spring.rabbitmq.template.mandatory=true

confrim 模式只能保证消息到达 broker,不能保证消息准确投递到目标 queue 里。在有些业务场景下,我们需要保证消息一定要投递到目标 queue 里,此时就需要用到return 退回模式。

这样如果消息未能投递到目标 queue 里将调用 returnCallback ,可以记录下详细到投递数据,定期的巡检或者自动纠错都需要这些数据。

发送端—代码配置

#服务端确认
# 开启消息正确抵达RabbitMQ确认
spring.rabbitmq.publisher-confirms=true
# 开启RabbitMQ中的消息正确的从交换机投递到队列确认
spring.rabbitmq.publisher-returns=true
# 只要消息抵达队列,以异步方式优先回调ReturnCallback
spring.rabbitmq.template.mandatory=true
@Configuration
public class MyRabbitConfig {

    /**
     * 使用JSON序列化机制,进行消息转换
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    private RabbitTemplate rabbitTemplate;

    @Primary
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        this.rabbitTemplate = rabbitTemplate;
        rabbitTemplate.setMessageConverter(messageConverter());
        initRabbitTemplate();
        return rabbitTemplate;
    }

    /**
     * 定制RabbitTemplate
     *      做好消息确认机制(publisher,consumer【手动ack】)
     *      每一个发送的消息都在数据库做好记录。定期将失败的消息再次发送一遍
     *
     * 发送端确认:
     * 1、Broker收到消息就回调【P——>B】
             * 1、spring.rabbitmq.publisher-confirms=true
             * 2、设置确认回调ConfirmCallback
     * 2、消息没有正确抵达队列进行回调【E——>Q】
             * 1、spring.rabbitmq.publisher-returns=true
             *    spring.rabbitmq.template.mandatory=true
             * 2、设置确认回调ReturnCallback
     *
     *
     * 消费端确认(保证每个消息被正确消费,此时broker才可以删除这个消息)。
     *          spring.rabbitmq.listener.simple.acknowledge-mode=manual #手动签收
     *          默认是自动确认的:只要消息接收到,客户端会自动确认,服务端就会移除这个消息
     * 问题:
     *          我们收到很多消息,如果自动回复给服务器ack,当消息由于各种原因没有成功处理完成,就会发生消息丢失;
     * 消费者手动确认模式:
     *          只要我们没有明确告诉MQ消息被签收,消息就一直是unacked状态。
     *          即使Consumer宕机,消息也不会丢失,会重新变为Ready状态,下一次有新的Consumer连接进来就发给他
     * 如何签收:
     *          channel.basicAck(deliveryTag,false);业务成功,签收
     *          channel.basicNack(deliveryTag,false,true);业务失败,拒签,并让消息重新入队;
     */
//    @PostConstruct //MyRabbitConfig对象创建完成以后,也就是构造器执行完成后,执行这个方法
    public void initRabbitTemplate() {
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

            /**
             * P ——> B [Publisher ——> Broker]
             *
             * 只要消息抵达Broker这里的ack就为true
             * @param correlationData 当前消息的唯一关联数据(这个是消息的唯一id,发布者发消息的时候传递的)
             * @param ack  消息是否成功抵达Broker
             * @param cause 失败的原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                //Broker收到了:修改消息的状态——>Broker接收到消息
//                System.out.println("confirm...correlationData[" + correlationData + "]==>ack[" + ack + "]==>cause[" + cause + "]");
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * E ——> Q [Exchange ——> Queue]
             *
             * 只要消息没有正确投递给指定的队列,就会触发这个失败回调
             * @param message   投递失败的消息的详细信息
             * @param replyCode 回复的状态码
             * @param replyText 回复的文本内容
             * @param exchange  当时这个消息发给了哪个交换机
             * @param routingKey 当时这个消息指定的路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                //报错了:修改数据库当前消息的状态——>队列接收消息发生错误
//                System.out.println("Fail Message[" + message + "]==>replyCode[" + replyCode + "]==>replyText[" + replyText + "]===>exchange[" + exchange + "]===>routingKey[" + routingKey + "]");
            }
        });
    }

}

消费端

消费者获取到消息,成功处理,可以回复Ack给Broker

  • basic.ack用于肯定确认;broker将移除此消息
  • basic.nack用于否定确认;可以指定broker是否丢弃此消息,可以批量
  • basic.reject用于否定确认;可以指定broker是否丢弃此消息,但不能批量

默认自动ack,消息被消费者收到,就会从broker的queue中移除

queue无消费者,消息依然会被存储,直到消费者消费。消费者收到消息,默认会自动ack。但是如果无法确定此消息是否被处理完成, 或者成功处理。我们可以开启手动ack模式spring.rabbitmq.listener.simple.acknowledge-mode=manual

  • 消息处理成功,ack(),接受下一个消息,此消息broker就会移除
  • 消息处理失败,nack()/reject(),重新发送给其他人进行处理,或者容错处理后ack,或者丢弃
  • 消息一直没有调用ack/nack方法(比如宕机/程序出异常),broker认为此消息正在被处理,不会投递给别人,此时客户端断开,MQ感知到后,消息不会被broker移除,会重新入队并投递给别人
# 客户端确认:开启手动ack消息
spring.rabbitmq.listener.simple.acknowledge-mode=manual
    /**
     * 消费端确认(保证每个消息被正确消费,此时broker才可以删除这个消息)。
     *          spring.rabbitmq.listener.simple.acknowledge-mode=manual #手动签收
     *          默认是自动确认的:只要消息接收到,客户端会自动确认,服务端就会移除这个消息
     * 问题:
     *          我们收到很多消息,如果自动回复给服务器ack,当消息由于各种原因没有成功处理完成,就会发生消息丢失;
     * 消费者手动确认模式:
     *          只要我们没有明确告诉MQ消息被签收,消息就一直是unacked状态。
     *          即使Consumer宕机,消息也不会丢失,会重新变为Ready状态,下一次有新的Consumer连接进来就发给他
     * 如何签收:
     *          channel.basicAck(deliveryTag,false);业务成功,签收
     *          channel.basicNack(deliveryTag,false,true);业务失败,拒签,并让消息重新入队;
     */
    @RabbitListener(queues = {"hello-java-queue"})
    public void receiveMessage0(Message message,
                                Channel channel) {
//         multiple:是否批量
//         requeue=false 丢弃  requeue=true 发回服务器,让服务器重新入队该消息。

//                          long deliveryTag, boolean multiple
//         channel.basicAck(     deliveryTag,         false); 只签收当前货物,不批量签收;

//                          long deliveryTag, boolean multiple, boolean requeue
//         channel.basicNack(    deliveryTag,         false,            true); 拒签当前货物【是否将该消息让MQ重新放入队列,看自己的业务需求】

//                          long deliveryTag, boolean requeue
//         channel.basicReject(  deliveryTag,         true); 拒签当前货物【是否将该消息重新放回MQ看自己的业务需求】

        //DeliveryTag在channel内按顺序自增
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        System.out.println("deliveryTag==>" + deliveryTag);

        //签收货物(消息),非批量模式
        try {
            if (deliveryTag % 2 == 0) {
                //收货
                channel.basicAck(deliveryTag, false);
                System.out.println("签收了货物"+ message +"...deliveryTag..." + deliveryTag);
            } else {
                //退货 requeue=false 丢弃  requeue=true 发回服务器,服务器重新入队。

                channel.basicNack(deliveryTag, false, true);
//                channel.basicReject(deliveryTag, true);

//                channel.basicNack(deliveryTag, false, false);

                System.out.println("不签收货物"+ message +"...deliveryTag..." + deliveryTag);

            }
        } catch (Exception e) {
            //网络中断,签收信息未成功发送给Broker
        }

    }

消息的TTL(Time To Live)

消息的TTL就是消息的存活时间。

RabbitMQ给消息设置 TTL

  1. 通过队列设置:队列中的消息都有相同的过期时间
  2. 给消息本身设置:每条消息的 TTL 可以不同

如果队列设置了,消息也设置了,则最小的 TTL 生效。所以一个消息如果被路由到不同的队列中,这个消息死亡的时间有可能不一样(不同的队列设置)。

消息在队列中生存时间一旦超过 TTL,就会变成死信(Dead Message)

什么是死信

  1. 一个消息被Consumer拒收了,并且reject方法的参数里requeue是false。也就是说不会被再次放在队列里,被其他消费者使用。(basic.reject/ basic.nack)requeue=false
  2. 消息的TTL到了,消息过期了。(没有人消费它)
  3. 队列的长度限制满了。排在前面的消息会被丢弃或者扔到死信路由上

延时队列

当消息在一个队列中变成死信之后,它能被发送到一个指定的交换机中,这个交换机就是 DLX (Dead Letter Exchange),可称为死信交换机。

绑定在 DLX 上的队列就称为死信队列。

我们既可以控制消息在一段时间后变成死信,又可以控制变成死信的消息被路由到某一个指定的交换机,这个交换机又可以绑定队列去消费死信,结合它们就可以实现一个延时队列

不推荐使用给消息设置过期时间这种方式实现延时队列

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

延时队列的实现

在这里插入图片描述

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

import java.util.HashMap;
import java.util.Map;

@Configuration
public class MyMQConfig {

    //@Bean Binding,Queue,Exchange

    /**
     * 容器中的 Binding,Queue,Exchange 都会自动创建(RabbitMQ没有的情况)
     * RabbitMQ中已有的话 @Bean中声明属性发生了变化也不会覆盖
     */
    @Bean
    public Queue orderDelayQueue() {
        Map<String,Object> arguments = new HashMap<>();
        /**
         * x-dead-letter-exchange: order-event-exchange
         * x-dead-letter-routing-key: order.release.order
         * x-message-ttl: 60000
         */
        arguments.put("x-dead-letter-exchange","order-event-exchange");
        arguments.put("x-dead-letter-routing-key","order.release.order");
        arguments.put("x-message-ttl",60000);
        //String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
        return new Queue("order.delay.queue", true, false, false,arguments);
    }

    @Bean
    public Queue orderReleaseOrderQueue() {
        return new Queue("order.release.order.queue", true, false, false);
    }

    @Bean
    public Exchange orderEventExchange() {
        //String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
       return new TopicExchange("order-event-exchange",true,false);
    }

    @Bean
    public Binding orderCreateOrderBinding() {
        //String destination, DestinationType destinationType, String exchange, String routingKey,
        //			Map<String, Object> arguments
        return new Binding("order.delay.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.create.order",
                null);
    }

    @Bean
    public Binding orderReleaseOrderBinding() {
        return new Binding("order.release.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.order",
                null);
    }

}
import com.atguigu.gulimall.order.entity.OrderEntity;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.ResponseBody;

import java.io.IOException;
import java.util.Date;
import java.util.UUID;

@Controller
public class HelloController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RabbitListener(queues = {"order.release.order.queue"})
    public void testListenOrderRelease(OrderEntity order, Message message, Channel channel) throws IOException {
        System.out.println("listenOrderRelease order : " + order);
        System.out.println("listenOrderRelease message : " + message);
        System.out.println("listenOrderRelease channel : " + channel);
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }

    @ResponseBody
    @GetMapping("/test/createOrder")
    public String createOrderTest() {
        //订单下单成功
        OrderEntity entity = new OrderEntity();
        entity.setOrderSn(UUID.randomUUID().toString());
        entity.setModifyTime(new Date());

        //给MQ发送消息。
        rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", entity);
        return "ok";
    }

}

如何保证消息可靠性

消息丢失

消息丢失出现的原因:

  1. 消息发送出去,由于网络问题没有抵达MQ服务器(Broker)

    • 发送者做好容错方法(try-catch),发送消息可能会网络失败,失败后要有重试机制;
    • 做好记录,每个消息发送出去后都应该记录到数据库
  2. 消息抵达Broker,Broker要将消息写入磁盘(持久化)才算成功。此时Broker尚未持久化完成就宕机。

    • publisher必须加入确认回调机制,回调后,根据是否成功,修改数据库消息的发送状态。
    • 做好定期重发,定期去数据库扫描未成功的消息进行重发
  3. 自动ACK的状态下。消费者收到消息,但没来得及处理完成消息宕机

    • 一定开启手动ACK,消费成功才移除,失败或者没来得及处理就noAck并重新入队

防止消息丢失:

  1. 做好消息确认机制(publisher,consumer【手动ack】)
  2. publisher将发送的消息都在数据库做好记录。定期从数据库扫描发送失败的消息,将它们再次发送

比如给数据库创建如下表,用来记录消息的发送状态:

CREATE TABLE `mq_message`
(
    `message_id`     char(32) NOT NULL,
    `content`        text,
    `to_exchange`    varchar(255) DEFAULT NULL,
    `routing_key`    varchar(255) DEFAULT NULL,
    `class_type`     varchar(255) DEFAULT NULL,
    `message_status` int(1)       DEFAULT '0' COMMENT '0-新建  1-已发送 2-错误抵达  3-已抵达',
    `create_time`    datetime     DEFAULT NULL,
    `update_time`    datetime     DEFAULT NULL,
    PRIMARY KEY (`message_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4

消息重复

  1. 消息消费失败,由于重试机制,自动又将消息发送出去。【这种情况允许重复】
  2. 成功消费,手动ack时宕机或者网络原因等等,消息由unack变为ready,Broker又重新发送
    • 将消费者的业务消费接口设计为幂等的即可。比如要解锁库存先判断状态
    • 使用防重表(redis/mysql),发送消息每一个都有业务的唯 一标识,处理过就不用处理
    • rabbitMQ的每一个消息都有redelivered字段,可以获取是否是被重新投递过来的,而不是第一次投递过来的Boolean redelivered = message.getMessageProperties().getRedelivered();

消息积压

  1. 消费者宕机积压
  2. 消费者消费能力不足积压
  3. 发送者发送流量太大
    • 上线更多的消费者,进行正常消费
    • 上线专门的消费服务,将消息先批量取出来,记录数据库,离线慢慢处理

MQ对比

在这里插入图片描述

参考

雷丰阳: Java项目《谷粒商城》Java架构师 | 微服务 | 大型电商项目.


本文完,感谢您的关注支持!


本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/800006.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Spring Boot整合Minio实现文件上传和读取

文章目录 一、简介1.分布式文件系统应用场景2.Minio介绍3.Minio优点 二、docker部署&#xff08;windows系统&#xff09;1.创建目录2.拉取镜像3.创建容器并运行4.访问控制台5.初始化配置 三、Spring Boot整合Minio1.创建demo项目2.引入依赖3.配置4.编写配置类5.MinIO工具类6.文…

【C++PythonJava】字符处理详细解读_字符_ASCLL码_字母数字转换_算法竞赛_开发语言

文章目录 Beginning1&#xff09;ASCLL 码2&#xff09;大小比较2&#xff09;判断数字字符3&#xff09;字符、数字间的相互转换End Beginning 在 C 中&#xff0c;字符和整数有着密不可分的关系。原因就是在计算机中&#xff0c;字符是以一种较 ASCLL 码的整数存储的。自然&…

中科微电子ATGM336H GPS定位模块STM32应用

文章目录 前言1. 中科微电子ATGM336H的使用1.1 ATGM336H引脚说明1.2 数据帧介绍1.3 经纬度介绍1.4 ATGM336H的启动方式 2 数据处理前置C语言知识2.1 strstr函数2.2 memset函数2.3 memcpy函数2.4strtod函数 3. 开始移植3.1 usart初始化程序3.2 串口中断接收函数3.4 数据帧的解析…

—张pdf怎么分割成多页,怎么把一个pdf分割

在数字化时代&#xff0c;pdf文件已经成为我们工作和生活中不可或缺的一部分。然而&#xff0c;有时候我们可能会遇到需要将一张pdf文件分割成多页的情况。无论是为了便于分享&#xff0c;还是为了满足特定的文档格式要求&#xff0c;这个任务都可能变得相当棘手。但别担心&…

17098 广告牌最佳安放问题

这个问题可以通过动态规划来解决。我们可以定义一个数组d&#xff0c;其中d[i]表示到第i个广告牌地点时可以选择放置广告牌的最大效益值。然后我们可以通过遍历所有可能的j&#xff08;1 < j < i && x[i] - x[j] > 5&#xff09;&#xff0c;然后更新d[i]为ma…

【云原生】ptcpdump捕获任何进程、容器或 Pod 的网络流量的抓包神器——筑梦之路

ptcpdump 是一个使用 eBPF 技术开发的、类 tcpdump 的网络抓包工具。它除了兼容 tcpdump 的常用命令行参数以及包过滤语法外&#xff0c; 还额外提供了如下核心特性&#xff1a; 在输出中记录和显示发送网络流量的进程、容器、Pod 信息。 支持对指定进程、容器以及 Pod 进行抓…

LED显示屏中什么情况下用网线?什么情况下用光纤?

在这个色彩斑斓的数字时代&#xff0c;LED显示屏如同城市的眼睛&#xff0c;闪烁着各种信息与艺术的光芒。而要让这些“眼睛”明亮有神&#xff0c;背后离不开两条重要的“信息高速公路”——网线和光纤。它们就像是LED显示屏的血管&#xff0c;负责输送数据这一“血液”。那么…

实验三:图像的平滑滤波

目录 一、实验目的 二、实验原理 1. 空域平滑滤波 2. 椒盐噪声的处理 三、实验内容 四、源程序和结果 (1) 主程序&#xff08;matlab&#xff09; (2) 函数GrayscaleFilter (3) 函数MeanKernel (4) 函数MedFilter 五、结果分析 1. 空域平滑滤波 2. 椒盐噪声的处理…

Python PDF文件的加密和水印处理使用详解

概要 在日常工作中,处理PDF文件是非常常见的需求。为了保护PDF文件的内容,我们可能需要对其进行加密。同时,为了防止文件被未经授权的复制和使用,添加水印也是一种有效的方法。本文将详细介绍如何使用Python对PDF文件进行加密和添加水印的操作,包含详细的示例代码,帮助全…

嵌入式系统中的GPIO控制与应用

GPIO是嵌入式系统中最常见且功能最强大的接口之一。它允许硬件工程师通过编程来配置和控制芯片上的数字引脚&#xff0c;实现输入和输出的功能。在本文中&#xff0c;我们将从理论和实践两个方面探讨GPIO的工作原理&#xff0c;并通过一个简单的示例项目来演示如何利用GPIO控制…

IP风险画像 金融行业的安全盾牌

在当今数字化时代&#xff0c;金融行业面临着前所未有的安全挑战。随着在线交易和数字银行业务的迅猛发展&#xff0c;欺诈和网络攻击的威胁也在不断增加。金融机构需要高效、可靠的安全解决方案来保护客户的资产和个人信息&#xff0c;防止各种形式的欺诈行为。 IP风险画像是…

CS110L(Rust)

1.Rust 语法总结 数值类型 有符号整数: i8, i16, i32, i64无符号整数: u8, u16, u32, u64 变量声明 声明变量: let i 0; // 类型推断let n: i32 1; // 显式类型声明 可变变量: let mut n 0; n n 1; 字符串 注意&#xff0c;let s: str "Hello world";…

WebSocket、服务器推送技术

WebSocket 是一种在单个 TCP 连接上进行 全双工 通信的协议&#xff0c;它可以让客户端和服务器之间进行实时的双向通信&#xff0c;且不存在同源策略限制 WebSocket 使用一个长连接&#xff0c;在客户端和服务器之间保持持久的连接&#xff0c;从而可以实时地发送和接收数据…

区块链与云计算的融合:新时代数据安全的挑战与机遇

随着信息技术的迅猛发展&#xff0c;云计算和区块链技术作为两大前沿技术在各自领域内展示出了巨大的潜力。而它们的结合&#xff0c;即区块链与云计算的融合&#xff0c;正在成为数据安全领域的新趋势。本文将探讨这一融合对数据安全带来的挑战和机遇&#xff0c;以及其在企业…

django实现用户的注册、登录、注销功能

创建django项目的步骤&#xff1a;Django项目的创建步骤-CSDN博客 一、前置工作 配置数据库&#xff0c;设置数据库引擎为mysql 1、在settings文件中找到DATABASES, 配置以下内容 DATABASES {"default": {ENGINE: django.db.backends.mysql, # 数据库引擎NAME: dja…

【数据结构与算法】希尔排序:基于插入排序的高效排序算法

&#x1f493; 博客主页&#xff1a;倔强的石头的CSDN主页 &#x1f4dd;Gitee主页&#xff1a;倔强的石头的gitee主页 ⏩ 文章专栏&#xff1a;《数据结构与算法》 期待您的关注 ​ 目录 一、引言 二、基本原理 三、实现步骤 四、C语言实现 五、性能分析 1. 时间复杂度…

Hadoop3:HDFS-查看logs文件,排查NameNode故障原因。

问题一、NameNode进程退出 我们发现&#xff0c;NameNode进程不存在。 情况1、单独启动NameNode hdfs --daemon start namenode能够正常拉起&#xff0c;那就没问题 情况2、无法独立启动NameNode 先尝试启动NameNode hdfs --daemon start namenode发现&#xff0c;没能成…

el-date-picker手动输入日期,通过设置开始时间和阶段自动填写结束时间

需求&#xff1a;根据开始时间&#xff0c;通过填写阶段时长&#xff0c;自动填写结束时间&#xff0c;同时开始时间和节数时间可以手动输入 代码如下&#xff1a; <el-form ref"ruleForm2" :rules"rules2" :model"formData" inline label-po…

Redis深度解析:从基础到高级特性,剖析关键技术

一、关于Redis Redis介绍 REmote DIctionary Server(Redis) 是一个由 Salvatore Sanfilippo 写的 key-value 存储系统&#xff0c;是跨平台的非关系型数据库。 Redis 是一个开源的使用 ANSIC 语言编写、遵守 BSD&#xff08;开源协议&#xff09; 协议、支持网络、可基于内存…

指令判断数据更改,文本变色

默认数据是这样&#xff0c;如果更改了其中一个&#xff0c;文本框变成红色 <el-form-item label"Activity name"><el-inputv-model"form.name"v-highlight"datas[name]"input"changeValue(name)"/></el-form-item>…