rocketmq总结(消息的顺序、重复、事务、消费模式)

迈不过友情╰ 2022-02-09 11:11 435阅读 0赞

# **更多**RocketMQ**资源请访问[www.itkc8.com][]** #

[https://www.cnblogs.com/xuwc/p/9034352.html][https_www.cnblogs.com_xuwc_p_9034352.html]

# 分布式开放消息系统(RocketMQ)的原理与实践 #

分布式消息系统作为实现分布式系统可扩展、可伸缩性的关键组件，需要具有高吞吐量、高可用等特点。而谈到消息系统的设计，就回避不了两个问题：

> 1.  消息的顺序问题
> 2.  消息的重复问题

RocketMQ作为阿里开源的一款高性能、高吞吐量的消息中间件，它是怎样来解决这两个问题的？RocketMQ 有哪些关键特性？其实现原理是怎样的？

关键特性以及其实现原理

一、顺序消息

消息有序指的是一类消息消费时，能按照发送的顺序来消费。例如：一个订单产生了 3 条消息，分别是订单创建、订单付款、订单完成。消费时，要按照这个顺序消费才有意义。但同时订单之间又是可以并行消费的。

假如生产者产生了2条消息：M1、M2，要保证这两条消息的顺序，应该怎样做？你脑中想到的可能是这样：

![2][]

你可能会采用这种方式保证消息顺序

M1发送到S1后，M2发送到S2，如果要保证M1先于M2被消费，那么需要M1到达消费端后，通知S2，然后S2再将M2发送到消费端。

这个模型存在的问题是，如果M1和M2分别发送到两台Server上，就不能保证M1先达到，也就不能保证M1被先消费，那么就需要在MQ Server集群维护消息的顺序。那么如何解决？一种简单的方式就是将M1、M2发送到同一个Server上：

![2 1][]

保证消息顺序，你改进后的方法

这样可以保证M1先于M2到达MQServer（客户端等待M1成功后再发送M2），根据先达到先被消费的原则，M1会先于M2被消费，这样就保证了消息的顺序。

这个模型，理论上可以保证消息的顺序，但在实际运用中你应该会遇到下面的问题：

![2 2][]

网络延迟问题

只要将消息从一台服务器发往另一台服务器，就会存在网络延迟问题。如上图所示，如果发送M1耗时大于发送M2的耗时，那么M2就先被消费，仍然不能保证消息的顺序。即使M1和M2同时到达消费端，由于不清楚消费端1和消费端2的负载情况，仍然有可能出现M2先于M1被消费。如何解决这个问题？将M1和M2发往同一个消费者即可，且发送M1后，需要消费端响应成功后才能发送M2。

但又会引入另外一个问题，如果发送M1后，消费端1没有响应，那是继续发送M2呢，还是重新发送M1？一般为了保证消息一定被消费，肯定会选择重发M1到另外一个消费端2，就如下图所示。

![2 3][]

保证消息顺序的正确姿势

这样的模型就严格保证消息的顺序，细心的你仍然会发现问题，消费端1没有响应Server时有两种情况，一种是M1确实没有到达，另外一种情况是消费端1已经响应，但是Server端没有收到。如果是第二种情况，重发M1，就会造成M1被重复消费。也就是我们后面要说的第二个问题，消息重复问题。

回过头来看消息顺序问题，严格的顺序消息非常容易理解，而且处理问题也比较容易，要实现严格的顺序消息，简单且可行的办法就是：

> 保证`生产者 - MQServer - 消费者`是一对一对一的关系

但是这样设计，并行度就成为了消息系统的瓶颈（吞吐量不够），也会导致更多的异常处理，比如：只要消费端出现问题，就会导致整个处理流程阻塞，我们不得不花费更多的精力来解决阻塞的问题。

但我们的最终目标是要集群的高容错性和高吞吐量。这似乎是一对不可调和的矛盾，那么阿里是如何解决的？

> 世界上解决一个计算机问题最简单的方法：“恰好”不需要解决它！

有些问题，看起来很重要，但实际上我们可以通过合理的设计或者将问题分解来规避。如果硬要把时间花在解决它们身上，实际上是浪费的，效率低下的。从这个角度来看消息的顺序问题，我们可以得出两个结论：

> 1、不关注乱序的应用实际大量存在  
> 2、队列无序并不意味着消息无序

最后我们从源码角度分析RocketMQ怎么实现发送顺序消息。

一般消息是通过轮询所有队列来发送的（负载均衡策略），顺序消息可以根据业务，比如说订单号相同的消息发送到同一个队列。下面的示例中，OrderId相同的消息，会发送到同一个队列：

![复制代码][copycode.gif]

// RocketMQ默认提供了两种MessageQueueSelector实现：随机/Hash
    SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
        @Override
        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
            Integer id = (Integer) arg;
            int index = id % mqs.size();
            return mqs.get(index);
        }
    }, orderId);

![复制代码][copycode.gif]

在获取到路由信息以后，会根据`MessageQueueSelector`实现的算法来选择一个队列，同一个OrderId获取到的队列是同一个队列。

![复制代码][copycode.gif]

private SendResult send()  {
        // 获取topic路由信息
        TopicPublishInfo topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic());
        if (topicPublishInfo != null && topicPublishInfo.ok()) {
            MessageQueue mq = null;
            // 根据我们的算法，选择一个发送队列
            // 这里的arg = orderId
            mq = selector.select(topicPublishInfo.getMessageQueueList(), msg, arg);
            if (mq != null) {
                return this.sendKernelImpl(msg, mq, communicationMode, sendCallback, timeout);
            }
        }
    }

![复制代码][copycode.gif]

二、消息重复

上面在解决消息顺序问题时，引入了一个新的问题，就是消息重复。那么RocketMQ是怎样解决消息重复的问题呢？还是“恰好”不解决。

造成消息的重复的根本原因是：网络不可达。只要通过网络交换数据，就无法避免这个问题。所以解决这个问题的办法就是不解决，转而绕过这个问题。那么问题就变成了：如果消费端收到两条一样的消息，应该怎样处理？

> 1、消费端处理消息的业务逻辑保持幂等性  
> 2、保证每条消息都有唯一编号且保证消息处理成功与去重表的日志同时出现

第1条很好理解，只要保持幂等性，不管来多少条重复消息，最后处理的结果都一样。第2条原理就是利用一张日志表来记录已经处理成功的消息的ID，如果新到的消息ID已经在日志表中，那么就不再处理这条消息。

我们可以看到第1条的解决方式，很明显应该在消费端实现，不属于消息系统要实现的功能。第2条可以消息系统实现，也可以业务端实现。正常情况下出现重复消息的概率不一定大，且由消息系统实现的话，肯定会对消息系统的吞吐量和高可用有影响，所以最好还是由业务端自己处理消息重复的问题，这也是RocketMQ不解决消息重复的问题的原因。

**RocketMQ不保证消息不重复，如果你的业务需要保证严格的不重复消息，需要你自己在业务端去重。**

三、事务消息

RocketMQ除了支持普通消息，顺序消息，另外还支持事务消息。首先讨论一下什么是事务消息以及支持事务消息的必要性。我们以一个转帐的场景为例来说明这个问题：Bob向Smith转账100块。

在单机环境下，执行事务的情况，大概是下面这个样子：

![2 4][]

单机环境下转账事务示意图

当用户增长到一定程度，Bob和Smith的账户及余额信息已经不在同一台服务器上了，那么上面的流程就变成了这样：

![2 5][]

集群环境下转账事务示意图

这时候你会发现，同样是一个转账的业务，在集群环境下，耗时居然成倍的增长，这显然是不能够接受的。那我们如何来规避这个问题？

> **大事务 = 小事务 + 异步**

