RabbitMQ + SpringBoot 可靠性投递 + 幂等性实现之一

最新推荐文章于 2024-06-24 15:00:04 发布
最新推荐文章于 2024-06-24 15:00:04 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： # RabbitMQ 文章标签： rabbitmq springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/caplike/article/details/108431010
版权

文章目录

RabbitMQ + SpringBoot “可靠性投递” 和 “幂等性” 探讨

本章我们来探讨一下消息的可靠性投递和幂等性, 并以发送邮件为场景模拟.

引言

消息的幂等性

消息永远不会被消费多次. 实现方式通常有:

  • [本文采用的方式] 唯一 ID + 指纹码机制, 利用数据库的主键去重. 高并发下可能需要 Hash 分库分表.在这里插入图片描述
SELECT COUNT(1) FROM T_ORDER WHERE ID = 唯一 ID + 指纹码;
  • 利用 Redis 的原子性. 哨兵 + 集群模式 (博文链接), 这种方式需要定期将 Redis 的记录同步到数据库中.

消息的可靠性投递

即消息如何保障 100% 投递成功.

首先, 什么是生产端的可靠性投递?

  • 保障消息的成功发出;
  • 保障 MQ Broker 的成功接收: 借助 ReturnListener;
  • 发送端收到 MQ Broker 确认应答 (ACK, NACK): 借助 ConfirmListerner;

消费端需要做什么来保证消息的 100% 消费?

  • 完善的消息进行补偿机制: 定时任务抓取没有应答的消息;

解决方案通常也有两种:

  • [本文采用的方式] 消息落库, 对消息状态进行打标;

    • 生产者投递消息后, 将消息落库;
    • 消费者消费并回执;
    • 生产者通过 ConfirmListener 接收 ACK / NACK 对消息状态更新;
    • 开启定时任务抓取投递失败消息进行重发;在这里插入图片描述

  • 消息的延迟投递, 做二次确认, 回调检查;

    • 生产者发送消息后, 稍后再发一条确认的延迟消息;

    • 消费者监听到消息并消费后, 会发一条确认消息到 MQ Broker;

    • MQ Broker 收到消费者的确认消息后, 消息落库, 随后与生产者发送的确认的延迟消息内容比对是否收到了这条消息:

      • 如果收到就落库
      • ;如果没收到就通知生产者重发

    • 回调服务 (Callback Service) 接收消费者的 ack
      在这里插入图片描述

整个过程对数据库的操作很少, 并且对数据库的操作交由回调服务, 与核心链路独立.

实现

本文基于发送邮件的场景来介绍如何实现可靠性投递和幂等性, 本质上是模拟一个通信模块, 消息的生产者 (Producer) 申请请求投递邮件, 将请求消息发送到消费端, 消费端 (Consumer) 接收到邮件发送请求, 则发起邮件. 整个链路就是这样.

首先我们需要做到的是:

  1. 在生产端, 发送消息前对消息记录落库. 需要保证消息 100% 投递到 Broker, 对投递状态打标 (失败);
  2. 在生产端, 如果路由不到指定的队列, 也需要消费端补偿投递成功但是一段时间内没有消费的消息;
  3. 在消费端, 如果消息被成功消费, 更新消息投递记录的状态 (成功);
  4. 在消费端, 如果消息消费失败 (本案例中, 可能是由于邮件发送服务调用失败), 更新消息投递记录 (失败);
  5. 在消费端, 开启定时任务定时拉取 (失败) 的记录进行重发补偿;

介绍几个核心类的实现, 相关要点都在代码注释中.

完整代码请参考: 代码仓库

server:
  port: 17005
  servlet:
    context-path: /demo-rabbitmq-springboot-idempotence-reliability

