SpringBoot RabbitMQ實現消息可靠投遞

消息投遞時 可能發生丟失的場景：

1. 生產者------msg------> MQ 。可開啓消息投遞結果回調，確保每條消息都收到了回調。
2. MQ。將Queue與消息設置成可持久化，搭建鏡像集羣隊列。
3. MQ-------callback---->生產者。回調時失敗，某條消息在一段時間內未收到回調，則默認投遞失敗，生產者需要再次投遞該消息到MQ。（該場景下會導致同一條消息被重複投遞，消費者端需要自行保證消息冪等消費）

一、實現思路

使用技術:

• SpringBoot
• RabbitMQ
• Mysql
• MybatisPlus
• XxlJob

二、準備，框架搭建

• 數據庫Entity：
  • Message

/**
 * 消息發送歷史
 *
 * @author futao
 * @date 2020/3/31.
 */
@Getter
@Setter
@Builder
@TableName("message")
public class Message extends IdTimeEntity {

    @Tolerate
    public Message() {
    }

    /**
     * 消息承載的業務數據
     */
    @TableField("msg_data")
    private String msgData;

    /**
     * 交換機名稱
     */
    @TableField("exchange_name")
    private String exchangeName;

    /**
     * 路由鍵
     */
    @TableField("routing_key")
    private String routingKey;

    /**
     * 消息狀態
     *
     * @see com.futao.springboot.learn.rabbitmq.doc.reliabledelivery.model.enums.MessageStatusEnum
     */
    @TableField("status")
    private int status;

    /**
     * 重試次數
     */
    @TableField("retry_times")
    private int retryTimes;

    /**
     * 下一次重試時間
     */
    @TableField("next_retry_date_time")
    private LocalDateTime nextRetryDateTime;

}

• 消息狀態枚舉

/**
 * 消息狀態枚舉
 *
 * @author futao
 * @date 2020/3/31.
 */
@Getter
@AllArgsConstructor
public enum MessageStatusEnum {

    /**
     * 1=發送中
     */
    SENDING(1, "發送中"),

    /**
     * 2=發送失敗
     */
    SUCCESS(2, "發送成功"),

    /**
     * 3=發送失敗
     */
    FAIL(3, "發送失敗");

    private int status;
    private String description;
}

• RabbitMQ配置

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: futao
    password: 123456789
    virtual-host: reliable-delivery
    connection-timeout: 15000
    # 發送確認
    publisher-confirms: true
    # 路由失敗回調
    publisher-returns: true
    template:
      # 必須設置成true 消息路由失敗通知監聽者，而不是將消息丟棄
      mandatory: true

app:
  rabbitmq:
    retry:
      # 消息最大重試次數
      max-retry-times: 5
      # 每次重試時間間隔
      retry-interval: 5s
    # 隊列定義
    queue:
      user: user-queue
    # 交換機定義
    exchange:
      user: user-exchange

三、編碼

• 隊列交換機定義與綁定

/**
 * RabbitMQ隊列定義與綁定
 *
 * @author futao
 * @date 2020/3/31.
 */
@Configuration
public class Declare {

    @Bean
    public Queue userQueue(@Value("${app.rabbitmq.queue.user}") String userQueueName) {
        return QueueBuilder
                .durable(userQueueName)
                //.withArgument("x-max-length", 2)
                .build();
    }

    @Bean
    public Exchange userExchange(@Value("${app.rabbitmq.exchange.user}") String userExchangeName) {
        return ExchangeBuilder
                .topicExchange(userExchangeName)
                .durable(true)
                .build();
    }

    @Bean
    public Binding userBinding(Queue userQueue, Exchange userExchange) {
        return BindingBuilder
                .bind(userQueue)
                .to(userExchange)
                .with("user.*")
                .noargs();
    }
}

• 對RabbitTemplate進行增強，設置confirmCallback()消息投遞迴調方法與returnCallback()消息路由失敗回調方法