将大事务拆分成多个小事务异步执行。这样基本上能够将跨机事务的执行效率优化到与单机一致。转账的事务就可以分解成如下两个小事务：

![2 6][]

小事务+异步消息

图中执行本地事务（Bob账户扣款）和发送异步消息应该保持同时成功或者失败中，也就是扣款成功了，发送消息一定要成功，如果扣款失败了，就不能再发送消息。那问题是：我们是先扣款还是先发送消息呢？

首先我们看下，先发送消息，大致的示意图如下：

![2 7][]

事务消息：先发送消息

存在的问题是：如果消息发送成功，但是扣款失败，消费端就会消费此消息，进而向Smith账户加钱。

先发消息不行，那我们就先扣款呗，大致的示意图如下：

![2 8][]

事务消息-先扣款

存在的问题跟上面类似：如果扣款成功，发送消息失败，就会出现Bob扣钱了，但是Smith账户未加钱。

可能大家会有很多的方法来解决这个问题，比如：直接将发消息放到Bob扣款的事务中去，如果发送失败，抛出异常，事务回滚。这样的处理方式也符合“恰好”不需要解决的原则。RocketMQ支持事务消息，下面我们来看看RocketMQ是怎样来实现的。

![2 9][]

RocketMQ实现发送事务消息

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

那我们来看下RocketMQ源码，是不是这样来处理事务消息的。客户端发送事务消息的部分（完整代码请查看：`rocketmq-example`工程下的`com.alibaba.rocketmq.example.transaction.TransactionProducer`）：

![复制代码][copycode.gif]

// 未决事务，MQ服务器回查客户端
    // 也就是上文所说的，当RocketMQ发现`Prepared消息`时，会根据这个Listener实现的策略来决断事务
    TransactionCheckListener transactionCheckListener = new TransactionCheckListenerImpl();
    // 构造事务消息的生产者
    TransactionMQProducer producer = new TransactionMQProducer("groupName");
    // 设置事务决断处理类
    producer.setTransactionCheckListener(transactionCheckListener);
    // 本地事务的处理逻辑，相当于示例中检查Bob账户并扣钱的逻辑
    TransactionExecuterImpl tranExecuter = new TransactionExecuterImpl();
    producer.start()
    // 构造MSG，省略构造参数
    Message msg = new Message(......);
    // 发送消息
    SendResult sendResult = producer.sendMessageInTransaction(msg, tranExecuter, null);
    producer.shutdown();

![复制代码][copycode.gif]

接着查看`sendMessageInTransaction`方法的源码，总共分为3个阶段：发送`Prepared消息`、执行本地事务、发送确认消息。

![复制代码][copycode.gif]

public TransactionSendResult sendMessageInTransaction(.....)  {
        // 逻辑代码，非实际代码
        // 1.发送消息
        sendResult = this.send(msg);
        // sendResult.getSendStatus() == SEND_OK
        // 2.如果消息发送成功，处理与消息关联的本地事务单元
        LocalTransactionState localTransactionState = tranExecuter.executeLocalTransactionBranch(msg, arg);
        // 3.结束事务
        this.endTransaction(sendResult, localTransactionState, localException);
    }

![复制代码][copycode.gif]

`endTransaction`方法会将请求发往`broker(mq server)`去更新事物消息的最终状态：

1.  根据`sendResult`找到`Prepared消息`
2.  根据`localTransaction`更新消息的最终状态

如果`endTransaction`方法执行失败，导致数据没有发送到`broker`，`broker`会有回查线程定时（默认1分钟）扫描每个存储事务状态的表格文件，如果是已经提交或者回滚的消息直接跳过，如果是`prepared状态`则会向`Producer`发起`CheckTransaction`请求，`Producer`会调用`DefaultMQProducerImpl.checkTransactionState()`方法来处理`broker`的定时回调请求，而`checkTransactionState`会调用我们的事务设置的决断方法，最后调用`endTransactionOneway`让`broker`来更新消息的最终状态。

再回到转账的例子，如果Bob的账户的余额已经减少，且消息已经发送成功，Smith端开始消费这条消息，这个时候就会出现消费失败和消费超时两个问题？解决超时问题的思路就是一直重试，直到消费端消费消息成功，整个过程中有可能会出现消息重复的问题，按照前面的思路解决即可。

![2 10][]

消费事务消息

这样基本上可以解决超时问题，但是如果消费失败怎么办？阿里提供给我们的解决方法是：**人工解决**。大家可以考虑一下，按照事务的流程，因为某种原因Smith加款失败，需要回滚整个流程。如果消息系统要实现这个回滚流程的话，系统复杂度将大大提升，且很容易出现Bug，估计出现Bug的概率会比消费失败的概率大很多。我们需要衡量是否值得花这么大的代价来解决这样一个出现概率非常小的问题，这也是大家在解决疑难问题时需要多多思考的地方。