spring:
  application:
    name: demo-rabbitmq-springboot-idempotence-reliability
  datasource:
    url: jdbc:mysql://118.24.109.247:3306/demo-rabbitmq
    password: "!GFLiKe0"
    username: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  mail:
    host: smtp.163.com
    username: caplike@163.com
    password: AIABWEWTQVNQQRVX
    default-encoding: UTF-8
    properties:
      mail:
        smtp:
          auth: true
          ssl:
            enable: true
          starttls:
            enable: true
            required: true
  # ~ RabbitMQ Configuration
  rabbitmq:
    host: 118.24.109.247
    publisher-confirm-type: correlated
    publisher-returns: true
    listener:
      simple:
        acknowledge-mode: manual
        prefetch: 10
      direct:
        acknowledge-mode: manual

# ~ MyBatis Configuration
mybatis:
  configuration:
    map-underscore-to-camel-case: true

# ~ Logging.Level
logging:
  level:
    cn.caplike.demo.rabbitmq.springboot.idempotence_reliability: debug

# ~ Custom Configurations
# ---------------------------- ------------------------------------------------------------------------------------------

# ~ Rabbit Broker Declaration
message:
  rabbit:
    mail:
      queue:
        name: demo.idempotence.reliability.mail
      exchange:
        name: demo.idempotence.reliability.mail
        type: direct
      routing-key: demo.idempotence.reliability.mail

Producer - RabbitConfiguration 配置类

启用生产端投递确认机制和监听路由不到的消息, 需要在配置类配置:

值得注意的是, 当 Exchange 存在, 但是 RoutingKey 错误的 “不可路由” 的消息, ConfirmCallback 的 ack = true, 同时 ReturnCallback 也会触发. 对于这类不可路由消息, 应该由消费端定时监听 投递成功但是一定时间之后还没有被消费的记录, 并进行补偿 (TODO).

/**
 * Description: RabbitMQ 配置类
 *
 * @author LiKe
 * @version 1.0.0
 * @date 2020-09-01 17:10
 */
@Slf4j
@Configuration
public class RabbitConfiguration {

    private CachingConnectionFactory connectionFactory;

    private MessageDeliveryLogService messageDeliveryLogService;

    /**
     * 消息的确认指的是生产者投递消息后, 如果 Broker 收到消息, 给生产者应答.<br>
     * 生产者接收应答用来确认消息是否正常的发送到 Broker, 这种方式也是 Producer 端消息的 <strong>可靠性投递</strong> 的核心保障.
     */
    private final RabbitTemplate.ConfirmCallback confirmCallback = (correlationData, ack, cause) -> {
        final String messageId = Optional.ofNullable(correlationData).orElseThrow(() -> new RuntimeException("correlationData is null!")).getId();

        if (ack) {
            // ~ [ ! ] 如果消息发送到 Exchange 成功, 但是 routingKey 错误, 则会触发 ReturnCallback,
            //         ※ 只要 Exchange 正确, 消息成功发送到 Broker, confirmCallback 的 ack = {@code true}
            log.info("Producer :: 消息发送到 Broker - 成功.");

            // ~ 插入成功发送的日志记录
            messageDeliveryLogService.deliverySuccess(messageId);
        } else {
            // ~ [ ! ] 如果生产端发送消息时, 指定了错误的 Exchange, 则消息并没有发送到 Broker, ack = {@code false}

            log.error("Producer :: 消息发送到 Broker - 失败. correlationData: {} cause: {}", correlationData, cause);

            // ~ 消息都没发送到 Broker
            messageDeliveryLogService.deliveryFailed(messageId);
        }
    };

    /**
     * 用于处理一些 <strong>不可路由</strong> 的消息.
     */
    private final RabbitTemplate.ReturnCallback returnCallback = (message, replyCode, replyText, exchange, routingKey) -> {
        // ~ [ ! ] 如果发送到 Exchange 成功, 但是 RoutingKey 不正确:
        //         ConfirmCallback ack = {@code true}, 但是 ReturnCallback 也会调用; 需要注意 ReturnCallback 和 ConfirmCallback 的调用顺序.

        log.error("Producer :: 消息从 Exchange 路由到 Queue 失败: exchange: {}, routingKey: {}, replyCode: {}, replayText: {}, message: {}", exchange, routingKey, replyCode, replyText, message);
        final String messageId = MapUtils.getString(message.getMessageProperties().getHeaders(), PublisherCallbackChannel.RETURNED_MESSAGE_CORRELATION_KEY);

        // ~ TODO 消息发送到了 Broker 但是不可路由, Consumer 端也应该监控这种投递成功但是隔了一段时间还没有消费的消息
    };

