RocketMq顺序消息和事务消息(四)

最新推荐文章于 2024-04-11 17:26:40 发布

四月天五月雨

最新推荐文章于 2024-04-11 17:26:40 发布

阅读量7k

点赞数 5

分类专栏： java系列中间件文章标签： rocketmq 事务消息分布式事务 java 中间件

本文链接：https://blog.csdn.net/weixin_40533111/article/details/84587967

版权

java系列同时被 2 个专栏收录

23 篇文章 2 订阅

订阅专栏

中间件

7 篇文章 1 订阅

订阅专栏

前言

本篇继续看rocketmq,接 中文文档 集群搭建 rocketmq实战

正文

顺序消息

有很多场景需要顺序消息,比如先买票->再上车;淘宝买东西时,先下订单->付款->发货;等等
此刻我们有个要求 :1.每个订单的消息要有序 2.多个订单可以并行(mq的目的就是解耦和提高系统整体性能).
rocketmq是怎么实现的呢?

1.要发送端确保发送有序,
2. 存储有序(依赖发送有序)
3.消费端才能消费有序(依赖存储有序)

即满足producer - query- consumer 是一对一对一的关系模型,
带着这三个步骤看看代码怎么实现:(以购物流程为例)

生产者端:

/**
     * 生产者1
     */
    @Test
    public void send1() {
        try {
            DefaultMQProducer producer = new DefaultMQProducer("producerGroup1");
            producer.setNamesrvAddr("192.168.229.5:9876;192.168.229.6:9876");
            producer.setRetryTimesWhenSendFailed(3);
            producer.start();
            String[] tags = new String[]{"创建订单", "支付", "发货", "收货", "五星好评"};
            for (int i = 5; i < 25; i++) {
                int orderId = i / 5;
                Message msg = new Message("OrderTopic1", tags[i % tags.length], "uniqueId:" + i,
                        ("order_" + orderId + " " + tags[i % tags.length]).getBytes(RemotingHelper.DEFAULT_CHARSET));
                SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                    @Override
                    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                        //此刻arg == orderId,可以保证是每个订单进入同一个队列
                        Integer id = (Integer) arg;
                        int index = id % mqs.size();
                        return mqs.get(index);
                    }
                }, orderId);
                System.out.printf("%s%n", sendResult);
            }
            producer.shutdown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

一个topic下有多个queue,为了保证发送有序,rocketmq提供了MessageQueueSelector队列选择机制,他有三种实现:
在这里插入图片描述
,我们可使用hash取模法,让同一个订单发送到同一个queue中,再使用同步发送,只有消息A发送成功,再发送消息B,这样,我们保证了发送有序.
rocketmq的topic内的队列机制,可以保证存储满足FIFO,剩下的只需要消费者顺序消费即可
rocketmq仅保证顺序发送,顺序消费由消费者业务保证!!!

消费者端:

