RabbitMQ实战应用

最新推荐文章于 2024-08-11 16:16:30 发布
最新推荐文章于 2024-08-11 16:16:30 发布
阅读量573 收藏 5
点赞数 1
分类专栏： RabbitMQ 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71212413/article/details/129899947
版权

一、确认机制

1 生产投递丢失问题

  • 如果生产者 P 投递消息到交换机 X 的过程中，出现了网络延迟，导致消息丢失，怎么保证消息安全？

1.1通过发布确认机制解决 

  • 生产者 P 投递消息到交换机 X 的过程中，交换机 X 会给生产者 P 一个 ACK 确认回调，生产者可以根据收到 ACK 值知道是否投递成功 
@Configuration
@EnableRabbit
public class RabbitMqConfig {

    public static final String CONFIRM_EXCHANGE_NAME = "confirm-exchange";
    public static final String BACK_EXCHANGE_NAME = "back-confirm-exchange";
    public static final String CONFIRM_QUEUE_NAME = "confirm-queue";
    public static final String BACK_QUEUE_NAME = "back-confirm-queue";

    @Value("${spring.rabbitmq.host}")
    private String host;
    @Value("${spring.rabbitmq.port}")
    private Integer port;
    @Value("${spring.rabbitmq.username}")
    private String username;
    @Value("${spring.rabbitmq.password}")
    private String password;

    @Bean(name="myRabbitTemplate")
    //@Scope
    public RabbitTemplate rabbitTemplate(){
        RabbitTemplate template = new RabbitTemplate(cachingConnectionFactory());
        return template;
    }

    @Bean
    public CachingConnectionFactory cachingConnectionFactory(){
        //新建缓存连接工厂
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setHost(host);
        factory.setPassword(password);
        factory.setUsername(username);
        factory.setPort(port);
        return factory;
    }

    //新建确认交换机
    @Bean
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.
                directExchange(CONFIRM_EXCHANGE_NAME).
                durable(true).
                build();
    }

    //确认队列
    @Bean
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    //绑定交换机和队列
    @Bean
    public Binding confirmBinding(){
        return BindingBuilder.bind(confirmQueue()).to(confirmExchange()).with("ack");
    }
}
@SpringBootTest
class SpringbootRabbitmqSend02ApplicationTests {

    @Autowired
    RabbitTemplate rabbitTemplate;


    @Test
    void contextLoads() {
         rabbitTemplate.convertAndSend("confirm-exchange","ack","你好");
    }

}

2 交换机无法路由问题

  • 当生产者 P 投递消息到交换机 X 的过程中，消息确定收到了，但是路由配置错误，或者没有绑定队列，此时又如何保证消息安全性？

 2.1回退机制让生产者自行处理

  • 仅仅开启确认机制无法保证消息安全性，可以通过回退机制，通知消费者此条消息无法处理，让消费者自行处理消息
  • 建立连接工厂、消息队列和交换机并绑定
@Configuration
@EnableRabbit
public class RabbitMqConfig {

    public static final String CONFIRM_EXCHANGE_NAME = "confirm-exchange";
    public static final String BACK_EXCHANGE_NAME = "back-confirm-exchange";
    public static final String CONFIRM_QUEUE_NAME = "confirm-queue";
    public static final String BACK_QUEUE_NAME = "back-confirm-queue";

    @Value("${spring.rabbitmq.host}")
    private String host;
    @Value("${spring.rabbitmq.port}")
    private Integer port;
    @Value("${spring.rabbitmq.username}")
    private String username;
    @Value("${spring.rabbitmq.password}")
    private String password;
    @Bean(name="myRabbitTemplate")
    //@Scope
    public RabbitTemplate rabbitTemplate(AckCallBack ackCallBack, ReturnCallBack returnCallBack){
        RabbitTemplate template = new RabbitTemplate(cachingConnectionFactory());
        template.setConfirmCallback(ackCallBack);
        template.setMandatory(true);//true交换机回退 false 直接丢弃
        template.setReturnsCallback(returnCallBack);
        return template;
    }