    @Bean
    public RabbitTemplate rabbitTemplate() {

        // ~ RabbitTemplate
        // -------------------------------------------------------------------------------------------------------------

        final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        rabbitTemplate.setConfirmCallback(confirmCallback);

        // ~ 在消息没有被路由到合适的队列情况下，Broker 会将消息返回给生产者，
        //    为 true 时如果 Exchange 根据类型和消息 Routing Key 无法路由到一个合适的 Queue 存储消息，
        //        Broker 会调用 Basic.Return 回调给 handleReturn()，再回调给 ReturnCallback，将消息返回给生产者。
        //    为 false 时，丢弃该消息
        rabbitTemplate.setMandatory(Boolean.TRUE);
        rabbitTemplate.setReturnCallback(returnCallback);

        return rabbitTemplate;
    }

    // ~ Autowired
    // -----------------------------------------------------------------------------------------------------------------

    @Autowired
    public void setConnectionFactory(CachingConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }

    @Autowired
    public void setMessageDeliveryLogService(MessageDeliveryLogService messageDeliveryLogService) {
        this.messageDeliveryLogService = messageDeliveryLogService;
    }

}

Producer - MailProducer

MailRequest 为定义的邮件请求对象, 通过 JSON 发送.

/**
 * Description: 邮件发送端
 *
 * @author LiKe
 * @version 1.0.0
 * @date 2020-09-02 13:21
 */
@Slf4j
@RestController
@RequestMapping("/notification")
public class MailProducer {

    private RabbitTemplate rabbitTemplate;

    private MessageDeliveryLogService messageDeliveryLogService;

    @Value("${message.rabbit.mail.exchange.name}")
    private String exchange;

    @Value("${message.rabbit.mail.routing-key}")
    private String routingKey;

    @PostMapping("/mail")
    public void send() {
        final String messageId = UUID.randomUUID().toString();
        final MailRequest mailRequest = MailRequest.builder().messageId(messageId).clientId("local").clientSecret("some-client-secret").receiver("lks.nova@foxmail.com").build();

        // ~ 消息落库
        //   当消息落库失败? 落库成功再发消息, 如果落库成功消息发送失败, 可追溯.
        messageDeliveryLogService.add(
                MessageDeliveryLogBuilder.of()
                        .messageId(messageId).message(mailRequest).exchange(exchange).routingKey(routingKey).status(MessageDeliveryLog.Status.DELIVERING).build()
        );

        // ~ 关于 correlationId: https://stackoverflow.com/questions/53857051/why-cant-i-get-the-correlationid-on-the-consumer-side-by-using-the-spring-boot
        rabbitTemplate.convertAndSend(exchange, routingKey, mailRequest, messagePostProcessor(), new CorrelationData(messageId));
    }

    // ~ MessagePostProcessor
    // -----------------------------------------------------------------------------------------------------------------

    private MessagePostProcessor messagePostProcessor() {
        return message -> {
            final MessageProperties messageProperties = message.getMessageProperties();
            messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
            messageProperties.setContentEncoding(StandardCharsets.UTF_8.name());
            return message;
        };
    }

    // ~ Autowired
    // -----------------------------------------------------------------------------------------------------------------

    @Autowired
    public void setMessageDeliveryLogService(MessageDeliveryLogService messageDeliveryLogService) {
        this.messageDeliveryLogService = messageDeliveryLogService;
    }

    @Autowired
    public void setRabbitTemplate(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }
}

Consumer - RabbitListenerConfiguration

