谷粒商城のRabbitMQ基础篇

已于 2024-10-06 20:00:17 修改
阅读量727 收藏 16
点赞数 4
分类专栏： 项目实践 文章标签： rabbitmq 分布式 后端 springboot
于 2024-10-06 19:59:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77599076/article/details/142707323
版权

文章目录

前言

  本篇主要介绍消息中间件Rabbit MQ的基本概念及使用，以及保证消息的可靠投递
  对应视频p248-p261

一、Rabbit MQ简介

1、基本概念

  Rabbit MQ是一个消息代理 - 一个消息系统的媒介。它可以为你的应用提供一个通用的消息发送和接收平台，并且保证消息在传输过程中的安全。这是官方文档给予Rabbit MQ的定义。
  Rabbit MQ是基于AMQP 模型，AMQP（高级消息队列协议）是一个网络协议。它支持符合要求的客户端应用（application）和消息中间件代理（messaging middleware broker）之间进行通信。和JMS（Java Message Service）JAVA消息服务最大的区别在于，AMQP具有跨平台，跨语言的特性，并且支持更多的消息模型，并且简化了消息的类型（网络通信统一转换为流）。
  在企业级开发中运用Rabbit MQ，主要是为了达到异步、削峰、解耦的目的：

  • 异步：假设用户注册完成后需要发送短信和邮件，如果是同步模式，就需要注册->发送短信->发送邮件顺序执行。假设某一个步骤调用第三方的接口执行的时间较长，会极大地拖延整个业务流程的完成时间，需要等到最后一步执行完成后再返回结果，这样对于用户是非常不友好的。而引入Rabbit MQ，可以做到注册完成后直接返回结果给用户，异步通知其他的服务发送短信，发送邮件。
  • 削峰：对于一些电商平台，在双11，618等活动时，用户请求会达到峰值，服务器一般短时间内无法承受这样的负担，通过Rabbit MQ，可以将用户的请求暂时存放入队列中，然后负责业务处理的模块按照一定的规则从队列中获取请求进行处理，也就是起到一个缓冲的作用。
  • 解耦：假设现在有三个系统，B，C系统需要接受A系统的通知，如果后续又加入了一个D系统，那么A系统还需要编写针对D系统发送通知的接口。引入Rabbit MQ，A系统可以将通知发送到队列，需要接受消息的系统自行监听队列即可。

2、组件架构

  Rabbit MQ的基本架构，包括生产者、消费者、消息、交换机、队列、通道、虚拟主机：

  • 生产者 是消息的生产方，负责编辑消息发送到交换机。
  • 消费者 是消息的消费方，负责监听队列，从队列中获取消息并处理。
  • 交换机 作为消息和队列的中间组件，消息需要经过交换机，而不是直接发送至队列。
  • 队列 用来保存消息直到发送给消费者。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
  • 通道信道是建立在真实的TCP连接内的虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。可以复用一条TCP连接。虽然客户端和 RabbitMQ 服务器之间只有一个 TCP 连接，但可以通过多个信道并行处理不同的消息通信任务。每个信道在逻辑上是独立的，它们互不干扰。在 RabbitMQ 中，客户端首先与服务器建立一个 TCP 连接，然后通过该连接创建多个信道来进行通信。
  • 虚拟主机 上述的交换机，队列，通道都是运行在虚拟主机上的。可以将虚拟主机理解成一个命名空间，允许你在同一个 RabbitMQ 实例中分隔不同的应用或项目。不同的队列、交换机等资源可以在不同的虚拟主机中拥有相同的名称，而不会产生冲突。并且每个虚拟主机都有一套独立的权限管理。

二、使用步骤

1.引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2.application.properties

spring.rabbitmq.host=自己的地址
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/

  还需要在启动类上加入@EnableRabbit注解

3、docker 安装Rabbit MQ

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

3、使用案例

  同样的Rabbit MQ提供了两个模版：AmqpAdmin和RabbitTemplate。AmqpAdmin 可用于队列，交换机，绑定关系的定义。RabbitTemplate可以用于发送消息。

3.1、定义队列

	 /**
     * 创建队列
     */
    @Test
    public void createQueue() {
    		 //参数二控制是否持久化
        amqpAdmin.declareQueue(new Queue("hello-java-queue", true, false, false,null));
        System.out.println("queue created");
    }