    @Bean
    public CachingConnectionFactory cachingConnectionFactory(){
        //新建缓存连接工厂
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setHost(host);
        factory.setPassword(password);
        factory.setUsername(username);
        factory.setPort(port);
        factory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);
        return factory;
    }

    //新建确认交换机
    @Bean
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.
                directExchange(CONFIRM_EXCHANGE_NAME).
                durable(true).
                build();
    }

    //确认队列
    @Bean
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    //绑定交换机和队列
    @Bean
    public Binding confirmBinding(){
        return BindingBuilder.bind(confirmQueue()).to(confirmExchange()).with("ack");
    }

}
  • 新建AckCallBack
@Component
@Slf4j
public class AckCallBack implements RabbitTemplate.ConfirmCallback {
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData != null ?correlationData.getId():"";
        if(ack){
            log.info("交换机已经收到id:{}消息了",id);
        }else{
            log.info("交换机没有收到id:{}消息,原因是：{}",id,cause);
        }
    }
}
  •  新建ReturnCallBack
@Component
@Slf4j
public class ReturnCallBack implements RabbitTemplate.ReturnsCallback {
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        Message message = returned.getMessage();
        log.info("消息：{}被服务器退回，退回原因：{}，退回码：{}",
                message.getBody(),
                returned.getReplyText(),
                returned.getReplyCode());
        /**
         * 处理方式
         *  1：尝试重新调用
         *  2：落库处理，存入 mysql 数据库中
         */
    }
}

 2.2 备份交换机解决

  • 可以通过给交换机设置备份机的方式，来处理交换机无法路由的消息，备份交换机设置 Fanout 类型，可以添加备份队列，还可以添加告警队列，还可以添加入库队列。 

@Configuration
@EnableRabbit
public class RabbitMqConfig {

    public static final String CONFIRM_EXCHANGE_NAME = "confirm-exchange";
    public static final String BACK_EXCHANGE_NAME = "back-confirm-exchange";
    public static final String CONFIRM_QUEUE_NAME = "confirm-queue";
    public static final String BACK_QUEUE_NAME = "back-confirm-queue";

    @Value("${spring.rabbitmq.host}")
    private String host;
    @Value("${spring.rabbitmq.port}")
    private Integer port;
    @Value("${spring.rabbitmq.username}")
    private String username;
    @Value("${spring.rabbitmq.password}")
    private String password;

    @Bean(name="myRabbitTemplate")
    public RabbitTemplate rabbitTemplate(AckCallBack ackCallBack, ReturnCallBack returnCallBack){
        RabbitTemplate template = new RabbitTemplate(cachingConnectionFactory());
        template.setConfirmCallback(ackCallBack);
        template.setMandatory(true);//true交换机回退 false 直接丢弃
        template.setReturnsCallback(returnCallBack);
        return template;
    }


    @Bean
    public CachingConnectionFactory cachingConnectionFactory(){
        //新建缓存连接工厂
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setHost(host);
        factory.setPassword(password);
        factory.setUsername(username);
        factory.setPort(port);
        factory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);
        return factory;
    }

    //建立确认交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.
                directExchange(CONFIRM_EXCHANGE_NAME).
                durable(true).
                withArgument("alternate-exchange",BACK_EXCHANGE_NAME).
                build();
    }

    //确认队列
    @Bean
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    //绑定交换机和队列
    @Bean
    public Binding confirmBinding(){
        return BindingBuilder.bind(confirmQueue()).to(confirmExchange()).with("ack");
    }

    //声明备份交换机
    @Bean("backExchange")
    public FanoutExchange backExchange(){
        return new FanoutExchange(BACK_EXCHANGE_NAME);

    }

    //声明备份队列
    @Bean("backQueue")
    public Queue backQueue(){
        return QueueBuilder.durable(BACK_QUEUE_NAME).build();
    }

    //绑定备份交换机和队列
    @Bean
    public Binding backBinding(){
        return BindingBuilder.bind(backQueue()).to(backExchange());
    }
}

 3.消费者异常导致数据丢失