在消费端, 为了接收 JSON 的消息体并自动转换, 需要做额外的配置:

@Configuration
public class RabbitListenerConfiguration implements RabbitListenerConfigurer {

    @Override
    public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
        registrar.setMessageHandlerMethodFactory(messageHandlerMethodFactory());
    }

    @Bean
    public MessageHandlerMethodFactory messageHandlerMethodFactory() {
        final DefaultMessageHandlerMethodFactory messageHandlerMethodFactory = new DefaultMessageHandlerMethodFactory();
        messageHandlerMethodFactory.setMessageConverter(consumerJackson2MessageConverter());
        return messageHandlerMethodFactory;
    }

    @Bean
    public MappingJackson2MessageConverter consumerJackson2MessageConverter() {
        return new MappingJackson2MessageConverter();
    }
}

Consumer - MailRequestMessageListener

@Slf4j
@Component
public class MailRequestMessageListener {

    /**
     * 投递日志服务接口
     */
    private MessageDeliveryLogService messageDeliveryLogService;

    /**
     * 邮件发送服务接口
     */
    private MailSendingService mailSendingService;

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(value = "${message.rabbit.mail.queue.name}", autoDelete = "true", durable = "false"),
                    exchange = @Exchange(value = "${message.rabbit.mail.exchange.name}", type = "${message.rabbit.mail.exchange.type}", autoDelete = "true", durable = "false"),
                    key = "${message.rabbit.mail.routing-key}"
            )
    )
    public void consume(
            Channel channel,
            @Payload MailRequest mailRequest, @Headers Map<String, Object> headers
    ) throws IOException {

        final String messageId = mailRequest.getMessageId();
        final MessageDeliveryLog messageDeliveryLog = messageDeliveryLogService.get(messageId);
        if (messageDeliveryLog.hasConsumed()) {
            log.info("Consumer :: 消息 ({}) 已被消费...", messageId);
            return;
        }

        // ~ Confirm
        final Long deliveryTag = MapUtils.getLong(headers, AmqpHeaders.DELIVERY_TAG);

        try {
            // ~ Send Mail
            mailSendingService.send(
                    MailRequest.builder()
                            .clientId(mailRequest.getClientId()).clientSecret(mailRequest.getClientSecret()).receiver(mailRequest.getReceiver()).build()
            );
        } catch (Exception any) {
            // ~ Mail sending fail, NACK:
            //   1. 告诉 Broker 丢弃这条消息 (default);
            //   2. 用死信队列处理 (require: requeue = false);
            //   3. 用定时任务补偿 (本例采用)
            //   4. 重回队列 (requeue = true);
            //   Reference: https://blog.youkuaiyun.com/sun_tantan/article/details/88667102
            log.error("Consumer :: mail sending failed, cause: {}", any.getMessage());
            messageDeliveryLogService.deliveryFailed(messageId);
            channel.basicNack(deliveryTag, false, false);
            return;
        }

        // ~ Mail sending success, ACK: 告诉 Broker 这条消息已经被消费
        //   TODO 当消息状态更新失败? 发送到另外一个 Exchange 进行记录, 补偿
        messageDeliveryLogService.consumedSuccess(messageId);
        channel.basicAck(deliveryTag, Boolean.FALSE);
    }

    // ~ Autowired
    // -----------------------------------------------------------------------------------------------------------------

    @Autowired
    public void setMessageDeliveryLogService(MessageDeliveryLogService messageDeliveryLogService) {
        this.messageDeliveryLogService = messageDeliveryLogService;
    }

    @Autowired
    public void setMailSendingService(MailSendingService mailSendingService) {
        this.mailSendingService = mailSendingService;
    }
}

Consumer - 定时补偿

@Slf4j
@Service
public class ScheduledMailResendingService {

    private MessageDeliveryLogService messageDeliveryLogService;

    private RabbitTemplate rabbitTemplate;