> 20160321补充：在3.2.6版本中移除了事务消息的实现，所以此版本不支持事务消息，具体情况请参考rocketmq的issues：  
> [https://github.com/alibaba/RocketMQ/issues/65][https_github.com_alibaba_RocketMQ_issues_65]  
> [https://github.com/alibaba/RocketMQ/issues/138][https_github.com_alibaba_RocketMQ_issues_138]  
> [https://github.com/alibaba/RocketMQ/issues/156][https_github.com_alibaba_RocketMQ_issues_156]

四、Producer如何发送消息

`Producer`轮询某topic下的所有队列的方式来实现发送方的负载均衡，如下图所示：

![2 11][]

producer发送消息负载均衡

首先分析一下RocketMQ的客户端发送消息的源码：

![复制代码][copycode.gif]

// 构造Producer
    DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
    // 初始化Producer，整个应用生命周期内，只需要初始化1次
    producer.start();
    // 构造Message
    Message msg = new Message("TopicTest1",// topic
                            "TagA",// tag：给消息打标签,用于区分一类消息，可为null
                            "OrderID188",// key：自定义Key，可以用于去重，可为null
                            ("Hello MetaQ").getBytes());// body：消息内容
    // 发送消息并返回结果
    SendResult sendResult = producer.send(msg);
    // 清理资源，关闭网络连接，注销自己
    producer.shutdown();

![复制代码][copycode.gif]

在整个应用生命周期内，生产者需要调用一次start方法来初始化，初始化主要完成的任务有：

> 1.  如果没有指定`namesrv`地址，将会自动寻址
> 2.  启动定时任务：更新namesrv地址、从namsrv更新topic路由信息、清理已经挂掉的broker、向所有broker发送心跳...
> 3.  启动负载均衡的服务

初始化完成后，开始发送消息，发送消息的主要代码如下：

![复制代码][copycode.gif]

private SendResult sendDefaultImpl(Message msg,......) {
        // 检查Producer的状态是否是RUNNING
        this.makeSureStateOK();
        // 检查msg是否合法：是否为null、topic,body是否为空、body是否超长
        Validators.checkMessage(msg, this.defaultMQProducer);
        // 获取topic路由信息
        TopicPublishInfo topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic());
        // 从路由信息中选择一个消息队列
        MessageQueue mq = topicPublishInfo.selectOneMessageQueue(lastBrokerName);
        // 将消息发送到该队列上去
        sendResult = this.sendKernelImpl(msg, mq, communicationMode, sendCallback, timeout);
    }

![复制代码][copycode.gif]

代码中需要关注的两个方法`tryToFindTopicPublishInfo`和`selectOneMessageQueue`。前面说过在producer初始化时，会启动定时任务获取路由信息并更新到本地缓存，所以`tryToFindTopicPublishInfo`会首先从缓存中获取topic路由信息，如果没有获取到，则会自己去`namesrv`获取路由信息。`selectOneMessageQueue`方法通过轮询的方式，返回一个队列，以达到负载均衡的目的。

如果Producer发送消息失败，会自动重试，重试的策略：

1.  重试次数 < retryTimesWhenSendFailed（可配置）
2.  总的耗时（包含重试n次的耗时） < sendMsgTimeout（发送消息时传入的参数）
3.  同时满足上面两个条件后，Producer会选择另外一个队列发送消息

五、消息存储

RocketMQ的消息存储是由`consume queue`和`commit log`配合完成的。

1、Consume Queue

consume queue是消息的逻辑队列，相当于字典的目录，用来指定消息在物理文件`commit log`上的位置。

我们可以在配置中指定consume queue与commitlog存储的目录  
每个`topic`下的每个`queue`都有一个对应的`consumequeue`文件，比如：

${rocketmq.home}/store/consumequeue/${topicName}/${queueId}/${fileName}

Consume Queue文件组织，如图所示：

![2 12][]

Consume Queue文件组织示意图

1.  根据`topic`和`queueId`来组织文件，图中TopicA有两个队列0,1，那么TopicA和QueueId=0组成一个ConsumeQueue，TopicA和QueueId=1组成另一个ConsumeQueue。
2.  按照消费端的`GroupName`来分组重试队列，如果消费端消费失败，消息将被发往重试队列中，比如图中的`%RETRY%ConsumerGroupA`。
3.  按照消费端的`GroupName`来分组死信队列，如果消费端消费失败，并重试指定次数后，仍然失败，则发往死信队列，比如图中的`%DLQ%ConsumerGroupA`。

> 死信队列（Dead Letter Queue）一般用于存放由于某种原因无法传递的消息，比如处理失败或者已经过期的消息。

Consume Queue中存储单元是一个20字节定长的二进制数据，顺序写顺序读，如下图所示：

![2 13][]

consumequeue文件存储单元格式

1.  CommitLog Offset是指这条消息在Commit Log文件中的实际偏移量
2.  Size存储中消息的大小
3.  Message Tag HashCode存储消息的Tag的哈希值：主要用于订阅时消息过滤（订阅时如果指定了Tag，会根据HashCode来快速查找到订阅的消息）

2、Commit Log

CommitLog：消息存放的物理文件，每台`broker`上的`commitlog`被本机所有的`queue`共享，不做任何区分。  
文件的默认位置如下，仍然可通过配置文件修改：

${user.home} \store\${commitlog}\${fileName}

CommitLog的消息存储单元长度不固定，文件顺序写，随机读。消息的存储结构如下表所示，按照编号顺序以及编号对应的内容依次存储。

![2 14][]

Commit Log存储单元结构图

3、消息存储实现

消息存储实现，比较复杂，也值得大家深入了解，后面会单独成文来分析，这小节只以代码说明一下具体的流程。

![复制代码][copycode.gif]

// Set the storage time
    msg.setStoreTimestamp(System.currentTimeMillis());
    // Set the message body BODY CRC (consider the most appropriate setting
    msg.setBodyCRC(UtilAll.crc32(msg.getBody()));
    StoreStatsService storeStatsService = this.defaultMessageStore.getStoreStatsService();
    synchronized (this) {
        long beginLockTimestamp = this.defaultMessageStore.getSystemClock().now();
        // Here settings are stored timestamp, in order to ensure an orderly global
        msg.setStoreTimestamp(beginLockTimestamp);
        // MapedFile：操作物理文件在内存中的映射以及将内存数据持久化到物理文件中
        MapedFile mapedFile = this.mapedFileQueue.getLastMapedFile();
        // 将Message追加到文件commitlog
        result = mapedFile.appendMessage(msg, this.appendMessageCallback);
        switch (result.getStatus()) {
        case PUT_OK:break;
        case END_OF_FILE:
             // Create a new file, re-write the message
             mapedFile = this.mapedFileQueue.getLastMapedFile();
             result = mapedFile.appendMessage(msg, this.appendMessageCallback);
         break;
         DispatchRequest dispatchRequest = new DispatchRequest(
                    topic,// 1
                    queueId,// 2
                    result.getWroteOffset(),// 3
                    result.getWroteBytes(),// 4
                    tagsCode,// 5
                    msg.getStoreTimestamp(),// 6
                    result.getLogicsOffset(),// 7
                    msg.getKeys(),// 8
                    /**
                     * Transaction
                     */
                    msg.getSysFlag(),// 9
                    msg.getPreparedTransactionOffset());// 10
        // 1.分发消息位置到ConsumeQueue
        // 2.分发到IndexService建立索引
        this.defaultMessageStore.putDispatchRequest(dispatchRequest);
    }

![复制代码][copycode.gif]

4、消息的索引文件

如果一个消息包含key值的话，会使用IndexFile存储消息索引，文件的内容结构如图：

![2 15][]

消息索引

索引文件主要用于根据key来查询消息的，流程主要是：

1.  根据查询的 key 的 hashcode%slotNum 得到具体的槽的位置(slotNum 是一个索引文件里面包含的最大槽的数目，例如图中所示 slotNum=5000000)
2.  根据 slotValue(slot 位置对应的值)查找到索引项列表的最后一项(倒序排列,slotValue 总是指向最新的一个索引项)
3.  遍历索引项列表返回查询时间范围内的结果集(默认一次最大返回的 32 条记录)

六、消息订阅

RocketMQ消息订阅有两种模式，一种是Push模式，即MQServer主动向消费端推送；另外一种是Pull模式，即消费端在需要时，主动到MQServer拉取。但在具体实现时，Push和Pull模式都是采用消费端主动拉取的方式。

首先看下消费端的负载均衡：

![2 16][]

消费端负载均衡

消费端会通过RebalanceService线程，10秒钟做一次基于topic下的所有队列负载：

1.  遍历Consumer下的所有topic，然后根据topic订阅所有的消息
2.  获取同一topic和Consumer Group下的所有Consumer
3.  然后根据具体的分配策略来分配消费队列，分配的策略包含：平均分配、消费端配置等

如同上图所示：如果有 5 个队列，2 个 consumer，那么第一个 Consumer 消费 3 个队列，第二 consumer 消费 2 个队列。这里采用的就是平均分配策略，它类似于我们的分页，TOPIC下面的所有queue就是记录，Consumer的个数就相当于总的页数，那么每页有多少条记录，就类似于某个Consumer会消费哪些队列。

通过这样的策略来达到大体上的平均消费，这样的设计也可以很方面的水平扩展Consumer来提高消费能力。

消费端的Push模式是通过长轮询的模式来实现的，就如同下图：

![2 17][]

Push模式示意图

Consumer端每隔一段时间主动向broker发送拉消息请求，broker在收到Pull请求后，如果有消息就立即返回数据，Consumer端收到返回的消息后，再回调消费者设置的Listener方法。如果broker在收到Pull请求时，消息队列里没有数据，broker端会阻塞请求直到有数据传递或超时才返回。

当然，Consumer端是通过一个线程将阻塞队列`LinkedBlockingQueue<PullRequest>`中的`PullRequest`发送到broker拉取消息，以防止Consumer一致被阻塞。而Broker端，在接收到Consumer的`PullRequest`时，如果发现没有消息，就会把`PullRequest`扔到ConcurrentHashMap中缓存起来。broker在启动时，会启动一个线程不停的从ConcurrentHashMap取出`PullRequest`检查，直到有数据返回。

七、RocketMQ的其他特性

前面的6个特性都是基本上都是点到为止，想要深入了解，还需要大家多多查看源码，多多在实际中运用。当然除了已经提到的特性外，RocketMQ还支持：

1.  定时消息
2.  消息的刷盘策略
3.  主动同步策略：同步双写、异步复制
4.  海量消息堆积能力
5.  高效通信
6.  .......

其中涉及到的很多设计思路和解决方法都值得我们深入研究：

1.  消息的存储设计：既要满足海量消息的堆积能力，又要满足极快的查询效率，还要保证写入的效率。
2.  高效的通信组件设计：高吞吐量，毫秒级的消息投递能力都离不开高效的通信。
3.  .......

RocketMQ最佳实践

一、Producer最佳实践

1、一个应用尽可能用一个 Topic，消息子类型用 tags 来标识，tags 可以由应用自由设置。只有发送消息设置了tags，消费方在订阅消息时，才可以利用 tags 在 broker 做消息过滤。  
2、每个消息在业务层面的唯一标识码，要设置到 keys 字段，方便将来定位消息丢失问题。由于是哈希索引，请务必保证 key 尽可能唯一，这样可以避免潜在的哈希冲突。  
3、消息发送成功或者失败，要打印消息日志，务必要打印 sendresult 和 key 字段。  
4、对于消息不可丢失应用，务必要有消息重发机制。例如：消息发送失败，存储到数据库，能有定时程序尝试重发或者人工触发重发。  
5、某些应用如果不关注消息是否发送成功，请直接使用`sendOneWay`方法发送消息。

二、Consumer最佳实践

1、消费过程要做到幂等（即消费端去重）  
2、尽量使用批量方式消费方式，可以很大程度上提高消费吞吐量。  
3、优化每条消息消费过程

三、其他配置

线上应该关闭`autoCreateTopicEnable`，即在配置文件中将其设置为`false`。

RocketMQ在发送消息时，会首先获取路由信息。如果是新的消息，由于MQServer上面还没有创建对应的`Topic`，这个时候，如果上面的配置打开的话，会返回默认TOPIC的（RocketMQ会在每台`broker`上面创建名为`TBW102`的TOPIC）路由信息，然后`Producer`会选择一台`Broker`发送消息，选中的`broker`在存储消息时，发现消息的`topic`还没有创建，就会自动创建`topic`。后果就是：以后所有该TOPIC的消息，都将发送到这台`broker`上，达不到负载均衡的目的。

所以基于目前RocketMQ的设计，建议关闭自动创建TOPIC的功能，然后根据消息量的大小，手动创建TOPIC。

RocketMQ设计相关

RocketMQ的设计假定：

> 每台PC机器都可能宕机不可服务  
> 任意集群都有可能处理能力不足  
> 最坏的情况一定会发生  
> 内网环境需要低延迟来提供最佳用户体验

RocketMQ的关键设计：

> 分布式集群化  
> 强数据安全  
> 海量数据堆积  
> 毫秒级投递延迟（推拉模式）

这是RocketMQ在设计时的假定前提以及需要到达的效果。我想这些假定适用于所有的系统设计。随着我们系统的服务的增多，每位开发者都要注意自己的程序是否存在单点故障，如果挂了应该怎么恢复、能不能很好的水平扩展、对外的接口是否足够高效、自己管理的数据是否足够安全...... 多多规范自己的设计，才能开发出高效健壮的程序。

附录：RocketMQ涉及到的几个专业术语和整体架构介绍

一、RocketMQ中的专业术语

**Topic**  
`topic`表示消息的第一级类型，比如一个电商系统的消息可以分为：交易消息、物流消息...... 一条消息必须有一个`Topic`。

**Tag**  
`Tag`表示消息的第二级类型，比如交易消息又可以分为：交易创建消息，交易完成消息..... 一条消息可以没有`Tag`。RocketMQ提供2级消息分类，方便大家灵活控制。

**Queue**  
一个`topic`下，我们可以设置多个`queue(消息队列)`。当我们发送消息时，需要要指定该消息的`topic`。RocketMQ会轮询该`topic`下的所有队列，将消息发送出去。

**Producer 与 Producer Group**  
`Producer`表示消息队列的生产者。消息队列的本质就是实现了publish-subscribe模式，生产者生产消息，消费者消费消息。所以这里的`Producer`就是用来生产和发送消息的，一般指业务系统。

`Producer Group`是一类`Producer`的集合名称，这类`Producer`通常发送一类消息，且发送逻辑一致。

**Consumer 与 Consumer Group**  
消息消费者，一般由后台系统异步消费消息。

> `Push Consumer`  
> Consumer 的一种，应用通常向 Consumer 对象注册一个 Listener 接口，一旦收到消息，Consumer 对象立刻回调 Listener 接口方法。  
> `Pull Consumer`  
> Consumer 的一种，应用通常主动调用 Consumer 的拉消息方法从 Broker 拉消息，主动权由应用控制。

`Consumer Group`是一类`Consumer`的集合名称，这类`Consumer`通常消费一类消息，且消费逻辑一致。

**Broker**  
消息的中转者，负责存储和转发消息。可以理解为消息队列服务器，提供了消息的接收、存储、拉取和转发服务。`broker`是RocketMQ的核心，它不不能挂的，所以需要保证`broker`的高可用。

**广播消费**  
一条消息被多个`Consumer`消费，即使这些`Consumer`属于同一个`Consumer Group`，消息也会被`Consumer Group`中的每个`Consumer`都消费一次。在广播消费中的`Consumer Group`概念可以认为在消息划分方面无意义。

**集群消费**  
一个`Consumer Group`中的`Consumer`实例平均分摊消费消息。例如某个`Topic`有 9 条消息，其中一个`Consumer Group`有 3 个实例(可能是 3 个进程,或者 3 台机器)，那么每个实例只消费其中的 3 条消息。

**NameServer**  
`NameServer`即名称服务，两个功能：

1.  接收`broker`的请求，注册`broker`的路由信息
2.  接口`client`的请求，根据某个`topic`获取其到`broker`的路由信息  
    `NameServer`没有状态，可以横向扩展。每个`broker`在启动的时候会到`NameServer`注册；`Producer`在发送消息前会根据`topic`到`NameServer`获取路由(到`broker`)信息；`Consumer`也会定时获取`topic`路由信息。

二、RocketMQ Overview

![2 18][]

rocketmq overview

`Producer`向一些队列轮流发送消息，队列集合称为`Topic`，`Consumer`如果做广播消费，则一个`consumer`实例消费这个`Topic`对应的所有队列；如果做集群消费，则多个`Consumer`实例平均消费这个`Topic`对应的队列集合。

再看下RocketMQ物理部署结构图：

![2 19][]

RocketMQ网络部署图

RocketMQ网络部署特点：

1.  1.  `Name Server` 是一个几乎无状态节点，可集群部署，节点之间无任何信息同步。
    2.  Broker部署相对复杂，Broker分为`Master`与`Slave`，一个`Master`可以对应多个`Slave`，但是一个`Slave`只能对应一个`Master`，`Master`与`Slave`的对应关系通过指定相同的`BrokerName`，不同的`BrokerId`来定义，`BrokerId=0`表示`Master`，非0表示`Slave`。`Master`也可以部署多个。每个`Broker`与`Name Server`集群中的所有节点建立长连接，定时注册`Topic`信息到所有`Name Server`。
    3.  `Producer`与`Name Server`集群中的其中一个节点（随机选择）建立长连接，定期从`Name Server`取Topic路由信息，并向提供Topic 服务的Master建立长连接，且定时向Master发送心跳。Producer 完全无状态，可集群部署。
    4.  `Consumer`与`Name Server`集群中的其中一个节点（随机选择）建立长连接，定期从`Name Server`取Topic 路由信息，并向提供`Topic`服务的Master、Slave建立长连接，且定时向Master、Slave发送心跳。`Consumer`既可以从Master订阅消息，也可以从Slave订阅消息，订阅规则由Broker配置决定。

# RocketMQ事务消费和顺序消费详解 #

### 一、RocketMq有3中消息类型 ###

1.普通消费

2. 顺序消费

3.事务消费

*  **顺序消费场景**

在网购的时候，我们需要下单，那么下单需要假如有三个顺序，第一、创建订单 ，第二：订单付款，第三：订单完成。也就是这个三个环节要有顺序，这个订单才有意义。RocketMQ可以保证顺序消费。

*  rocketMq实现顺序消费的原理

produce在发送消息的时候，把消息发到同一个队列（queue）中,消费者注册消息监听器为MessageListenerOrderly，这样就可以保证消费端只有一个线程去消费消息

注意：是把把消息发到同一个队列（queue），不是同一个topic，默认情况下一个topic包括4个queue

**单个节点（Producer端1个、Consumer端1个）**

**1、Producer.java **

![复制代码][copycode.gif]

**2、Consumer.java**

![复制代码][copycode.gif]

package order;   
    import java.util.List;  
    import java.util.concurrent.TimeUnit;  
    import java.util.concurrent.atomic.AtomicLong;   
    import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;  
    import com.alibaba.rocketmq.client.consumer.listener.ConsumeOrderlyContext;  
    import com.alibaba.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;  
    import com.alibaba.rocketmq.client.consumer.listener.MessageListenerOrderly;  
    import com.alibaba.rocketmq.client.exception.MQClientException;  
    import com.alibaba.rocketmq.common.consumer.ConsumeFromWhere;  
    import com.alibaba.rocketmq.common.message.MessageExt;  
      
    /** 
     * 顺序消息消费，带事务方式（应用可控制Offset什么时候提交） 
     */  
    public class Consumer1 {  
      
        public static void main(String[] args) throws MQClientException {  
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");  
            consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");  
      
            /** 
             * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br> 
             * 如果非第一次启动，那么按照上次消费的位置继续消费 
             */  
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);  
      
            consumer.subscribe("TopicOrderTest", "*");  
      
            consumer.registerMessageListener(new MessageListenerOrderly() {  
                AtomicLong consumeTimes = new AtomicLong(0);  
      
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {  
                    // 设置自动提交  
                    context.setAutoCommit(true);  
                    for (MessageExt msg : msgs) {  
                        System.out.println(msg + ",内容：" + new String(msg.getBody()));  
                    }  
      
                    try {  
                        TimeUnit.SECONDS.sleep(5L);  
                    } catch (InterruptedException e) {  
      
                        e.printStackTrace();  
                    }  
                    ;  
      
                    return ConsumeOrderlyStatus.SUCCESS;  
                }  
            });  
      
            consumer.start();  
      
            System.out.println("Consumer1 Started.");  
        }  
      
    }

![复制代码][copycode.gif]

结果如下图所示：

![Center][]

这个五条数据被顺序消费了

*  **多个节点（Producer端1个、Consumer端2个）**

**Producer.java**

![复制代码][copycode.gif]

package order;  
      
    import java.util.List;  
      
    import com.alibaba.rocketmq.client.exception.MQBrokerException;  
    import com.alibaba.rocketmq.client.exception.MQClientException;  
    import com.alibaba.rocketmq.client.producer.DefaultMQProducer;  
    import com.alibaba.rocketmq.client.producer.MessageQueueSelector;  
    import com.alibaba.rocketmq.client.producer.SendResult;  
    import com.alibaba.rocketmq.common.message.Message;  
    import com.alibaba.rocketmq.common.message.MessageQueue;  
    import com.alibaba.rocketmq.remoting.exception.RemotingException;  
      
    /** 
     * Producer，发送顺序消息 
     */  
    public class Producer {  
        public static void main(String[] args) {  
            try {  
                DefaultMQProducer producer = new DefaultMQProducer("order_Producer");  
                producer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");  
      
                producer.start();  
      
                // String[] tags = new String[] { "TagA", "TagB", "TagC", "TagD",  
                // "TagE" };  
      
                for (int i = 1; i <= 5; i++) {  
      
                    Message msg = new Message("TopicOrderTest", "order_1", "KEY" + i, ("order_1 " + i).getBytes());  
      
                    SendResult sendResult = producer.send(msg, new MessageQueueSelector() {  
                        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {  
                            Integer id = (Integer) arg;  
                            int index = id % mqs.size();  
                            return mqs.get(index);  
                        }  
                    }, 0);  
      
                    System.out.println(sendResult);  
                }  
                for (int i = 1; i <= 5; i++) {  
      
                    Message msg = new Message("TopicOrderTest", "order_2", "KEY" + i, ("order_2 " + i).getBytes());  
      
                    SendResult sendResult = producer.send(msg, new MessageQueueSelector() {  
                        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {  
                            Integer id = (Integer) arg;  
                            int index = id % mqs.size();  
                            return mqs.get(index);  
                        }  
                    }, 1);  
      
                    System.out.println(sendResult);  
                }  
                for (int i = 1; i <= 5; i++) {  
      
                    Message msg = new Message("TopicOrderTest", "order_3", "KEY" + i, ("order_3 " + i).getBytes());  
      
                    SendResult sendResult = producer.send(msg, new MessageQueueSelector() {  
                        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {  
                            Integer id = (Integer) arg;  
                            int index = id % mqs.size();  
                            return mqs.get(index);  
                        }  
                    }, 2);  
      
                    System.out.println(sendResult);  
                }  
      
                producer.shutdown();  
            } catch (MQClientException e) {  
                e.printStackTrace();  
            } catch (RemotingException e) {  
                e.printStackTrace();  
            } catch (MQBrokerException e) {  
                e.printStackTrace();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }

![复制代码][copycode.gif]

**Consumer1.java**

![复制代码][copycode.gif]

/** 
     * 顺序消息消费，带事务方式（应用可控制Offset什么时候提交） 
     */  
    public class Consumer1 {  
      
        public static void main(String[] args) throws MQClientException {  
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");  
            consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");  
      
            /** 
             * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br> 
             * 如果非第一次启动，那么按照上次消费的位置继续消费 
             */  
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);  
      
            consumer.subscribe("TopicOrderTest", "*");  
              
            /** 
             * 实现了MessageListenerOrderly表示一个队列只会被一个线程取到  
             *，第二个线程无法访问这个队列 
             */  
            consumer.registerMessageListener(new MessageListenerOrderly() {  
                AtomicLong consumeTimes = new AtomicLong(0);  
      
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {  
                    // 设置自动提交  
                    context.setAutoCommit(true);  
                    for (MessageExt msg : msgs) {  
                        System.out.println(msg + ",内容：" + new String(msg.getBody()));  
                    }  
      
                    try {  
                        TimeUnit.SECONDS.sleep(5L);  
                    } catch (InterruptedException e) {  
      
                        e.printStackTrace();  
                    }  
                    ;  
      
                    return ConsumeOrderlyStatus.SUCCESS;  
                }  
            });  
      
            consumer.start();  
      
            System.out.println("Consumer1 Started.");  
        }  
      
    }

![复制代码][copycode.gif]

**Consumer2.java**

![复制代码][copycode.gif]

/** 
     * 顺序消息消费，带事务方式（应用可控制Offset什么时候提交） 
     */  
    public class Consumer2 {  
      
        public static void main(String[] args) throws MQClientException {  
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");  
            consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");  
      
            /** 
             * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br> 
             * 如果非第一次启动，那么按照上次消费的位置继续消费 
             */  
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);  
      
            consumer.subscribe("TopicOrderTest", "*");  
              
            /** 
             * 实现了MessageListenerOrderly表示一个队列只会被一个线程取到  
             *，第二个线程无法访问这个队列 
             */  
            consumer.registerMessageListener(new MessageListenerOrderly() {  
                AtomicLong consumeTimes = new AtomicLong(0);  
      
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {  
                    // 设置自动提交  
                    context.setAutoCommit(true);  
                    for (MessageExt msg : msgs) {  
                        System.out.println(msg + ",内容：" + new String(msg.getBody()));  
                    }  
      
                    try {  
                        TimeUnit.SECONDS.sleep(5L);  
                    } catch (InterruptedException e) {  
      
                        e.printStackTrace();  
                    }  
                    ;  
      
                    return ConsumeOrderlyStatus.SUCCESS;  
                }  
            });  
      
            consumer.start();  
      
            System.out.println("Consumer2 Started.");  
        }  
      
    }

![复制代码][copycode.gif]

先启动Consumer1和Consumer2，然后启动Producer，Producer会发送15条消息  
Consumer1消费情况如图，都按照顺序执行了

![Center 1][]  
  
  
Consumer2消费情况如图，都按照顺序执行了

![Center 2][]

### 二、事务消费 ###

这里说的主要是分布式事物。下面的例子的[数据库][Link 1]分别安装在不同的节点上。

事物消费需要先说说什么是事务。比如说：我们跨行转账，从工商银行转到建设银行，也就是我从工商银行扣除1000元之后，我的建设银行也必须加1000元。这样才能保证数据的一致性。假如工商银行转1000元之后，建设银行的服务器突然宕机，那么我扣除了1000，但是并没有在建设银行给我加1000，就出现了数据的不一致。因此加1000和减1000才行，减1000和减1000必须一起成功，一起失败。

再比如，我们进行网购的时候，我们下单之后，订单提交成功，仓库商品的数量必须减一。但是订单可能是一个数据库，仓库数量可能又是在另个数据库里面。有可能订单提交成功之后，仓库数量服务器突然宕机。这样也出现了数据不一致的问题。

使用消息队列来解决分布式事物：

现在我们去外面饭店吃饭，很多时候都不会直接给了钱之后直接在付款的窗口递饭菜，而是付款之后他会给你一张小票，你拿着这个小票去出饭的窗口取饭。这里和我们的系统类似，提高了吞吐量。即使你到第二个窗口，师傅告诉你已经没饭了，你可以拿着这个凭证去退款，即使中途由于出了意外你无法到达窗口进行取饭，但是只要凭证还在，可以将钱退给你。这样就保证了数据的一致性。

如何保证凭证（消息）有2种方法：

1、在工商银行扣款的时候，余额表扣除1000，同时记录日志，而且这2个表是在同一个数据库实例中，可以使用本地事物解决。然后我们通知建设银行需要加1000给该用户，建设银行收到之后给我返回已经加了1000给用户的确认信息之后，我再标记日志表里面的日志为已经完成。

2、通过消息中间件

原文地址：http://www.jianshu.com/p/453c6e7ff81c

![Center 3][]

RocketMQ第一阶段发送Prepared消息时，会拿到消息的地址，第二阶段执行本地事物，第三阶段通过第一阶段拿到的地址去访问消息，并修改消息的状态。

细心的你可能又发现问题了，如果确认消息发送失败了怎么办？RocketMQ会定期扫描消息集群中的事物消息，如果发现了Prepared消息，它会向消息发送端(生产者)确认，Bob的钱到底是减了还是没减呢？如果减了是回滚还是继续发送确认消息呢？RocketMQ会根据发送端设置的策略来决定是回滚还是继续发送确认消息。这样就保证了消息发送与本地事务同时成功或同时失败。

例子：

**Consumer.java**

![复制代码][copycode.gif]

package transaction;  
      
    import java.util.List;  
      
    import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;  
    import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
    import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
    import com.alibaba.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
    import com.alibaba.rocketmq.client.exception.MQClientException;  
    import com.alibaba.rocketmq.common.consumer.ConsumeFromWhere;  
    import com.alibaba.rocketmq.common.message.MessageExt;  
      
    /** 
     * Consumer，订阅消息 
     */  
    public class Consumer {  
      
        public static void main(String[] args) throws InterruptedException, MQClientException {  
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("transaction_Consumer");  
            consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");  
            consumer.setConsumeMessageBatchMaxSize(10);  
            /** 
             * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br> 
             * 如果非第一次启动，那么按照上次消费的位置继续消费 
             */  
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);  
      
            consumer.subscribe("TopicTransactionTest", "*");  
      
            consumer.registerMessageListener(new MessageListenerConcurrently() {  
      
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
      
                    try {  
      
                        for (MessageExt msg : msgs) {  
                            System.out.println(msg + ",内容：" + new String(msg.getBody()));  
                        }  
      
                    } catch (Exception e) {  
                        e.printStackTrace();  
      
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;// 重试  
      
                    }  
      
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功  
                }  
            });  
      
            consumer.start();  
      
            System.out.println("transaction_Consumer Started.");  
        }  
    }