/**
 * Bean增強
 * 【嚴重警告】: 不可在該類中注入Bean，被注入的Bean不會被BeanPostProcessor增強，造成誤傷。
 * 必須通過容器來獲取需要注入的Bean
 *
 * @author futao
 * @date 2020/3/20.
 */
@Slf4j
@Component
public class BeanEnhance implements BeanPostProcessor {

//    @Resource
//    private MessageMapper messageMapper;

    /**
     * 消息的最大重試次數
     */
    @Value("${app.rabbitmq.retry.max-retry-times}")
    private int maxRetryTimes;

    /**
     * 每次重試時間間隔
     */
    @Value("${app.rabbitmq.retry.retry-interval}")
    private Duration retryInterval;

//    @Autowired
//    private RabbitTemplate rabbitTemplate;
//
//    @Autowired
//    private BeanEnhance enhance;


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        //增強RabbitTemplate
        if (RabbitTemplate.class.equals(bean.getClass())) {
            //消息投遞成功與否的監聽，可以用來保證消息100%投遞到rabbitMQ。（如果某條消息（通過id判定)在一定時間內未收到該回調，則重發該消息)
            //需要設置 publisher-confirms: true
            ((RabbitTemplate) bean).setConfirmCallback((correlationData, ack, cause) -> {
                String correlationDataId = correlationData.getId();
                if (ack) {
                    //ACK
                    log.debug("消息[{}]投遞成功，將DB中的消息狀態設置爲投遞成功", correlationDataId);
                    ApplicationContextHolder.getBean(MessageMapper.class).update(null,
                            Wrappers.<Message>lambdaUpdate()
                                    .set(Message::getStatus, MessageStatusEnum.SUCCESS.getStatus())
                                    .eq(Message::getId, correlationDataId)
                    );
                } else {
                    log.debug("消息[{}]投遞失敗,cause:{}", correlationDataId, cause);
                    //NACK，消息重發
                    ApplicationContextHolder.getBean(BeanEnhance.class).reSend(correlationDataId);
                }
            });

            //消息路由失敗的回調--需要設置   publisher-returns: true 並且   template: mandatory: true 否則rabbit將丟棄該條消息
            ((RabbitTemplate) bean).setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
                log.warn("消息路由失敗回調...做一些補償或者記錄.............................................");
                log.warn("message{}", message);
                log.warn("replyCode{}", replyCode);
                log.warn("replyText{}", replyText);
                log.warn("exchange{}", exchange);
                log.warn("routingKey{}", routingKey);
            });
        }
        return bean;
    }


    /**
     * NACK時進行消息重發
     *
     * @param correlationDataId
     */
    @Transactional(rollbackFor = Exception.class)
    public void reSend(String correlationDataId) {
        Message message = ApplicationContextHolder.getBean(MessageMapper.class).selectById(correlationDataId);
        if (message.getRetryTimes() < maxRetryTimes) {
            //進行重試
            ApplicationContextHolder.getBean(RabbitTemplate.class).convertAndSend(message.getExchangeName(), message.getRoutingKey(), message.getMsgData(), new CorrelationData(correlationDataId));
            //更新DB消息狀態
            ApplicationContextHolder.getBean(MessageMapper.class).update(null,
                    Wrappers.<Message>lambdaUpdate()
                            .set(Message::getStatus, MessageStatusEnum.SENDING.getStatus())
                            .set(Message::getNextRetryDateTime, LocalDateTime.now(ZoneOffset.ofHours(8)).plus(retryInterval))
                            .set(Message::getRetryTimes, message.getRetryTimes() + 1)
                            .eq(Message::getId, correlationDataId)
            );
        }
    }
}

• 生產者：

/**
 * @author futao
 * @date 2020/3/31.
 */
@Component
public class Sender {

    @Value("${app.rabbitmq.retry.retry-interval}")
    private Duration retryInterval;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Resource
    private MessageMapper messageMapper;

    @Value("${app.rabbitmq.exchange.user}")
    private String userExchangeName;