    /**
     * Description: 每隔一定时间 (30s) 抓取投递失败的消息执行重新投递
     *
     * @return void
     * @author LiKe
     * @date 2020-09-03 09:45:17
     */
    @Scheduled(cron = "0/30 * * * * ?")
    public void execute() {
        log.info("Producer :: 开始执行定时任务 - 重新投递");

        messageDeliveryLogService.fetchDeliveryFailed().forEach(messageDeliveryLog -> {
            final String messageId = messageDeliveryLog.getMessageId();
            if (messageDeliveryLog.getRetryCount() <= 3) {
                rabbitTemplate.convertAndSend(
                        messageDeliveryLog.getExchange(),
                        messageDeliveryLog.getRoutingKey(),
                        JSON.parseObject(new String(Base64.getDecoder().decode(messageDeliveryLog.getMessage().getBytes())), MailRequest.class),
                        new CorrelationData(messageId)
                );

                messageDeliveryLogService.updateResendingStatus(messageId);
                log.info("Producer :: 第 {} 次重新投递消息 (messageId: {})", messageDeliveryLog.getRetryCount() + 1, messageId);
            }
            log.error("Producer :: 消息 (messageId: {}) 超过重试次数", messageId);
        });
    }

    // ~ Autowired
    // -----------------------------------------------------------------------------------------------------------------

    @Autowired
    public void setMessageDeliveryLogService(MessageDeliveryLogService messageDeliveryLogService) {
        this.messageDeliveryLogService = messageDeliveryLogService;
    }

    @Autowired
    public void setRabbitTemplate(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }
}

Consumer - 邮件发送服务

这里采用 thymeleaf 作为邮件模板, 可以参考 代码仓库.

public class MailSendingService {

    private static final String MAIL_SENDER = "caplike@163.com";

    private JavaMailSender mailSender;

    /**
     * {@code Thymeleaf} 模板引擎
     */
    private TemplateEngine templateEngine;

    /**
     * Description: 发送邮件
     *
     * @param mailRequest 邮件内容实体
     * @return void
     * @throws RuntimeException 如果发送邮件异常
     * @author LiKe
     * @date 2020-09-01 17:01:10
     */
    public void send(MailRequest mailRequest) {
        try {
            MimeMessage mimeMessage = mailSender.createMimeMessage();
            MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
            mimeMessageHelper.setFrom(MAIL_SENDER);
            mimeMessageHelper.setTo(mailRequest.getReceiver());
            mimeMessageHelper.setSubject("Client Secret Notification!");
            mimeMessageHelper.setText(
                    templateEngine.process(
                            "mail/template-client-secret-request",
                            new Context(
                                    Locale.CHINESE,
                                    MapUtils.putAll(new HashMap<>(), new String[]{
                                            "clientId", StringUtils.upperCase(mailRequest.getClientId()),
                                            "clientSecret", UUID.randomUUID().toString()
                                    })
                            )
                    ), true);
            mailSender.send(mimeMessage);
        } catch (MessagingException ex) {
            throw new RuntimeException(ex);
        }
    }

    // ~ Autowired
    // -----------------------------------------------------------------------------------------------------------------

