五、RabbitMQ消息投递案例

最新推荐文章于 2024-05-18 18:45:00 发布
最新推荐文章于 2024-05-18 18:45:00 发布
阅读量47 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/strap/article/details/132795888
版权

消息投递案例

在这里插入图片描述

这里以推送文档到es，做同步更新索引为例

增加配置

  rabbitmq:
    # 使confirmCallback回调生效
    publisher-confirm-type: correlated
    # 使returnsCallback回调生效
    publisher-returns: true
    # 如果配置为false，交换机没有匹配到队列就会丢弃掉消息，而不会触发returnCallback的回调
    template:
      mandatory: true

创建消息体

/**
 * <p>
 *  消息体
 * </p>
 *
 * @author strap
 */
@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class DocMessage implements Serializable {

    private static final long serialVersionUID = 2136809013109440975L;

    private String messageId;

    /**
     * 文档主键
     */
    private Long documentId;

    /**
     * 文档存放的路径
     */
    private String filePath;

}

创建消息日志类

/**
 * <p>
 * 
 * </p>
 *
 * @author strap
 */
@TableName("broker_message_log")
@ApiModel(value = "BrokerMessageLog对象", description = "消息记录")
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class BrokerMessageLog extends Model<BrokerMessageLog> implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(type = IdType.INPUT)
    private String messageId;

    private String message;

    private Integer tryCount;

    private Integer state;

    private LocalDateTime nextRetry;

    private LocalDateTime createTime;

    private LocalDateTime updateTime;

}

创建历史消息记录类

成功处理完的记录，从消息记录表删除，添加到历史记录表

/**
 * <p>
 *  已经成功消费的消息转到此处存放，即state=1
 * </p>
 *
 * @author strap
 */
@TableName("broker_message_log_history")
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class BrokerMessageLogHistory extends BrokerMessageLog implements Serializable {

    private static final long serialVersionUID = 4922336781826093421L;

    @TableId(type = IdType.NONE)
    private String messageId;

}

生产者代码

/**
 * <p>生产者</p>
 *
 * @author strap
 */
@Component
@Log4j
public class MqProducer {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Resource
    private BrokerMessageLogMapper brokerMessageLogMapper;

    public MqProducer() {
    }

    public void sendOrder(DocMessage docMessage) throws Exception {
        // 消息投递到交换机，不管是否成功投递到交换机都回调，成功投递到交换机则ack=true
        rabbitTemplate.setConfirmCallback(
                (correlationData, ack, cause) -> {
                    if (ack) {
                        log.info("消息已成功投递到了交换机，但不知道是否路由到队列");
                    } else {
                        log.info("消息未投递到交换机");
                        new BrokerMessageLog()
                                .setState(4)  //消息未投递到交换机
                                .setUpdateTime(LocalDateTimeUtil.now())
                                .update(
                                        Wrappers.<BrokerMessageLog>lambdaUpdate()
                                                .set(
                                                        BrokerMessageLog::getNextRetry, null
                                                ).eq(
                                                        BrokerMessageLog::getMessageId, correlationData.getId()
                                                )
                                );
                    }
                }
        );

        // 消息从交换机分配到队列时失败才回调，假设连交换机都找不到（即只会触发ConfirmCallback返回nack），ReturnsCallback不会触发
        rabbitTemplate.setReturnsCallback(
                returnedMessage -> {
                    log.info("消息投递到队列失败，如可能匹配不到路由键");
                    String messageId = returnedMessage.getMessage().getMessageProperties().getCorrelationId();
                    new BrokerMessageLog()
                            .setState(5)  //消息投递到队列失败
                            .setUpdateTime(LocalDateTimeUtil.now())
                            .update(
                                    Wrappers.<BrokerMessageLog>lambdaUpdate()
                                            .set(
                                                    BrokerMessageLog::getNextRetry, null
                                            ).eq(
                                                    BrokerMessageLog::getMessageId, messageId
                                            )
                            );
                }
        );
        CorrelationData correlationData = new CorrelationData(docMessage.getMessageId());
        rabbitTemplate.convertAndSend(MyDemoConstants.MQConstants.EXCHANGE_NAME, MyDemoConstants.MQConstants.ROUTING_KEY_NAME, docMessage, correlationData);
    }

}

消费者代码

/**
 * <p>消费者</p>
 *
 * @author strap
 */
@Component
@Log4j
public class MqConsumer {