3.2、定义交换机

  常见的交换机有：

  • Direct 交换机 根据精确匹配的路由键来将消息路由到特定队列。
  • Fanout 交换机 将消息广播到所有绑定的队列，无需考虑路由键。
  • Topic 交换机 根据模式匹配的路由键，将消息路由到匹配的队列。
  • Headers 交换机 根据消息头中的属性值匹配，而非路由键。

  前三种模式最为常用，Topic 交换机 的模式匹配 也称为通配符模式，一般有两种，#匹配0个或多个单词，*匹配一
个单词。

	 /**
     * 创建交换机(直连模式)
     */
    @Test
    public void createExchange() {
    	    //参数二控制是否持久化
        amqpAdmin.declareExchange(new DirectExchange("hello-java-exchange", true, false,null));
        System.out.println("exchange created");
    }

3.3、绑定

 	 /**
     * 将队列绑定到交换机上
     */
    @Test
    public void createBinding() {
    		//参数一 队列名 参数二：绑定类型 参数三：交换机名 参数四：路由键
        amqpAdmin.declareBinding(new Binding("hello-java-queue",
                Binding.DestinationType.QUEUE,
                "hello-java-exchange",
                "hello.java",
                null));
        System.out.println("binding created");
    }

3.4、发送消息

  发送的消息通过路由键找到对应的交换机。

    /**
     * 发送消息
     */
    @Test
    public void sendMessage() {
    			//参数一：交换机名 参数二：路由键
        rabbitTemplate.convertAndSend("hello-java-exchange","hello.java","这是一个测试信息");
    }

3.5、接受消息

  需要在方法上加入@RabbitListener注解，指定监听的队列。

	 @RabbitListener(queues = "hello-java-queue")
    public void listenMessage(Message message, Channel channel) {

	 }

3.5、自定义消息序列化方式

@Configuration
public class MyRabbitConfig {

 	  @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

}

3.6、演示Fanout 交换机模式

    /**
     * 创建交换机(广播模式)
     */
    @Test
    public void createFanoutExchange() {
        amqpAdmin.declareExchange(new FanoutExchange("hello-java-fanout-exchange", true, false,null));
    }
    
	  @Test
    public void createQueue2() {
        amqpAdmin.declareQueue(new Queue("hello-java-fanout-queue", true, false, false,null));
    }

    /**
     * 将队列绑定到交换机上
     */
    @Test
    public void createBindingFanout() {
        amqpAdmin.declareBinding(new Binding("hello-java-queue",
                Binding.DestinationType.QUEUE,
                "hello-java-fanout-exchange",
                "hello.java",
                null));
        amqpAdmin.declareBinding(new Binding("hello-java-fanout-queue",
                Binding.DestinationType.QUEUE,
                "hello-java-fanout-exchange",
                "hello.java",
                null));
        System.out.println("binding created");
    }
    
    /**
     * 发送消息
     */
    @Test
    public void sendMessage() {
        rabbitTemplate.convertAndSend("hello-java-fanout-exchange","hello.js","这是一个测试信息");
    }
    
    @RabbitListener(queues = {"hello-java-queue","hello-java-fanout-queue"})
    public void receiveQueue(String message) {
        System.out.println(message);
    }

  广播模式下，在发送消息时，即使指定的路由键和队列绑定在交换机上的不同，监听相关队列的消费者也可以接收到消息。即：fanout 交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。
在这里插入图片描述