    public void send(User user) {
        Message message = Message.builder()
                .msgData(JSON.toJSONString(user))
                .exchangeName(userExchangeName)
                .routingKey("user.abc")
                .status(MessageStatusEnum.SENDING.getStatus())
                //下次重試時間
                .nextRetryDateTime(LocalDateTime.now(ZoneOffset.ofHours(8)).plus(retryInterval))
                .retryTimes(0)
                .build();
        //消息落庫
        messageMapper.insert(
                message
        );
        CorrelationData correlationData = new CorrelationData(message.getId());
        //消息投遞到MQ
        rabbitTemplate.convertAndSend(userExchangeName, "user.abc", JSON.toJSONString(user), correlationData);
    }
}

• 定時任務掃描DB中的消息狀態，如果存在發送中的消息，且當前時間>=下一次投遞時間 and 重試次數<=最大重試次數，則再次進行投遞。
  • XxlJob配置

xxl:
  job:
    switch: ON
    admin:
      ### 調度中心部署跟地址 [選填]：如調度中心集羣部署存在多個地址則用逗號分隔。執行器將會使用該地址進行"執行器心跳註冊"和"任務結果回調"；爲空則關閉自動註冊；
      addresses: http://127.0.0.1:9090/xxl-job-admin
    executor:
      ### 執行器AppName [選填]：執行器心跳註冊分組依據；爲空則關閉自動註冊
      appname: xxl-job-executor-rabbitmq
      ### 執行器IP [選填]：默認爲空表示自動獲取IP，多網卡時可手動設置指定IP，該IP不會綁定Host僅作爲通訊實用；地址信息用於 "執行器註冊" 和 "調度中心請求並觸發任務"；
      # ip:
      ### 執行器端口號 [選填]：小於等於0則自動獲取；默認端口爲9999，單機部署多個執行器時，注意要配置不同執行器端口；
      port: 9999
      ### 執行器運行日誌文件存儲磁盤路徑 [選填] ：需要對該路徑擁有讀寫權限；爲空則使用默認路徑；
      logpath: data/applogs/xxl-job/jobhandler
      ### 執行器日誌文件保存天數 [選填] ： 過期日誌自動清理, 限制值大於等於3時生效; 否則, 如-1, 關閉自動清理功能；
      logretentiondays: 30
    ### 執行器通訊TOKEN [選填]：非空時啓用；
    accessToken:

• Configuration

/**
 * XXL-JOB配置
 *
 * @author futao
 * @date 2020/4/1.
 */
@Setter
@Getter
@Slf4j
@Configuration
@ConfigurationProperties(prefix = "xxl.job")
public class XxlJobConfig {


    private final Admin admin = new Admin();
    private final Executor executor = new Executor();

    @Bean
    public XxlJobSpringExecutor xxlJobExecutor(XxlJobConfig xxlJobConfig) {
        log.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(xxlJobConfig.getAdmin().getAddresses());
        xxlJobSpringExecutor.setAppName(xxlJobConfig.getExecutor().getAppName());
        xxlJobSpringExecutor.setIp(xxlJobConfig.getExecutor().getIp());
        xxlJobSpringExecutor.setPort(xxlJobConfig.getExecutor().getPort());
        xxlJobSpringExecutor.setLogPath(xxlJobConfig.getExecutor().getLogPath());
        xxlJobSpringExecutor.setLogRetentionDays(xxlJobConfig.getExecutor().getLogRetentionDays());
        return xxlJobSpringExecutor;
    }

    @Getter
    @Setter
    public static class Admin {
        private String addresses;
    }

    @Getter
    @Setter
    public static class Executor {
        private String appName;
        private String ip;
        private int port;
        private String logPath;
        private int logRetentionDays;
    }
}

• 定時掃描任務編寫

/**
 * 掃描數據庫中需要重新投遞的消息並重新投遞
 *
 * @author futao
 * @date 2020/4/1.
 */
@Slf4j
@Component
public class MessageReSendJob extends IJobHandler {


    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Resource
    private MessageMapper messageMapper;

    @Autowired
    private MessageReSendJob messageReSendJob;

    /**
     * 最大重試次數
     */
    @Value("${app.rabbitmq.retry.max-retry-times}")
    private int retryTimes;