    @Resource
    private DocMessageService docMessageService;

    public MqConsumer() {
    }

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(value = MyDemoConstants.MQConstants.QUEUE_NAME, durable = "true",
                            arguments = {
                                    @Argument(name = MyDemoConstants.MQConstants.DEAD_EXCHANGE_LABEL, value = MyDemoConstants.MQConstants.DEAD_EXCHANGE),
                                    @Argument(name = MyDemoConstants.MQConstants.DEAD_ROUTING_KEY_LABEL, value = MyDemoConstants.MQConstants.DEAD_ROUTING_KEY)
                            }),
                    exchange = @Exchange(name = MyDemoConstants.MQConstants.EXCHANGE_NAME, type = "topic"),
                    key = MyDemoConstants.MQConstants.ROUTING_KEY_NAME
            )
    )
    @RabbitHandler
    public void consume(@Payload DocMessage docMessage, @Headers Map<String, Object> headers, Channel channel) throws Exception {
        log.info("消费者已拿到消息：" + docMessage);

        // 消息的下标index，批量确认消息：即确认所有下标小于该值的消息
        Long index = Convert.toLong(headers.get(AmqpHeaders.DELIVERY_TAG));
        // 是否是重复消费
        Boolean isRedeliver = Convert.toBool(headers.get(AmqpHeaders.REDELIVERED));
        if (docMessageService.runTask(docMessage)) {
            // 业务执行成功， 确认消息，但不批量确认
            channel.basicAck(index, false);
            log.info("messageId:" + docMessage.getMessageId() + ", 成功被消费");
        } else if (!isRedeliver) {
            // 不是重复消费，及业务处理未完成，不批量确认，告知MQ重发
            channel.basicNack(index, false, true);
            log.info("messageId:" + docMessage.getMessageId() + ", 被重新投递");
        } else {
            channel.basicNack(index, false, false);
            log.info("messageId:" + docMessage.getMessageId() + ", 进入死信队列");
        }

    }


    /**
     * 处理死信消息
     */
    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(value = MyDemoConstants.MQConstants.DEAD_QUEUE, durable = "true"),
                    exchange = @Exchange(name = MyDemoConstants.MQConstants.DEAD_EXCHANGE, type = "topic"),
                    key = MyDemoConstants.MQConstants.DEAD_ROUTING_KEY
            )
    )
    @RabbitHandler
    public void consumeDeadLetter(@Payload DocMessage docMessage, @Headers Map<String, Object> headers, Channel channel) throws Exception {
        // 消息的下标index，批量确认消息：即确认所有下标小于该值的消息
        Long index = Convert.toLong(headers.get(AmqpHeaders.DELIVERY_TAG));
        channel.basicAck(index, false);
        log.info("死信消息已经被处理：" + docMessage.getMessageId());
        new BrokerMessageLog()
                .setState(3)  //死信消息
                .setUpdateTime(LocalDateTimeUtil.now())
                .update(
                        Wrappers.<BrokerMessageLog>lambdaUpdate()
                                .set(
                                        BrokerMessageLog::getNextRetry, null
                                ).eq(
                                        BrokerMessageLog::getMessageId, docMessage.getMessageId()
                                )
                );
    }

}

业务处理类

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author strap
 */
@Service
@Log4j
public class DocMessageService {

    @Resource
    private MqProducer mqProducer;

    @Resource
    private BrokerMessageLogMapper brokerMessageLogMapper;

    @Resource
    private BrokerMessageLogHistoryMapper brokerMessageLogHistoryMapper;

    public void updateDoc(DocMessage docMessage) throws Exception {
        LocalDateTime now = LocalDateTimeUtil.now();
        boolean add = new BrokerMessageLog()
                .setMessageId(docMessage.getMessageId())
                .setMessage(JSONUtil.toJsonStr(docMessage))
                .setState(0)
                .setCreateTime(now)
                .setTryCount(1)
                .setUpdateTime(now)
                .setNextRetry(now.plus(3, ChronoUnit.MINUTES))// 3分钟后如果状态还是0就取出来重试
                .insert();
        if (add) {
            mqProducer.sendOrder(docMessage);
        }
    }