有一个消费端时:

 /**
     * 订阅
     */
    @Test
    public void consumer1() {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");
        consumer.setNamesrvAddr("192.168.229.5:9876;192.168.229.6:9876");
        try {
            //设置Consumer从哪开始消费
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
            consumer.subscribe("OrderTopic1", "*");
            // 实现了MessageListenerOrderly表示一个队列只会被一个线程取到, 第二个线程无法访问这个队列,MessageListenerOrderly默认单线程
//            consumer.setConsumeThreadMin(3);
//            consumer.setConsumeThreadMax(6);
            consumer.registerMessageListener(new MessageListenerOrderly() {
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                    try {
                        System.out.println("orderInfo: " + new String(msgs.get(0).getBody(), "utf-8"));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return ConsumeOrderlyStatus.SUCCESS;
                }
            });
            consumer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("Consumer1 Started.");
        while (true) {
        }

    }

先看下结果:
在这里插入图片描述
没有保证全局有序,但局部有序,每个订单的操作消息保证有序了,这种局部顺序满足高并发,符合预期.
上面提到
有两个消费端时:

看源码消费时:只允许有一个消费端或一个线程获取这个queue的锁,这样即能保证前面提到的模型:
producer - query- consumer 是一对一对一
在这里插入图片描述

问题:
consumer1和consumer2分别消费两个完整订单,有个疑问:为什么没有出现消费一半的情况?比如:consumer1消费了创建订单和支付,consumer2消费发货和收货等?
模拟下这种情况:我们在consumer1端刚消费第一条消息,第二条未完成消费时,退出jvm,模仿宕机

/**
     * 订阅
     */
    @Test
    @SuppressWarnings("all")
    public void consumer1() {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");
        consumer.setNamesrvAddr("192.168.229.5:9876;192.168.229.6:9876");
        try {
            //设置Consumer从哪开始消费
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
            consumer.subscribe("OrderTopic1", "*");
            // 实现了MessageListenerOrderly表示一个队列只会被一个线程取到, 第二个线程无法访问这个队列,MessageListenerOrderly默认单线程
//            consumer.setConsumeThreadMin(3);
//            consumer.setConsumeThreadMax(6);
            consumer.registerMessageListener(new MessageListenerOrderly() {
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                    try {
                        String body = new String(msgs.get(0).getBody(), "utf-8");
                        if ("order_1 支付".equals(body) || "order_2 支付".equals(body) || "order_3 支付".equals(body) || "order_4 支付".equals(body)) {
                            //模拟宕机   此刻order_1共有5条消息,此刻消费了一条
                            System.exit(0);
                        }

                        System.out.println("orderInfo: " + body);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return ConsumeOrderlyStatus.SUCCESS;
                }
            });
            consumer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("Consumer1 Started.");
        while (true) {
        }

    }

consumer2端的消费代码不变,看此时结果:
consumer1端:

在这里插入图片描述
仅仅消费了order_1的一条消息,
consumer2端:

也出现了order_1创建订单这一项,显然属于消息重复,造成消息重复的原因很多,也有可能是网络问题,比如consumer消费成功,但通知broker失败,或者broker下发消息到consumer失败等等

消息重复

现在出现了消息重复
理想状态是rocketmq帮我们处理消息重复,实际上他也可以做,但实际情况是鱼与熊掌不可兼得,去重放在broker显然比较重,性能不会高,因此,可以业务上控制,放一个唯一key,用来控制消息,本地可以维护一张key的log表,到这里,顺序消费基本可以使用了

严格顺序消息

显示生活中需要这种全局的严格的顺序消息的较少,
目前已知的应用只有数据库 binlog 同步强依赖严格顺序消息,其他应用推荐普通顺序消息

事务消息

常见的事务处理方式有最终一致性,两阶段,XA,维护本地事务表等,而rocketmq消息中间件就是最终一致性的实现方式之一.

项目规模大起来之后,分布式事务是必然面对的,生活中有这么个场景:许昌学院满庭芳一楼有家卖手工面的,人多时,先付款,卖家给你个小票,之后凭小票来取餐,假如此刻面售光了,你也可以拿着小票去退款或者其他操作.核心点就是小票保证了数据一致性.
银行转账也类似:
A余额宝转账给B10000元,我们要的结果是:要么转账失败,A和B的钱都不变,要么A减10000,B同时加10000,确保数据最终一致

rocketmq是怎么实现的呢?
RocketMQ producer第一阶段发送Prepared消息时，会拿到消息的地址，第二阶段执行本地事物，第三阶段通过第一阶段拿到的地址去访问消息，并修改消息的状态,如果确认消息发送失败了,RocketMQ会定期扫描消息集群中的事物消息，如果发现了Prepared消息，它会向消息发送端(生产者)确认，A的钱到底是减了还是没减呢？如果减了是回滚还是继续发送确认消息呢？RocketMQ会根据发送端设置的策略来决定是回滚还是继续发送确认消息。这样就保证了消息发送与本地事务同时成功或同时失败。

producer端:


 /**
     * 发送
     */
    @Test
    public void send1() {
        TransactionCheckListener transactionCheckListener = new TransactionCheckListenerImpl();
        TransactionMQProducer producer = new TransactionMQProducer("transaction_producer");
        producer.setNamesrvAddr("192.168.229.5:9876;192.168.229.6:9876");
        producer.setTransactionCheckListener(transactionCheckListener);
        try {
            producer.start();
            String[] tags = new String[]{"TagA", "TagB"};
            TransactionExecuterImpl tranExecuter = new TransactionExecuterImpl();
            for (int i = 0; i < 3; i++) {
                Message msg = new Message("transactionTopic1", tags[i % 2], "uniqueId" + i,
                        ("Hello RocketMQ " + i).getBytes());
                SendResult sendResult = producer.sendMessageInTransaction(msg, tranExecuter, null);
                System.out.println(sendResult);
            }
            while (true) {
            }
        } catch (Exception e) {
            producer.shutdown();
            e.printStackTrace();
        }
    }

consumer端:

/**
     * 消费
     */
    @Test
    public void consumer1() {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("transaction_consumer");
        consumer.setNamesrvAddr("192.168.229.5:9876;192.168.229.6:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        try {
            consumer.subscribe("transactionTopic1", "*");
            consumer.registerMessageListener(new MessageListenerConcurrently() {
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                    try {
                        System.out.println("transactionInfo：" + new String(msgs.get(0).getBody()));
                    } catch (Exception e) {
                        e.printStackTrace();
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;// 重试
                    }
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功
                }
            });

            consumer.start();
            System.out.println("transaction_consumer started.");
            while (true) {
            }
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }

本地事务

public class TransactionExecuterImpl implements LocalTransactionExecuter {
    @Override
    public LocalTransactionState executeLocalTransactionBranch(final Message msg, final Object arg) {
        System.out.println("执行本地事务msg = " + new String(msg.getBody()) + "   ;arg = " + arg);
        String tags = msg.getTags();
        if (tags.equals("TagB")) {
            System.out.println("进行-------ROLLBACK");
            return LocalTransactionState.ROLLBACK_MESSAGE;//回滚
//            return LocalTransactionState.UNKNOW;//未决事务
        }
        return LocalTransactionState.COMMIT_MESSAGE;//提交
    }


}

未决事务

public class TransactionCheckListenerImpl implements TransactionCheckListener {
    public LocalTransactionState checkLocalTransactionState(MessageExt msg) {
        try {
            //TODO 根据业务处理
            System.out.println("未决事务，服务器回查客户端msg =" + new String(msg.getBody(),"utf-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
         return LocalTransactionState.ROLLBACK_MESSAGE;
//        return LocalTransactionState.COMMIT_MESSAGE;
//         return LocalTransactionState.UNKNOW;
    }
}

启动consumer,接着启动producer,可以看到,此处模拟1条消息tabB失败:2条tagA的成功
producer日志:
在这里插入图片描述
consumer日志:

结果显示只有2条,符合预期

四月天五月雨

关注

5
点赞
踩
28

收藏

觉得还不错? 一键收藏
5
评论
RocketMq顺序消息和事务消息(四)

前言本篇继续看rocketmq,接中文文档集群搭建 rocketmq实战目录1.顺序消息2.事务消息正文顺序消息有很多场景需要顺序消息,比如先买票-&amp;gt;再上车;淘宝买东西时,先下订单-&amp;gt;付款-&amp;gt;发货;等等此刻我们有个要求 :1.每个订单的消息要有序 2.多个订单可以并行(mq的目的就是解耦和提高系统整体性能).rocketmq是怎么实现的呢?1.要发送...
复制链接

扫一扫