![复制代码][copycode.gif]

**Producer.java**

![复制代码][copycode.gif]

package transaction;  
      
    import com.alibaba.rocketmq.client.exception.MQClientException;  
    import com.alibaba.rocketmq.client.producer.SendResult;  
    import com.alibaba.rocketmq.client.producer.TransactionCheckListener;  
    import com.alibaba.rocketmq.client.producer.TransactionMQProducer;  
    import com.alibaba.rocketmq.common.message.Message;  
      
    /** 
     * 发送事务消息例子 
     *  
     */  
    public class Producer {  
        public static void main(String[] args) throws MQClientException, InterruptedException {  
      
            TransactionCheckListener transactionCheckListener = new TransactionCheckListenerImpl();  
            TransactionMQProducer producer = new TransactionMQProducer("transaction_Producer");  
            producer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");  
            // 事务回查最小并发数  
            producer.setCheckThreadPoolMinSize(2);  
            // 事务回查最大并发数  
            producer.setCheckThreadPoolMaxSize(2);  
            // 队列数  
            producer.setCheckRequestHoldMax(2000);  
            producer.setTransactionCheckListener(transactionCheckListener);  
            producer.start();  
      
            // String[] tags = new String[] { "TagA", "TagB", "TagC", "TagD", "TagE"  
            // };  
            TransactionExecuterImpl tranExecuter = new TransactionExecuterImpl();  
            for (int i = 1; i <= 2; i++) {  
                try {  
                    Message msg = new Message("TopicTransactionTest", "transaction" + i, "KEY" + i,  
                            ("Hello RocketMQ " + i).getBytes());  
                    SendResult sendResult = producer.sendMessageInTransaction(msg, tranExecuter, null);  
                    System.out.println(sendResult);  
      
                    Thread.sleep(10);  
                } catch (MQClientException e) {  
                    e.printStackTrace();  
                }  
            }  
      
            for (int i = 0; i < 100000; i++) {  
                Thread.sleep(1000);  
            }  
      
            producer.shutdown();  
      
        }  
    }