    // 模拟处理业务，处理成功返回true
    @Transactional(rollbackFor = Exception.class)
    public boolean runTask(DocMessage docMessage) throws Exception {
        BrokerMessageLog brokerMessageLog = brokerMessageLogMapper.selectById(docMessage.getMessageId());
        if (brokerMessageLog == null) {
            return true;
        }
        String filePath = docMessage.getFilePath();
        log.info("filePath:" + filePath);
        // 取路径读取文档获取请求es进行索引更新，这里模拟业务处理 TODO
        boolean success = filePath.length() > 3;
        if (success) {
            // 修改状态并存入历史消息
            BrokerMessageLogHistory logHistory = BeanUtil.copyProperties(brokerMessageLog, BrokerMessageLogHistory.class);
            logHistory.setNextRetry(null).setState(1).setUpdateTime(LocalDateTimeUtil.now());
            brokerMessageLogHistoryMapper.insert(logHistory);
            brokerMessageLog.deleteById();
        }
        return success;
    }

}

定时任务处理类

/**
 * <p></p>
 *
 * @author strap
 */
@Log4j
@ConditionalOnExpression("#{T(cn.hutool.core.util.StrUtil).isNotEmpty(\"${cron.job1}\")}")
@Component
public class MySpringQuartzJob {

    @Resource
    private BrokerMessageLogMapper brokerMessageLogMapper;

    @Resource
    private MqProducer mqProducer;

    public MySpringQuartzJob() {
    }

    @Scheduled(cron = "${cron.job1}")
    public void run() throws Exception {
        log.info("定时任务开始执行");

        Page<BrokerMessageLog> records = brokerMessageLogMapper.selectPage(
                new Page<>(),
                Wrappers.<BrokerMessageLog>lambdaQuery()
                        .eq(BrokerMessageLog::getState, 0)
                        .lt(BrokerMessageLog::getNextRetry, LocalDateTimeUtil.now())
        );
        for (BrokerMessageLog record : records.getRecords()) {
            if (record.getTryCount() > 2) {
                // 已尝试三次，不需要再重发
                new BrokerMessageLog()
                        .setState(2) // 重试多次仍然失败，不再重发
                        .update(
                                Wrappers.<BrokerMessageLog>lambdaUpdate()
                                        .set(
                                                BrokerMessageLog::getNextRetry, null
                                        ).eq(
                                                BrokerMessageLog::getMessageId, record.getMessageId()
                                        )
                        );
            } else {
                new BrokerMessageLog()
                        .setMessageId(record.getMessageId())
                        .setTryCount(record.getTryCount() + 1)
                        .setUpdateTime(LocalDateTimeUtil.now())
                        .updateById();
                mqProducer.sendOrder(JSONUtil.toBean(record.getMessage(), DocMessage.class));
            }
        }

    }

}

业务触发

    @GetMapping("/updateDoc")
    public void updateDoc() throws Exception {
        docMessageService.updateDoc(
                new DocMessage(
                        UUID.randomUUID().toString(true),
                        10251L,
                        "/article/20220322/xxx.doc"
                )
        );
    }