3.1消费者确认机制

  • 通过消费者确认机制避免消息丢失：
  • 有三种确认方式：①自动确认：acknowledge=none ②手动确认：acknowledge=manual ③根据异常情况确认：acknowledge=auto
  • 手动确认：
    • 正常执行：调用channel.basicAck(deliveryTag,false);方法确认签收消息
    • 异常执行：在catch中调用 basicNack或basicReject，拒绝消息，让MQ重新发送消息
spring:
  rabbitmq:
    host: 192.168.245.129
    port: 5672
    username: wj
    password: 123456
    listener:
      simple:
        retry:
          enabled: true
        acknowledge-mode: manual #手动ack
@Service
@Slf4j
public class MessageReceive {

    @RabbitListener(queues = {"back-confirm-queue"})
    public void receive(String body, Channel channel, Message message) throws IOException {
        try {
            log.info("队列消息"+body);

            int ret = 1/0;

            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        } catch (Exception e) {
            if (message.getMessageProperties().getRedelivered()){
                channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
            }else {
                channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
            }
        }
    }
}

二、死信队列

1.死信队列概述

  • 死信：在官网中对应的单词为“Dead Letter”，可以看出翻译确实非常的简单粗暴。死信是RabbitMQ的一种消息机制，如果出现以下情况消息将变成死信：
    • 消息在队列的存活时间超过设置的生存时间（TTL)时间
    • 消息队列的消息数量已经超过最大队列长度
    • 消息被否定确认，使用basicNack或basicReject并且requeue=false
  • 死信队列：Dead Letter Queue用来存放死信消息的队列
  • 死信交换机：Dead Letter Exchange用来路由死信消息的交换机

2.死信队列架构图

消息满足刚提到的几个条件之后，消息进入死信队列

3.TTL

  • TTL概述：用来控制消息或者是队列的最大存活时间，单位是毫秒。
  • 设置TTL两种方式：
    • 给消息设置TTL
    • 给队列设置TTL
  • 注意：如果同时配置了队列的 TTL 和消息的 TTL，那么较小的那个值将会被使用。
  • 区别：
    • 消息设置TTL的方式是在消费时做消息过期判断，如果是顶端的，到期直接移除
    • 队列设置过期是直接丢弃或丢到死信队列

4. 死信队列实操

4.1 达到最大长度进入死信队列

  • 限制队列最大长度为10，发送11条消息给正常队列
    //确认队列
    @Bean("confirmQueue")
    public Queue confirmQueue() {
//        return QueueBuilder.durable(TEST_QUEUE_NAME).build();
        Map<String, Object> map = new HashMap<>();
        //设置队列过期时间
//        map.put("x-message-ttl",5000);
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE_NAME);
        //设置队列最大长度
//        map.put("x-max-length",10);


        return QueueBuilder.durable(TEST_QUEUE_NAME).withArguments(map).build();
    }

4.2到达过期时间进入死信队列

  • 设置10秒过期时间
    //确认队列
    @Bean("confirmQueue")
    public Queue confirmQueue() {
//        return QueueBuilder.durable(TEST_QUEUE_NAME).build();
        Map<String, Object> map = new HashMap<>();
        //设置队列过期时间
//        map.put("x-message-ttl",5000);
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE_NAME);
        //设置队列最大长度
//        map.put("x-max-length",10);


        return QueueBuilder.durable(TEST_QUEUE_NAME).withArguments(map).build();
    }