    @Autowired
    public void setMailSender(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    @Autowired
    public void setTemplateEngine(TemplateEngine templateEngine) {
        this.templateEngine = templateEngine;
    }
}

后记

核心代码就是这么多了. 其他的 MyBatis 相关代码请参考 代码仓库 吧.

ReturnCallback 接收的不可路由的消息, 实际生产环境中不太可能遇得到.

TODO. 下一篇介绍: 通过死信队列处理 nack 的消息.

Refernece

rabbitmq+springboot实现幂等性操作
weixin_43360488的博客
09-03 1486
举个例子：一个消息M发送到了消息中间件，消息投递到了消费程序A，A接受到了消息，然后进行消费，但在消费到一半的时候程序重启了，这时候这个消息并没有标记为消费成功，这个消息还会继续投递给这个消费者，直到其消费成功了，消息中间件才会停止投递。我们利用消息id来判断消息是否已经消费过，如果该信息被消费过，那么消息表中已经 会有一条数据，由于消费时会先执行插入操作，此时会因为主键冲突无法重复插入，我们就利用这个原理来进行幂等的控制,消息内容可以用json格式来进行传输的。1.开启手动ack配置。
base rabbitmq springboot+rabbitmq 消息幂等性
qq_35573689的博客
02-24 262
direct one2many 的情况下，发送和消费的情况如下： 发送的消息是 one2many====>0 第1接受者接收到的额消息是one2many====>0 发送的消息是 one2many====>1 第2接受者接收到的额消息是one2many====>1 发送的消息是 one2many====>2 第3接受者接收到的额消息是one2many====...
rabbitmq幂等性，优先级队列，惰性队列
白鸽
07-15 468
14、RabbitMQ幂等性 用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。 举个最简单的例子，那就是支付，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常， 此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额发现多扣钱了，流水记录也变成了两条。在以前的单应用系统中，我们只需要把数据操作放入事务中即可，发生错误立即回滚，但是再响应客户端的时候也有可能出现网络中断或者异常等等 1、消息重复消费 消费者在消费 MQ 中的消息
RabbitMQ消息可靠性投递解决方案 - 基于SpringBoot实现
shanchahua123456的博客
01-09 976
原文：https://www.imooc.com/article/49814 幂等性，有序性，补偿性，可查性 生产者： 开放相应的查询接口 Step 1： 首先把消息信息(业务数据）存储到数据库中，紧接着，我们再把这个消息记录也存储到一张消息记录表里（或者另外一个同源数据库的消息记录表），每条消息有唯一ID，保证 业务数据+消息记录 在同一个事务中进行。 Step 2：生...
spring boot rabbitmq_架构 - RabbitMQ消息可靠性投递解决方案（基于SpringBoot实现）
weixin_39543647的博客
11-26 165
谈到消息的可靠性投递，无法避免的，在实际的工作中会经常碰到，尤其是一些金融行业的核心业务需要保障消息不丢失，接下来我们看一个可靠性投递的流程图，说明可靠性投递的念：可靠性投递Step 1： 首先把消息信息(业务数据)存储到数据库中，紧接着，我们再把这个消息记录也存储到一张消息记录表里(或者另外一个同源数据库的消息记录表)Step 2：发送消息到MQ Broker节点(采用confirm方式发送，会...
RabbitMq+springboot
04-20
在本文中，我们将深入探讨如何将RabbitMQ与SpringBoot集成，以实现高效的消息队列系统。RabbitMQ是一款开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing Protocol）协议，广泛应用于分布式系统中...
RabbitMq+Win安装+Springboot整合说明
u010684923的专栏
06-24 1660
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性[架构] 使用较多的消息队列有 ActiveMQ（安全），RabbitMQ，ZeroMQ，Kafka（大数据），MetaMQ，RocketMQ。黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。
rabbitmq + spring boot demo 消息确认、持久化、备用交换机、死信交换机等代码
03-07
本教程将详细介绍如何在Spring Boot应用中结合RabbitMQ实现消息确认、消息持久化、备用交换机以及死信交换机等功能。 首先，让我们理解这些概念： 1. **消息确认**：在RabbitMQ中，消息确认（Message ...
rabbitmq+springboot自动确认收货
最新发布
03-23
好的，我现在需要回答用户关于在Spring Boot中使用RabbitMQ实现消息自动确认机制的最佳实践的问题。首先，我得回顾一下用户提供的引用内容，看看有没有相关的信息可以直接应用。 用户提供了四个引用，其中引用[1]...
SpringBoot整合RabbitMQ-消息可靠性投递
diaohudou1168的博客
01-22 521
本系列是学习SpringBoot整合RabbitMQ的练手，包含服务安装，RabbitMQ整合SpringBoot2.x，消息可靠性投递实现等三篇博客。 　　学习路径：https://www.imooc.com/learn/1042RabbitMQ消息中间件极速入门与实战 　　项目源码：https://github.com/ZbLeaning/Boot-RabbitMQ ...
rabbitmq:演示使用RabbitMQ发布和使用消息
05-09
兔子MQ 该项目旨在演示RabbitMQ的发布和使用消息。 它包括重试失败消息的方法，如果消息使用失败，它将被发送到死信队列，在那里等待几秒钟，然后消息将被传递给交换，然后进入队列，在失败几次后，消息将消失。 入门 这些说明将为您提供在本地计算机上运行并运行的项目的副本，以进行开发和测试。 有关如何在实时系统上部署项目的注释，请参阅部署。 先决条件 您可以安装rabbit mq并自行手动启动。 但是通过使用Docker，它将把您的项目环境与您的机器隔离开，从而更轻松地支持将其交付给其他环境。 因此，请考虑在您的机器上安装Docker进行开发，如果您使用的是MacOS，请点击此。 然后通过以下方法检查安装结果： docker -v or docker-compose -v 建造 构建应用 使用Maven命令 mvn clean package 建立Docker映像 在根目录下，运行
SpringBoot整合RabbitMq(消息可靠投递)
one
07-18 1264
文章目录前言一、RabbitMq简介1、为何用RabbitMq，RabbitMq特点，场景应用2、RabbitMq工作流程3、AMQP协议二、创建工程1.spring-boot-starter-amqp注解2.rabbitTemplate使用3.rabbitListener&rabbitHandler接收消息4.消息队列-可靠投递-发送端确认5.消息队列-可靠投递-消费端确认总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开
基础：RocketMQ
weixin_49185060的博客
12-01 130
RocketMQ基础 MQ（Message Queue）消息队列，是一种用来保存消息数据的队列 队列：数据结构的一种，特征为 “先进先出”
RabbitMQ 高级特性——消息的可靠性投递
cj_eryue的博客
01-25 545
在使用rabbitmq的时候，作为消息发送方希望杜绝任何消息丢失过着投递失败的场景，rabbitMq为我们提供了两种方式用来控制消息的投递可靠性模式： confirm 确认模式 return 回退模式 rabbitmq整个消息投递的路径为：生产者（producer）->rabbitmq broker->exchange->queue->consumer 消息从producer到exchange则会返回一个confirmCallBack 消息从exchange到queu..
RabbitMQ保证消息的可靠投递，Java实现RabbitMQ消息的可靠投递，Springboot实现RabbitMQ消息的可靠投递
秃了也弱了
06-27 1979
title . put("desc" , "新增商户");return k;如果先发MQ的话，如果入库失败，就会导致MQ消息无法回滚了。今天我们就好好聊一聊RabbitMQ消息可靠投递的问题。
rabbitmq+springboot实现消息可靠投递
zwjzone的博客
05-08 1232
最详细，最全面，无bug版消息可靠投递策略演示
springboot整合rabbitMQ系列3 消息发布的可靠性投递(生产者发送消息到mq服务器)---生产者可靠性投递
小哇
04-12 855
以下功能是在此项目上升级https://blog.youkuaiyun.com/qq_41712271/article/details/115619405?spm=1001.2014.3001.5501 在使用 RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。也可以用事务，但性能较差，一般不用 RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。confirm 确认模式 return 退回模式 rabbitmq 整个消息投递的路径为： producer--->rab.
springBoot使用rabbitmq并保证消息可靠性
卷心菜投手
01-04 2975
1、rabbitmq在springboot中使用 2、rabbitmq数据可靠性投递
一起来学SpringBoot | 第十二篇：初探RabbitMQ消息队列
挖坑埋你
05-28 384
SpringBoot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的XML配置，我们只需遵循规范，引入相关的依赖就可以轻易的搭建出一个 WEB 工程 MQ全称（Message Queue）又名消息队列，是一种异步通讯的中间件。可以将它理解成邮局，发送者将消息传递到邮局，然后由邮局帮我们发送给具体的消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值