3.7、演示Topic 交换机模式

    /**
     * 创建交换机(通配符模式)
     */
    @Test
    public void createExchangeTopic() {
        amqpAdmin.declareExchange(new TopicExchange("hello-java-topic-exchange", true, false,null));
        System.out.println("exchange created");
    }

    /**
     * 创建通配符队列1
     */
    @Test
    public void createTopicQueue1() {
        amqpAdmin.declareQueue(new Queue("hello-java-topic-queue1", true, false, false,null));
    }

    /**
     * 创建通配符队列2
     */
    @Test
    public void createTopicQueue2() {
        amqpAdmin.declareQueue(new Queue("hello-java-topic-queue2", true, false, false,null));
    }

    /**
     * 将队列绑定到交换机上(通配符模式)
     */
    @Test
    public void createBindingTopic() {
        amqpAdmin.declareBinding(new Binding("hello-java-topic-queue1",
                Binding.DestinationType.QUEUE,
                "hello-java-topic-exchange",
                "#.java",
                null));
        amqpAdmin.declareBinding(new Binding("hello-java-topic-queue2",
                Binding.DestinationType.QUEUE,
                "hello-java-topic-exchange",
                "*.java",
                null));
        System.out.println("binding created");
    }
    
    @GetMapping("/send")
    public void sendMessage() {
        rabbitTemplate.convertAndSend("hello-java-topic-exchange", "java", "这是一个测试信息");
        rabbitTemplate.convertAndSend("hello-java-topic-exchange", "hello.world.java", "这是一个测试信息");
    }

    /**
     * 监听通配符队列1 和交换机绑定的路由键是 #.java
     * @param message
     * @param channel
     */
    @RabbitListener(queues = "hello-java-topic-queue1")
    public void receiveTopicQueue(String message,Channel channel) {
        System.out.println("监听hello-java-topic-queue1的消息是" + message);
    }

  首先向通配符模式的交换机发送了两个消息，消费者选择监听与交换机绑定了#.java路由键的队列hello-java-topic-queue1，由于发送的消息java和hello.world.java与#通配符能匹配上（前者匹配0个，后者匹配2个），所以两条消息消费者都接受到了。
在这里插入图片描述
  接下来测试*通配符，由于*通配符只能匹配单个单词，所以只监听到了hello.java

    @GetMapping("/send")
    public void sendMessage() {
        rabbitTemplate.convertAndSend("hello-java-topic-exchange", "java", "这是一个测试信息java");
        rabbitTemplate.convertAndSend("hello-java-topic-exchange", "hello.world.java", "这是一个测试信息hello.world.java");
        rabbitTemplate.convertAndSend("hello-java-topic-exchange", "hello.java", "这是一个测试信息hello.java");
    }
    
    /**
     * 监听通配符队列2 和交换机绑定的路由键是 *.java
     * @param message
     * @param channel
     */
    @RabbitListener(queues = "hello-java-topic-queue2")
    public void receiveTopicQueue(String message,Channel channel) {
        System.out.println("监听hello-java-topic-queue2的消息是" + message);
    }

三、消息可靠性

  在Rabbit MQ中，消息首先需要发送到交换机，再由交换机发送到队列，最后消费者从队列中读取消息。中转的步骤较多，其中每一步都有可能发生消息丢失的问题。Rabbit MQ采用消息投递回调和消息确认机制分别保证生产者方和消费者方的消息可靠性。

3.1、ConfirmCallback&ReturnCallback

  ConfirmCallback是消息发送到交换机的回调，无论成功或者失败都会触发。ReturnCallback是消息从交换机到队列的回调，只有失败了才会触发。
  在使用之前，需要在配置文件中加上：

spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.publisher-returns=true
spring.rabbitmq.template.mandatory=true

  可以在自定义配置类中为RabbitTemplate加上对应的配置：

    /**
     * 消息发送到交换机的回调 ConfirmCallback（成功和失败都会触发）
     * 从交换机到队列投递失败的回调ReturnCallback
     * 从队列到消费者是 ack机制 只要消费者没有手动ack，消息就默认未被消费，是unacked状态，服务器宕机，消息会重置为ready状态
     */
    @PostConstruct
    public void init() {
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

            /**
             * Confirmation callback.
             *
             * @param correlationData correlation data for the callback.
             * @param ack             true for ack, false for nack
             * @param cause           An optional cause, for nack, when available, otherwise null.
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("触发ConfirmCallback：correlationData:"+correlationData+",ack:"+ack+",cause:"+cause);
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {

            /**
             * Returned message callback.
             *
             * @param message    the returned message.
             * @param replyCode  the reply code.
             * @param replyText  the reply text.
             * @param exchange   the exchange.
             * @param routingKey the routing key.
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("触发ReturnCallback：message"+message+"replyCode:"+replyCode+",exchange:"+exchange+",routingKey:"+routingKey);
            }
        });
    }

3.2、设置手动ACK

  如果没有进行任何设置，在Rabbit MQ中默认消息都是自动签收的：

3.2.1、演示自动签收消息丢失

    @GetMapping("/send")
    public void sendMessage() {
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend("hello-java-exchange","hello.java","这是一个测试信息"+i);
        }
    }
    
    @RabbitListener(queues = "hello-java-queue")
    public void listenMessage(Message message, Channel channel) {
        System.out.println("listenMessage接收到的消息" + message);
        throw new NullPointerException();
    }

在这里插入图片描述
  上图的1条消息已经被自动签收
在这里插入图片描述
  模拟出现异常，消息不会丢失。在这里插入图片描述在这里插入图片描述
  假设此时服务器宕机了，队列中剩下未处理的消息会丢失：

    /**
     * 同一个消息只能被一个监听者接受
     * 一个消息处理完成后，才能处理下一个消息
     * @param message
     * @param channel
     */
    @RabbitListener(queues = "hello-java-queue")
    public void listenMessage(Message message, Channel channel) {
        System.out.println("listenMessage接收到的消息" + message);
    }

  通过jps -l找到当前服务进程，并Stop-Process -Id 25364 -Force强行终止：

在这里插入图片描述在这里插入图片描述  发现剩下的消息全部丢失：

在这里插入图片描述

3.2.2、演示手动签收

  我们可以设置消息手动确认，在配置文件中加入：spring.rabbitmq.listener.simple.acknowledge-mode=manual，打上断点：
在这里插入图片描述  队列中有5条unack（未确认）的消息。
在这里插入图片描述  接下来处理了两个消息，但是没有手动确认：
在这里插入图片描述  可以看到在控制台中依旧是5条unack状态：
在这里插入图片描述  假设此时服务器宕机了：
在这里插入图片描述  可以看到控制台中这5条消息回到了ready状态，没有丢失：
在这里插入图片描述  如果需要手动签收，需要在消费者方监听的代码中，使用channel的basicAck或basicNack方法，前者是签收，后者是拒绝，其中拒绝又有两种模式，一种是重新放回队列，另一种是丢弃：

  • 拒绝并丢弃：
    @RabbitListener(queues = "hello-java-queue")
    public void listenMessage(Message message, Channel channel) {
        System.out.println("监听hello-java-queue的消息是"+message);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //手动确认
            if (deliveryTag % 2 == 0) {
                //签收
                channel.basicAck(deliveryTag, false);
                System.out.println("接收到的消息" + deliveryTag);
            } else {
                //拒绝（丢弃）
                channel.basicNack(deliveryTag, false, false);
                System.out.println("拒绝了消息" + deliveryTag);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

  重新启动项目，消息一部分被拒绝，一部分被签收并消费
在这里插入图片描述  队列清空
在这里插入图片描述

  • 拒绝并重新放回队列：当一个消息被拒绝又重新放回队列时，会被再次消费，创建两个消费者监听hello-java-queue：
    @RabbitListener(queues = "hello-java-queue")
    public void listenMessage(Message message, Channel channel) {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //手动确认
            if (deliveryTag % 2 == 0) {
                //签收
                channel.basicAck(deliveryTag, false);
                System.out.println("listenMessage接收到的消息" + deliveryTag);
            } else {
                //拒绝
                channel.basicNack(deliveryTag, false, true);
                System.out.println("listenMessage拒绝了消息" + deliveryTag);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @RabbitListener(queues = {"hello-java-queue","hello-java-fanout-queue"})
    public void receiveQueue(Message message,Channel channel) {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            channel.basicAck(deliveryTag, false);
            System.out.println("receiveQueue接收到的消息"+deliveryTag);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

  拒绝的消息可以放回队列被再次消费，直到有消费者签收为止。
在这里插入图片描述

总结

  下面总结一下Rabbit MQ 的工作流程

  1. 生产者与虚拟主机建立连接，经过信道，发送消息到交换机（带有路由键）。
  2. 交换机根据绑定和路由规则，将消息路由到一个或多个队列。
  3. 队列存储消息，等待消费者处理。
  4. 消费者从队列中接收消息，并处理。
  5. 消费者处理消息后，发送 ACK 确认，RabbitMQ 从队列中删除该消息。
  6. 如果消费者拒绝消息或处理失败，RabbitMQ 可能会将消息重新投递，或者发送到死信队列。

  其他诸如死信队列，延迟队列，消息幂等性，消息积压等将在高级篇中讲解。
  下一篇：订单服务&分布式事务

西岭千秋雪_
关注
专栏目录
谷粒商城--分布式基础篇1
xu_jin_shan的博客
02-19 876
谷粒商城-分布式基础篇1 项目简介、分布式基础、环境搭建、Spring Cloud Alibaba
谷粒商城——基础篇
qq_37875826的博客
06-11 1216
一、项目介绍 商城微服务架构图如上图所示，其中涉及到以下微服务组件： 服务注册/发现&注册中心： A服务调用B服务，A服务并不知道B服务当前在哪几台服务器有，哪些是正常的，哪些服务已经下线。解决这个问题可以引入注册中心。配置中心用来几种管理微服务的配置信息。 服务熔断&服务降级： 在微服务架构中，微服务之间通过网络进行通信，存在相互依赖，当其中一个服务不可用时，会造成雪崩效应。要防止这样的情况，必须要有容错机制来保护服务。 例如：订单服务–>商品服务–>库存服务； 库存服务出现
谷粒商城-分布式高级篇[商城业务-RabbitMQ]
HGW的博客
04-16 3439
谷粒商城-分布式高级篇[商城业务-RabbitMQ]
【谷粒商城】全网最全笔记(1/4)
热门推荐
努力充实，远方可期
06-23 38万+
本文重点记录老师讲的话 和 一些配置流程，笔记中有的内容尽量少记录。 边看视频变更新，我尽快更新。
谷粒商城学习-笔记大全
epitomizelu的专栏
07-04 1729
1，谷粒商城-01-项目介绍 2，谷粒商城笔记-02-项目整体效果展示
谷粒商城 - 个人笔记(基础篇一)
知行
09-26 5万+
电商后台管理系统+电商系统，掌握微服务的全套方案。该系统有商品服务、仓储服务、订单服务、购物车服务、检索服务、认证中心服务、网关服务、用户服务、秒杀服务、第三方服务。使用SpringBoot+SpringCloud并配套SpringCloud Alibaba系列，引入全套微服务治理方案：Nacos注册中心/配置中心、Feign远程调用、Gateway网关、Redisson缓存、基于ElasticSearch7全文检索、异步编排与线程池、RabbitMQ柔性事务方案、Redisson分布式锁、分布式信号量等。
谷粒商城篇章9 ---- P248-P261/P292-P294 ---- 消息队列【分布式高级篇六】
weixin_48568302的博客
02-22 1150
RabbitMQ消息队列、RabbitMQ延时队列。
谷粒商城基础篇复习（上）
gpy1240301202的博客
08-26 192
谷粒商城基础篇已经全部看完了，还存在一些问题（网关路由木有生效），看到一位博主的笔记很详细，我就做了整体的快速复习：参考链接：https://blog.csdn.net/hancoder/article/details/106922139/ 集群是个物理形态，分布式是个工作方式。 spring cloud使用http+json远程调用，服务之间调用用feign组件 注册中心（Nacos）：服务注册发现 配置中心（Nacos）：管理微服务的配置信息 服务熔断降级防止微服务之间相互依赖造成的雪崩效应 服务熔断
谷粒商城基础篇（保姆级总结）
唐尧的博客
10-24 2万+
谷粒商城基础篇 文章目录谷粒商城基础篇项目相关基础知识介绍微服务架构图和项目描述**微服务划分图**Vrgrantsystemctl命令配置环境Docker自启动命令下载mysql5.7检查所有镜像配置git创建仓库创建其他微服务安装10.15.1node.js,逆向工程Spring Cloud Alibabanacos作为注册中心Fegin声明式远程调用如何使用nacos作为配置中心统一管理配置nacos核心加载多配置集GateWay网关前端基础Vuevue模块化开发三级分类开发配置网关路由与位置重写配置
谷粒商城 - 个人笔记(基础篇二）
知行
10-16 1万+
电商后台管理系统+电商系统，掌握微服务的全套方案。该系统有商品服务、仓储服务、订单服务、购物车服务、检索服务、认证中心服务、网关服务、用户服务、秒杀服务、第三方服务。使用SpringBoot+SpringCloud并配套SpringCloud Alibaba系列，引入全套微服务治理方案：Nacos注册中心/配置中心、Feign远程调用、Gateway网关、Redisson缓存、基于ElasticSearch7全文检索、异步编排与线程池、RabbitMQ柔性事务方案、Redisson分布式锁、分布式信号量等。
谷粒商城资料整理课件.zip_谷粒商城课件
07-01
基础篇\课件\谷粒商城-分布式基础-图.pdf 运维篇\课件\K8S部署&DevOps.pdf 高级篇\课件\01、Reactive&WebFlux.pdf 高级篇\课件\02、接口幂等性.pdf 高级篇\课件\03、本地事务&分布式事务.pdf 高级篇\课件\04、性能与...
谷粒商城电商项目 （ 大型分布式基础+高级、高可用集群部署）（全栈开发篇）
05-22
《谷粒商城电商项目：大型分布式基础与高可用集群部署》 在当今互联网时代，电商平台的构建已经成为企业不可或缺的一部分。谷粒商城电商项目以其大型分布式基础和高可用集群部署为特色，展现了现代电商系统的先进性...
【黑马点评】 使用RabbitMQ实现消息队列——2.使用RabbitMQ监听秒杀下单
m0_52031708的博客
10-06 632
黑马点评之使用RabbitMQ实现消息队列
RabbitMQ的高级特性-事务
m0_75227031的博客
09-30 406
RabbitMQ是基于AMQP协议实现的, 该协议实现了事务机制, 因此RabbitMQ也⽀持事务机制. SpringAMQP也提供了对事务相关的操作. RabbitMQ事务允许开发者确保消息的发送和接收是原⼦性的, 要么全部成功, 要么全部失败。2. 添加 @Transactional , 消息1和消息2全部发送失败。1. 不加 @Transactional , 会发现消息1发送成功。
尚硅谷 rabbitmq 2024 第34-37 延时队列 答疑
最新发布
2401_86733530的博客
10-06 673
**Kafka**：主要使用`@KafkaListener`，也可以通过`KafkaConsumer` API或`ConcurrentMessageListenerContainer`。在RabbitMQ中，`returnedMessage`和`confirm`是两种不同的消息确认机制，它们用于确保消息在生产者和消费者之间可靠传递。- **RabbitMQ**：主要使用`@RabbitListener`，也可以通过`SimpleMessageListenerContainer`或手动拉取消息。
RabbitMQ 高级特性——TTL
不能再留遗憾了的博客
09-29 904
RabbitMQ TTL特性
Kafka和RabbitMQ区别
weixin_37788102的博客
09-29 461
延迟消息是指生产者发送消息发送消息后，不能立刻被消费者消费，需要等待指定的时间后才可以被消费。
RabbitMQ的相关题
m0_75227031的博客
10-01 1049
采⽤Java语⾔开发, 由阿⾥巴巴开源, 后捐赠给了Apache. 在可⽤性, 可靠性以及稳定性等⽅⾯都⾮常出⾊, 吞吐量能达到⼗万级, 在Alibaba集团内部⼴泛使⽤, 但⽀持的客⼾端语⾔不多, 产品较新⽂档较少,且社区活跃度⼀般. 适合于⼤规模分布式系统, 可靠性要求⾼, 且并发⼤的场景, ⽐如互联⽹⾦融.延迟队列, 就是希望等待特定的时间之后, 消费者才能拿到这个消息. TTL刚好可以让消息延迟⼀段时间成为死信, 成为死信的消息会被投递到死信队列⾥, 这样消费者⼀直消费死信队列⾥的消息就可以了。
谷粒商城rabbitmq
08-07
谷粒商城使用了RabbitMQ作为消息队列。在配置文件中，可以看到RabbitMQ的相关配置信息，如主机地址、端口和虚拟主机等。在该博客系列中，作者主要关注了谷粒商城的业务逻辑编写和相关配置流程，以及RabbitMQ消息确认机制的实现。RabbitMQ是一个消息队列系统，它具有可靠的消息传递机制和强大的消息处理能力。在谷粒商城中，RabbitMQ被用于实现一些消息队列的使用场景，比如实现定时任务的延时队列等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值