![复制代码][copycode.gif]

**TransactionExecuterImpl .java --执行本地事务**

![复制代码][copycode.gif]

package transaction;  
      
    import com.alibaba.rocketmq.client.producer.LocalTransactionExecuter;  
    import com.alibaba.rocketmq.client.producer.LocalTransactionState;  
    import com.alibaba.rocketmq.common.message.Message;  
      
    /** 
     * 执行本地事务 
     */  
    public class TransactionExecuterImpl implements LocalTransactionExecuter {  
        // private AtomicInteger transactionIndex = new AtomicInteger(1);  
      
        public LocalTransactionState executeLocalTransactionBranch(final Message msg, final Object arg) {  
      
            System.out.println("执行本地事务msg = " + new String(msg.getBody()));  
      
            System.out.println("执行本地事务arg = " + arg);  
      
            String tags = msg.getTags();  
      
            if (tags.equals("transaction2")) {  
                System.out.println("======我的操作============，失败了  -进行ROLLBACK");  
                return LocalTransactionState.ROLLBACK_MESSAGE;  
            }  
            return LocalTransactionState.COMMIT_MESSAGE;  
            // return LocalTransactionState.UNKNOW;  
        }  
    }

![复制代码][copycode.gif]

TransactionCheckListenerImpl--未决事务，服务器回查客户端(目前已经被阉割啦)