4.3拒收进入死信队列

  • 模拟异常拒收
    //拒收演示
    @RabbitListener(queues = {"test-queue"})
    public void receiveReject(String body, Channel channel, Message message) throws IOException {
        try {

            if ("3".equals(body)){
                log.info("收到异常队列消息"+body);
                int ret = 1/0;
            }
            log.info("队列消息"+body);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        } catch (Exception e) {
            if (message.getMessageProperties().getRedelivered()){
                channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
            }else {
                channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
            }
        }
    }

5.总结

  • 死信交换机和死信队列和普通的没有区别
  • 当消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列
  • 消息成为死信的三种情况：
    • 消息在队列的存活时间超过设置的生存时间（TTL）时间
    • 消息队列的消息数量已经超过最大队列长度
    • 消息被否定确认，使用basicNack或basicReject并且requeue=false

三、延时队列

1.延时队列概述

  • 延时队列：消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费，最重要的特征就是延迟上 

  • 应用场景 ：
    • 12306购票30分钟内不支付自动取消订单，回滚库存
    • 会议设置，15分钟前通知参会人员
  • 解决方案：
    • 通过轮询数据库查询处理
    • 通过延迟队列实现

 

2.延时队列实现

  • RabbitMQ未提供延时队列功能，但是我们可以通过 TTL + 死信队列的方式设计出延时队列 

 

  • RabbitMQ未提供延时队列功能，但是我们可以通过 TTL + 死信队列的方式设计出延时队列
  • 出现问题：发现消费不能按最近过期时间消费问题 

3.安装插件实现延时队列 

  • 下载地址： https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases
  • 上传位置： /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.34/plugins
  • 启用插件： rabbitmq-plugins enablerabbitmq_delayed_message_exchange

4.小结

  • 延迟队列就是指消息进入队列后需要一定时间才消费
  • RabbitMQ本身是没有提供延迟队列功能，可以通过死信队列+过期时间来实现延迟队列
  • 自己实现的延迟队列不能按时消费，可能存在滞后问题，安装延时队列 插件使用

四、RabbitMQ实战场景

1.日志与可视化监控查看

  • 日志文件： /var/log/rabbitmq/rabbit@localhost.log
  • 通过如下操作观察日志：
    • 停止服务：/sbin/service rabbitmq-serverstop
    • 重新启动：rabbitmqctl start_app
    • 开启服务：/bin/systemctl startrabbitmq-server.service

2.消息追踪

  • Firehose：生产者给交换机发送消息时，会按照指定的格式发送到amq.rabbitmq.trace（Topic）交换机上。
    • 开启Firehose命令：rabbitmqctl trace_on
    • 关闭Firehose命令：rabbitmqctl trace_off
  • 注意：开启Firehose 会影响性能，不建议一直打开，一般测试时打开
  • rabbitmq_tracing：启用插件来实现可视化查看
    • 查看插件：rabbitmq-plugins list
    • 启用插件：rabbitmq-plugins enable rabbitmq_tracing
    • 关闭插件：rabbitmq-plugins disable rabbitmq_tracing

3.幂等性保障

  • 幂等性：是分布式中比较重要的一个概念，是指在多作业操作时候避免造成重复影响，其实就是保证同一个消息不被 消费者重复消费两次。但是实际开发中可能存在网络波动等问题，生产者无法接受消费者发送ack信息，因此这条消 息将会被重复发送给其他消费者进行消费，实际上这条消息已经被消费过了，这就是重复消费的问题。
  • 如何去避免重复消费问题：
  • 数据库乐观锁机制
    • update items set count=count-1 where count= #{count} and id = #{id}
    • update items set count=count-1,version=version+1 where version=#{version} and id = #{id}
  • 生成全局唯一id+redis锁机制:操作之前先判断是否抢占了分布式锁 setNx 命名

 五、RabbitMQ集群

1.目前存在的问题

  • 单节点的RabbitMQ如果内存崩溃、机器掉电或者主板故障，会影响整个业务线正常使用
  • 单机吞吐性能会受内存、带宽大小限制

2.解决方案