    /**
     * 重試時間間隔
     */
    @Value("${app.rabbitmq.retry.retry-interval}")
    private Duration retryInterval;

    /**
     * 批量從數據庫中讀取的消息
     */
    private static final int PAGE_SIZE = 100;


    @XxlJob(value = "MessageReSendJob", init = "jobHandlerInit", destroy = "jobHandlerDestroy")
    @Override
    public ReturnT<String> execute(String s) throws Exception {
        long startTime = System.currentTimeMillis();
        log.info("開始掃描需要進行重試投遞的消息");
        XxlJobLogger.log("開始掃描需要進行重試投遞的消息");
        service(1);
        log.info("掃描需要進行重試投遞的消息任務結束，耗時[{}]ms", System.currentTimeMillis() - startTime);
        XxlJobLogger.log("掃描需要進行重試投遞的消息任務結束，耗時[{}]ms", System.currentTimeMillis() - startTime);
        return ReturnT.SUCCESS;
    }

    public void service(int pageNum) {
        IPage<Message> messageIPage = messageMapper.selectPage(new Page<>(pageNum, PAGE_SIZE),
                Wrappers.<Message>lambdaQuery()
                        //發送中的消息
                        .eq(Message::getStatus, MessageStatusEnum.SENDING.getStatus())
                        //已到達下次發送時間
                        .le(Message::getNextRetryDateTime, LocalDateTime.now(ZoneOffset.ofHours(8)))
        );
        List<Message> messages = messageIPage.getRecords();
        messages.forEach(message -> {
            if (retryTimes <= message.getRetryTimes()) {
                //已達到最大投遞次數，將消息設置爲投遞失敗
                messageMapper.update(null, Wrappers.<Message>lambdaUpdate().set(Message::getStatus, MessageStatusEnum.FAIL.getStatus()).eq(Message::getId, message.getId()));
            } else {
                messageReSendJob.reSend(message);
            }
        });
        if (PAGE_SIZE == messages.size()) {
            service(++pageNum);
        }
    }


    /**
     * 重新投遞消息
     *
     * @param message
     */
    public void reSend(Message message) {
        messageMapper.update(null,
                Wrappers.<Message>lambdaUpdate()
                        .set(Message::getRetryTimes, message.getRetryTimes() + 1)
                        .set(Message::getNextRetryDateTime, LocalDateTime.now(ZoneOffset.ofHours(8)).plus(retryInterval))
                        .eq(Message::getId, message.getId())
        );
        try {
            //再次投遞
            rabbitTemplate.convertAndSend(message.getExchangeName(), message.getRoutingKey(), message.getMsgData(), new CorrelationData(message.getId()));
        } catch (Exception e) {
            log.error("消息[{}]投遞失敗", JSON.toJSONString(message));
        }
    }

    public void jobHandlerInit() {
        log.info("before job execute...");
        XxlJobLogger.log("before job handler init...");
    }

    public void jobHandlerDestroy() {
        log.info("after job execute...");
        XxlJobLogger.log("after job execute...");
    }
}

• XxlJob 新增調度任務
  

四、測試

• 測試接口

/**
 * @author futao
 * @date 2020/4/1.
 */
@RequestMapping("/user")
@RestController
public class UserController {

    @Autowired
    private Sender sender;

    @RequestMapping("/send")
    public void send() {
        sender.send(User
                .builder()
                .userName("天文")
                .birthday(LocalDate.of(1995, 1, 31))
                .address("浙江杭州")
                .build());
    }
}

• 正常場景：

消息落庫，狀態爲1=發送中

回調

消息設置成投遞成功

• 異常場景

啓動生產者服務後停止MQ
發送消息

因爲收不到該條消息的ACK。所以一直處於發送中。開啓任務調度再次進行投遞(投遞次數+1，且更新下次投遞時間)

當投遞次數達到最大投遞次數，下一次，將消息設置成投遞失敗

調度日誌

# Next

• 消息可靠消費
• 消費端限流保護
• 死信隊列
• 延遲隊列