![复制代码][copycode.gif]

package transaction;  
      
    import com.alibaba.rocketmq.client.producer.LocalTransactionState;  
    import com.alibaba.rocketmq.client.producer.TransactionCheckListener;  
    import com.alibaba.rocketmq.common.message.MessageExt;  
      
    /** 
     * 未决事务，服务器回查客户端 
     */  
    public class TransactionCheckListenerImpl implements TransactionCheckListener {  
        // private AtomicInteger transactionIndex = new AtomicInteger(0);  
      
        //在这里，我们可以根据由MQ回传的key去数据库查询，这条数据到底是成功了还是失败了。  
        public LocalTransactionState checkLocalTransactionState(MessageExt msg) {  
            System.out.println("未决事务，服务器回查客户端msg =" + new String(msg.getBody().toString()));  
            // return LocalTransactionState.ROLLBACK_MESSAGE;  
      
            return LocalTransactionState.COMMIT_MESSAGE;  
      
            // return LocalTransactionState.UNKNOW;  
        }  
    }

![复制代码][copycode.gif]

producer端：发送数据到MQ，并且处理本地事物。这里模拟了一个成功一个失败。Consumer只会接收到本地事物成功的数据。第二个数据失败了，不会被消费。

![Center 4][]

Consumer只会接收到一个，第二个数据不会被接收到