strap
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ 代码案例
08-15
代码写的是关于 RabbitMQ学习中的一些演示，对于刚接触 RabbitMQ的学者来说，当做一个示例
rabbitMQ代码案例 简单入门
10-31
rabbitMQ代码案例 简单入门，适合初学者使用，里面讲的很详细
Spring Boot文档阅读笔记-对Messaging with RabbitMQ解析
IT1995的博客
11-26 660
此篇教程以Rabbitmq作为消息队列服务端，使用Spring Boot产生和发布消息。 使用Spring AMQP的RabbitTemplate发布消息，使用MessageListenerAdapter订阅消息。 其中对应的Maven如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3...
Messaging——Spring for RabbitMQ
十年梦归尘的专栏
12-09 274
Spring for RabbitMQ
rabbitmq+springboot实现消息可靠投递
zwjzone的博客
05-08 1102
最详细，最全面，无bug版消息可靠投递策略演示
RabbitMQ入门案例
zt的博客
04-09 2257
MQ(message queue)，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个
RabbitMQ 消息丢失案例(returnCallback/confirmCallback)
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
07-31 1688
Slf4j@Override//获取RabbitTemplate//设置ReturnCallback//投递失败，记录日志log.info("消息发送失败，应答码{}，原因{}，交换机{}，路由键{},消息{}",//如果有业务需要，可以重发消息});}}//1.消息体";//2.全局唯一的消息ID，需要封装到CorrelationData中//3.添加callback//3.1.ack，消息成功log.debug("消息发送成功,ID。...
RabbitMQ 消息队列
bier_zm的博客
11-08 3569
什么是 RabbitMQ MQ（Message Queue）消息队列 消息队列中间件，是分布式系统中的重要组件； 主要解决异步处理、应用解耦、流量削峰等问题，从而实现高性能，高可用，可伸缩和最终一致性的架构。 使用较多的消息队列产品：RabbitMQ，RocketMQ，ActiveMQ，ZeroMQ，Kafka 等。 异步处理 用户注册后，需要发送验证邮箱和手机验证码。 将注册信息写入数据库，发送验证邮件，发送手机，三个步骤全部完成后，返回给客户端。 传统： 客户端 <-> 注
rabbitmq可靠性投递_Rabbitmq的使用五_消息的可靠性投递
weixin_39796868的博客
12-22 177
Rabbitmq的使用五_消息的可靠性投递官网地址：https://www.rabbitmq.com/tutorials/tutorial-seven-java.html通过前面的学习，可以知道消息的可靠性投递，可以做持久化操作过程一：从生产者发送消息到RabbitMQ服务器的过程。过程二：确保消息从交换机路由到队列过程三：确保消息在队列中正确的存储过程四：确保消息从队列正确地投递到消费者消息本身...
一文读懂RabbitMQ消息队列
zhoupenghui168的博客
04-27 2236
什么是消息队列，为什么要使用消息队列,消息队列使用的场景，RabbitMQ介绍,RabbitMQ的高级特性，RabbitMQ原理以及各种模式，RabbitMQ的高级特性，RabbitMQ的几种交换器，
Rabbitmq消息队列详解
qq_52030824的博客
11-01 4150
Rabbitmq消息队列详解
JAVA获取rabbitmq消息总数过程详解
08-25
主要介绍了JAVA获取rabbitmq消息总数过程详解，公司使用的是rabbitMQ，需要做监控预警的job去监控rabbitMQ里面的堆积消息个数，如何使用rabbitMQ获取监控的队列里面的队列消息个数呢,需要的朋友可以参考下
RabbitMq消息队列指南.docx
07-05
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。 MQ 为Message Queue ， 消息...
RabbitMQ消息服务器-其他
06-11
RabbitMQ是由LShift提供的一个Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的Erlang写成，因此也是继承了这些优点。 AMQP里主要要说两个组件：Exchange和Queue（在AMQP ...
本机搭建RabbitMQ
ql_gome的博客
05-15 953
Exchange（交换机）作用：Exchange是消息的路由器。生产者将消息发送给exchange，而不是直接发送给队列。exchange根据预定义的规则（称为binding）来决定哪些消息应该路由到哪个队列类型：Exchange有多种类型，如direct（直接交换机）、fanout（广播交换机）、topic（主题交换机）和headers（基于消息头的交换机），每种类型的exchange有不同的路由策略配置：Exchange需要预先声明，指定其类型和任何其他相关配置Queue（队列）
RabbitMQ .NET
最新发布
ooo
05-18 219
.NET RabbitMQQ Send Receive
rabbitmq交换机，死信队列的简单例子
weixin_43970625的博客
05-14 553
假设我们有一个场景，生产者有消息发到某个直连交换机，这个交换机上有两个队列分别存储两种类型的消息，但是与这两个队列相连的消费者太不争气了，处理消息有点慢，我们想5秒钟这个消息在队列中还没有被消费的话，就给它丢进死信队列里得了，后续再处理，但是这俩队列明显存储的消息不一样，我们又不好意思将它都扔到同一个死信队列里去，如果我们想要俩死信队列分别装这两个消费者漏掉的消息，那我们怎么做呢？：我们先创建一个工具类用来连接rabbitmq，注意你需要去创建对应的虚拟主机，以及对应的登录账号和密码。
Rabbitmq报unauthorized异常
qq_32590535的博客
05-14 325
处理rabbitmq的unauthorized 异常。Caused by: java.lang.SecurityException: Attempt to deserialize unauthorized class java.util.HashMap;
rabbitMQ 消息可靠投递
05-13
RabbitMQ 是一个开源的消息队列，它采用了 AMQP 协议来实现消息的可靠传输。AMQP 协议提供了消息确认...综上所述，RabbitMQ 提供了多种机制来保证消息的可靠投递，可以根据实际情况选择合适的机制来保证消息的可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值