2.1使用集群模式来解决 

 

 

  •  搭建RabbitMQ集群

  • RabbitMQ集群存在问题 

 

  •  RabbitMQ集群解决

 

 

 

 

 

 

 

 

喝咖啡学Java
关注
专栏目录
RabbitMq实战使用
forever_chm的博客
01-04 948
首先要清楚rabbitmq基础知识 生产者：生产消息 消费者：消费监听指定队列的消息 配置类：将交换机队列绑定到一起 引入依赖： <!-- mq --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> &lt
4、RabbitMQ---六大模式之简单队列模式
weixin_45608577的博客
07-19 267
本节我们将用 Java 编写两个程序。发送单个消息的生产者和接收消息并打印 出来的消费者。 1、创建一个maven工程并且添加依赖 <!--指定 jdk 编译版本--> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId>
RabbitMQ 使用教程
最新发布
白白白鲤鱼的博客
08-11 2117
RabbitMQ使用教程
rabbitMQ实战应用
ShiYueMemo37329的博客
04-01 1038
在这个示例中，我们创建了两个消费者，并且每个消费者会从队列中接收请求消息，并模拟处理请求的过程。：在Java项目中，可以将一些耗时的任务（如文件处理、邮件发送等）放入消息队列中，由后台的消费者异步地处理这些任务，提高系统的吞吐量和响应速度。，将日志消息发送到RabbitMQ队列，然后有一个或多个日志消费者从队列中接收日志消息并进行相应的分析和处理。数据消费者可以从这个队列中接收实时数据并进行相应的处理。创建一个简单的生产者和消费者，它们通过RabbitMQ进行消息的发送和接收，实现了微服务间的通信。
RabbitMQ在生产中的实际应用
qq_44663150的博客
04-06 1482
怎么确保消息的可靠性 要确保消息的可靠性，主要从这两方面去确认 消息成功到达Exchange 消息成功到达Queue 如果这两步中任一步骤出现问题，那么消息就没有成功送达，此时我们可能要通过重试等方式去重新发送消息，多次重试之后，如果消息还是不能到达，则可能就需要人工介入了。 经过上面的分析，我们可以确认，要确保消息成功发送，我们只需要做好三件事就可以了： 确认消息到达 Exchange。 确认消息到达 Queue。 开启定时任务，定时投递那些发送失败的消息。 生产者保证消息可靠 先来看第一步，确认
RabbitMQ在实际项目中的应用
weixin_67601403的博客
05-29 5490
RabbitMQ简介 以商品订单场景为例， 如果商品服务和订单服务是两个不同的微服务，在下单的过程中订单服务需要调用商品服务进行扣库存操作。按照传统的方式，下单过程要等到调用完毕之后才能返回下单成功，如果网络产生波动等原因使得商品服务扣库存延迟或者失败，会带来较差的用户体验，如果在高并发的场景下，这样的处理显然是不合适的，那怎么进行优化呢？这就需要消息队列登场了。 消息队列提供一个异步通信机制，消息的发送者不必一直等待到消息被成功处理才返回，而是立即返回。消息中间件负责处理网络通信，如果网络连接不可用
RabbitMQ实战指南-rabbitmq-action.zip
11-07
通过学习RabbitMQ实战指南，你可以掌握如何在实际项目中运用RabbitMQ，实现高效、可靠的异步通信，提升系统的稳定性和可扩展性。在实践中，结合具体的业务场景，灵活运用上述知识，将有助于构建出更加健壮的分布式...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
RabbitMQ实战 高效部署分布式消息队列 带目录 高清版 PDF
09-13
《RabbitMQ实战：高效部署分布式消息队列》是一本深度解析RabbitMQ技术的书籍，旨在帮助读者理解和掌握如何在实际项目中高效地运用这一强大的消息中间件。书中不仅涵盖了RabbitMQ的基础知识，还深入探讨了其在分布式...
RabbitMQ实战 高效部署分布式消息队列 PDF下载
11-24
通过深入学习和实践《RabbitMQ实战：高效部署分布式消息队列》，开发者能够全面了解RabbitMQ的特性和应用场景，提升分布式系统的设计与实施能力。这本书的内容无疑是学习和掌握RabbitMQ的宝贵资源。
RabbitMQ实战教程
06-10
本课程适用于RabbitMQ实战者以及SpringBoot整合RabbitMQ实战需求者。课程将首先带领大家拜读RabbitMQ官网的技术开发手册，之后会将学到的知识深入的实战到实际的各种应用场景中，从而加深知识点的理解，其中包括如何...
Rabbitmq在工作中的应用
浪里小白龙
09-02 747
工作中会遇到一些流程复杂、处理耗时的任务，直接执行在高并发时可能会导致服务器阻塞，以前放入mission表，用定时任务取出来处理，但是低并发时实时性比较差，现在用消息队列可以更方便的应对，不但减轻服务器和数据库的压力，还能降低业务之间的耦合。
RabbitMQ实战应用场景(服务解耦)
m0_73414953的博客
06-01 676
通过消息队列实现不同服务间的解耦，提高系统的可拓展性和可维护性。在实战案例中难免会遇到服务间耦合度过高的问题。流程图：举个常见的例子，在分布式电商项目中，我们通过(搜索引擎)来实现搜索功能并且查询出的数据是在中查询出来的，而在后台中我们修改商品信息或者新增商品信息，在ElasticSearch中商品信息并不会得到同步修改，也就是说修改商品之后会导致后台和前台的数据不一致，此时如果不用RabbitMQ。
RabbitMQ的应用总结
art_code的博客
09-01 666
RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现。AMQP 的出现其实也是应了广大人民群众的需求，虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实现（如微软的 MSMQ ，IBM 的 Websphere MQ 等），因此，在 ...
rabbitmq实战篇 - 使用场景
weixin_49300975的博客
04-25 648
rabbitmq 秒杀场景实现 本文仅自己学习使用,如有雷同勿喷。
RabbitMQ 典型应用场景实战
猿码天地
03-02 8688
一、实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 二、RabbitMQ 官网拜读 首先，让我们先拜读 RabbitMQ 官网的技术开发手册以及相关的 Features，感兴趣的朋友可以耐心的阅读其中的相关介绍，相信会有一定的收获，地址可见：RabbitMQ 官网 阅读该手册过程中，我们可以得知 RabbitMQ 其实核心就
Rabbitmq的应用场景
weixin_46879188的博客
08-19 1551
虽然并行已经提高的处理时间,但是,前面说过,邮件和短信对我正常的使用网站没有任何影响，客户端没有必要等着其发送完成才显示注册成功,应该是写入数据库后就返回. 消息队列: 引入消息队列后，把发送邮件,短信不是必须的业务逻辑异步处理。​​并行方式​​:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。​​订单系统​​:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功。2.秒杀业务根据消息队列中的请求信息，再做后续处理.
RabbitMQ —— 理解及应用场景
小蜜蜂vs码农
06-22 2303
RabbitMQ —— 理解及应用场景
RabbitMq 实际使用
weixin_42630616的博客
05-20 201
配置 // 测试支付队列 public static final String EXCHANGE_PUSH = “my-mq-exchange_PUSH”;//交换机 public static final String QUEUE_PUSH = “QUEUE_PUSH”;//队列 public static final String ROUTINGKEY_PUSH = “spring-boot-routingKey_PUSH”;//路由 // 配置交换机实例 @Bean public DirectEx..
SpringBoot与RabbitMQ实战配置与应用实例
通过这些姿势，开发者可以快速上手SpringBoot与RabbitMQ的集成，并在项目中灵活应用，提高系统的异步处理能力和解耦能力。整个文档旨在提供实操指导，对于想要掌握SpringBoot和RabbitMQ协作的读者来说，是一份有价值...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值