![Center 5][]

**分布式消息队列RocketMQ&Kafka -- 消息的“顺序消费”**

在说到消息中间件的时候，我们通常都会谈到一个特性：消息的顺序消费问题。这个问题看起来很简单：Producer发送消息1, 2, 3。。。 Consumer按1, 2, 3。。。顺序消费。

但实际情况却是：无论RocketMQ，还是Kafka，缺省都不保证消息的严格有序消费！

这个特性看起来很简单，但为什么缺省他们都不保证呢？

# “严格的顺序消费”有多么困难 #

下面就从3个方面来分析一下，对于一个消息中间件来说，”严格的顺序消费”有多么困难，或者说不可能。

## 发送端 ##

发送端不能异步发送，异步发送在发送失败的情况下，就没办法保证消息顺序。

比如你连续发了1，2，3。 过了一会，返回结果1失败，2, 3成功。你把1再重新发送1遍，这个时候顺序就乱掉了。

## 存储端 ##

对于存储端，要保证消息顺序，会有以下几个问题：   
（1）消息不能分区。也就是1个topic，只能有1个队列。在Kafka中，它叫做partition；在RocketMQ中，它叫做queue。 如果你有多个队列，那同1个topic的消息，会分散到多个分区里面，自然不能保证顺序。

（2）即使只有1个队列的情况下，会有第2个问题。该机器挂了之后，能否切换到其他机器？也就是高可用问题。

比如你当前的机器挂了，上面还有消息没有消费完。此时切换到其他机器，可用性保证了。但消息顺序就乱掉了。

要想保证，一方面要同步复制，不能异步复制；另1方面得保证，切机器之前，挂掉的机器上面，所有消息必须消费完了，不能有残留。很明显，这个很难！！！

## 接收端 ##

对于接收端，不能并行消费，也即不能开多线程或者多个客户端消费同1个队列。

## 总结 ##

从上面的分析可以看出，要保证消息的严格有序，有多么困难！

发送端和接收端的问题，还好解决一点，限制异步发送，限制并行消费。但对于存储端，机器挂了之后，切换的问题，就很难解决了。

你切换了，可能消息就会乱；你不切换，那就暂时不可用。这2者之间，就需要权衡了。

# 业务需要全局有序吗？ #

通过上面分析可以看出，要保证一个topic内部，消息严格的有序，是很困难的，或者说条件是很苛刻的。

那怎么办呢？我们一定要使出所有力气、用尽所有办法，来保证消息的严格有序吗？

这里就需要从另外一个角度去考虑这个问题：业务角度。正如在下面这篇博客中所说的：   
[http://www.jianshu.com/p/453c6e7ff81c][http_www.jianshu.com_p_453c6e7ff81c]

实际情况中：   
（1）不关注顺序的业务大量存在；   
（2） 队列无序不代表消息无序。

第（2）条的意思是说：我们不保证队列的全局有序，但可以保证消息的局部有序。

举个例子：保证来自同1个order id的消息，是有序的！

下面就看一下在Kafka和RocketMQ中，分别是如何对待这个问题的：

Kafka中：发送1条消息的时候，可以指定(topic, partition, key) 3个参数。partiton和key是可选的。

如果你指定了partition，那就是所有消息发往同1个partition，就是有序的。并且在消费端，Kafka保证，1个partition只能被1个consumer消费。

或者你指定key（比如order id），具有同1个key的所有消息，会发往同1个partition。也是有序的。

RocketMQ： RocketMQ在Kafka的基础上，把这个限制更放宽了一步。只指定(topic, key)，不指定具体发往哪个队列。也就是说，它更加不希望业务方，非要去要一个全局的严格有序。

**消费模式**

# 一、集群消费 #

之前的博客中，启动的都是单个Consumer，如果启动多个呢？

![RocketMQ-集群消费][RocketMQ-]   
*RocketMQ-集群消费*

其实，对于RocketMQ而言，通过ConsumeGroup的机制，实现了天然的消息负载均衡！通俗点来说，RocketMQ中的消息通过ConsumeGroup实现了将消息分发到C1/C2/C3/……的机制，这意味着我们将非常方便的通过加机器来实现水平扩展！

我们考虑一下这种情况：比如C2发生了重启，一条消息发往C3进行消费，但是这条消息的处理需要0.1S，而此时C2刚好完成重启，那么C2是否可能会收到这条消息呢？答案是肯定的，也就是consume broker的重启，或者水平扩容，或者不遵守先订阅后生产消息，都可能导致消息的重复消费！关于去重的话题会在后续中予以介绍！

至于消息分发到C1/C2/C3，其实也是可以设置策略的：

![RocketMQ-消息负载策略][RocketMQ- 1]   
*RocketMQ-消息负载策略*

使用哪种策略，只需要实例化对应的对象即可，如：

AllocateMessageQueueStrategy aqs = new AllocateMessageQueueAveragelyByCircle();
    consumer.setAllocateMessageQueueStrategy(aqs);

上面内容，其实是一种消费模式——集群消费。   
RocketMQ的消费模式有2种，查看一下源码：

public enum MessageModel {
        /**
         * broadcast
         */
        BROADCASTING,
        /**
         * clustering
         */
        CLUSTERING;
    }

在默认情况下，就是集群消费（CLUSTERING），也就是上面提及的消息的负载均衡消费。另一种消费模式，是广播消费（BROADCASTING）。

--------------------

# 二、广播消费 #

广播消费，类似于ActiveMQ中的发布订阅模式，消息会发给Consume Group中的每一个消费者进行消费。

![RocketMQ-广播消费模式设置][RocketMQ- 2]   
*RocketMQ-广播消费模式设置*

/**
     * Consumer，订阅消息
     */
    public class Consumer2 {
        public static void main(String[] args) throws InterruptedException, MQClientException {
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group_name");
            consumer.setNamesrvAddr("192.168.2.222:9876;192.168.2.223:9876");
            consumer.setConsumeMessageBatchMaxSize(10);
    
            // 设置为广播消费模式
            consumer.setMessageModel(MessageModel.BROADCASTING);
    
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
            consumer.subscribe("TopicTest", "*");
    
            consumer.registerMessageListener(new MessageListenerConcurrently() {
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                    try {
                        for (MessageExt msg : msgs) {
                            System.out.println(" Receive New Messages: " + msg);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;   // 重试
                    }
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;       // 成功
                }
            });
    
            consumer.start();
            System.out.println("Consumer Started.");
        }
    }

--------------------

# 内容补充 #

[《RocketMQ（三）——HelloWorld》][RocketMQ_HelloWorld]那篇博客的最后提到了单批次消息消费数量 ，本文既然提到了集群消费，那就针对这两个内容再进行一次补充吧。   
如果我们有2台节点，Producerw往MQ上写入20条数据 其中Consumer1中拉取了12条 。Consumer2中拉取了8 条，这种情况下，假如Consumer1宕机，那么我们消费数据的时候，只能消费到Consumer2中的8条，Consumer1中的12条已经持久化了。需要Consumer1恢复之后这12条数据才能继续被消费。其实这种先启动producer往MQ上写数据，然后再启动Consumer的情况本来就是违规操作，正确的情况应该是先启动Consumer后再启动producer。

**集群消费和广播消费**

### 基本概念 ###

MQ 是基于发布订阅模型的消息系统。在 MQ 消息系统中消息的订阅方订阅关注的 Topic，以获取并消费消息。由于订阅方应用一般是分布式系统，以集群方式部署有多台机器。因此 MQ 约定以下概念。

集群：MQ 约定使用相同 Consumer ID 的订阅者属于同一个集群，同一个集群下的订阅者消费逻辑必须完全一致（包括 Tag 的使用），这些订阅者在逻辑上可以认为是一个消费节点。

集群消费：当使用集群消费模式时，MQ 认为任意一条消息只需要被集群内的任意一个消费者处理即可。

广播消费：当使用广播消费模式时，MQ 会将每条消息推送给集群内所有注册过的客户端，保证消息至少被每台机器消费一次。

### 场景对比 ###

集群消费模式：

![cl][]

适用场景&注意事项

*  消费端集群化部署，每条消息只需要被处理一次。
 *  由于消费进度在服务端维护，可靠性更高。
 *  集群消费模式下，每一条消息都只会被分发到一台机器上处理，如果需要被集群下的每一台机器都处理，请使用广播模式。
 *  集群消费模式下，不保证消息的每一次失败重投等逻辑都能路由到同一台机器上，因此处理消息时不应该做任何确定性假设。

广播消费模式：

![bd][]

适用场景&注意事项

*  每条消息都需要被相同逻辑的多台机器处理。
 *  消费进度在客户端维护，出现重复的概率稍大于集群模式。
 *  广播模式下，MQ 保证每条消息至少被每台客户端消费一次，但是并不会对消费失败的消息进行失败重投，因此业务方需要关注消费失败的情况。
 *  广播模式下，第一次启动时默认从最新消息消费，客户端的消费进度是被持久化在客户端本地的隐藏文件中，因此不建议删除该隐藏文件，否则会丢失部分消息。
 *  广播模式下，每条消息都会被大量的客户端重复处理，因此推荐尽可能使用集群模式。
 *  目前仅 Java 客户端支持广播模式。
 *  广播模式下服务端不维护消费进度，所以服务端不提供堆积查询和报警功能。

使用集群模式模拟广播：

![cd-bd][]

适用场景&注意事项

*  每条消息都需要被多台机器处理，每台机器的逻辑可以相同也可以不一样。
 *  消费进度在服务端维护，可靠性高于广播模式。

# **更多**RocketMQ**资源请访问[www.itkc8.com][]** #

[https://www.cnblogs.com/xuwc/p/9034352.html][https_www.cnblogs.com_xuwc_p_9034352.html]

[www.itkc8.com]: http://www.itkc8.com
[https_www.cnblogs.com_xuwc_p_9034352.html]: https://www.cnblogs.com/xuwc/p/9034352.html
[2]: /images/20220206/38983310d9f14248a312d5d329e60aa5.png
[2 1]: /images/20220206/f8835d2a7c06488a8d6966a1d4da13e4.png
[2 2]: /images/20220206/656537cea6604dd290498a581f7c450e.png
[2 3]: /images/20220206/b4beb3bdd5374f28bf9c3b94c2912287.png
[copycode.gif]: /images/20220206/fb65701a0fcb4d129f332aabbb7876df.png
[2 4]: /images/20220206/3c82fe0fdd99488ab8ef71b88ccb6ee2.png
[2 5]: /images/20220206/d832e73a4f8f40d09a9450c3ec7faa4a.png
[2 6]: /images/20220206/a07f5803eb714305a77f4260bc5dd099.png
[2 7]: /images/20220206/a653a6228f9d4044a91d05c0a9699b2d.png
[2 8]: /images/20220206/317772c1613f4d5988c1484f1d3ecac1.png
[2 9]: /images/20220206/4de0d26323344e1b97e7a1fb251c80f9.png
[2 10]: /images/20220206/ae1615c254ec4b05bc396cdb14ec625b.png
[https_github.com_alibaba_RocketMQ_issues_65]: https://github.com/alibaba/RocketMQ/issues/65
[https_github.com_alibaba_RocketMQ_issues_138]: https://github.com/alibaba/RocketMQ/issues/138
[https_github.com_alibaba_RocketMQ_issues_156]: https://github.com/alibaba/RocketMQ/issues/156
[2 11]: /images/20220206/c0f09a4a4b704fcc9571fe51a7072cf2.png
[2 12]: /images/20220206/8ff3c5fbe46d4f0084efe8d6d65d0001.png
[2 13]: /images/20220206/f743b5404d8c48fdb59b2d509d213d0d.png
[2 14]: /images/20220206/e8da1d102f9845729c50729d4e07fa21.png
[2 15]: /images/20220206/ee2711ba14d34119ad07d49601e6bcf6.png
[2 16]: /images/20220206/432188f17d50468daf4439b361c2bd51.png
[2 17]: /images/20220206/a7fd2fe7e36e4b0cb113714051ca6eaf.png
[2 18]: /images/20220206/a126d3df27cf4cf0b7364d2e916b4660.png
[2 19]: /images/20220206/2f0884e94d8746f081c0355232e02f27.png
[Center]: /images/20220206/4db1eac176824be980f1ba9b1240d55d.png
[Center 1]: /images/20220206/458354d8a7fc42918db8431e746b0636.png
[Center 2]: /images/20220206/ba0cffd99baf4abda073cf6af793e56d.png
[Link 1]: http://lib.csdn.net/base/mysql
[Center 3]: /images/20220206/3a4bf49fb6a64f309074c3dd51eef531.png
[Center 4]: /images/20220206/38b303116e3149f3a9c1b1fac712cefd.png
[Center 5]: /images/20220206/506e5547a3dd4af389e49dc3eeac76fc.png
[http_www.jianshu.com_p_453c6e7ff81c]: http://www.jianshu.com/p/453c6e7ff81c
[RocketMQ-]: /images/20220206/ac90b1ab701748fc98dba2b10c7dd94f.png
[RocketMQ- 1]: /images/20220206/b8781fe0bb264e90ba8c85adad155427.png
[RocketMQ- 2]: /images/20220206/1e1eec99ca9f4bf6a66f238a91d8ddf3.png
[RocketMQ_HelloWorld]: http://blog.csdn.net/zhanglianhai555/article/details/77005663
[cl]: /images/20220206/e11f7e37d7c0402c8385716bfbb4a253.png
[bd]: /images/20220206/4c25e39fc09a44a4a6183911c1ddb4a6.png
[cd-bd]: /images/20220206/19517c6f28804ad294cd706c213a652b.png