【笔记】RocketMQ

• 关于消息队列的使用
• github rocketmq-externals

RocketMQ

消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ

1.架构

他主要有四大核心组成部分：NameServer、Broker、Producer以及Consumer四部分。

Tip：我们可以看到RocketMQ啥都是集群部署的，这是他吞吐量大，高可用的原因之一，集群的模式也很花哨，可以支持多master 模式、多master多slave异步复制模式、多 master多slave同步双写模式。

1.NameServer

主要负责对于源数据的管理，包括了对于Topic和路由信息的管理。

NameServer是一个功能齐全的服务器，其角色类似Dubbo中的Zookeeper，但NameServer与Zookeeper相比更轻量。主要是因为每个NameServer节点互相之间是独立的，没有任何信息交互。

NameServer压力不会太大，平时主要开销是在维持心跳和提供Topic-Broker的关系数据。

但有一点需要注意，Broker向NameServer发心跳时， 会带上当前自己所负责的所有Topic信息，如果Topic个数太多（万级别），会导致一次心跳中，就Topic的数据就几十M，网络情况差的话， 网络传输失败，心跳失败，导致NameServer误认为Broker心跳失败。

NameServer 被设计成几乎无状态的，可以横向扩展，节点之间相互之间无通信，通过部署多台机器来标记自己是一个伪集群。

每个 Broker 在启动的时候会到 NameServer 注册，Producer 在发送消息前会根据 Topic 到 NameServer 获取到 Broker 的路由信息，Consumer 也会定时获取 Topic 的路由信息。

所以从功能上看NameServer应该是和 ZooKeeper 差不多，据说 RocketMQ 的早期版本确实是使用的 ZooKeeper ，后来改为了自己实现的 NameServer 。

我们看一下Dubbo中注册中心的角色，是不是真的一毛一样，师出同门相似点真的很多

2.Producer

消息生产者，负责产生消息，一般由业务系统负责产生消息。

• Producer由用户进行分布式部署，消息由Producer通过多种负载均衡模式发送到Broker集群，发送低延时，支持快速失败。

• RocketMQ 提供了三种方式发送消息：同步、异步和单向

• 同步发送：同步发送指消息发送方发出数据后会在收到接收方发回响应之后才发下一个数据包。一般用于重要通知消息，例如重要通知邮件、营销短信。

• 异步发送：异步发送指发送方发出数据后，不等接收方发回响应，接着发送下个数据包，一般用于可能链路耗时较长而对响应时间敏感的业务场景，例如用户视频上传后通知启动转码服务。

• 单向发送：单向发送是指只负责发送消息而不等待服务器回应且没有回调函数触发，适用于某些耗时非常短但对可靠性要求并不高的场景，例如日志收集。

3.Broker

消息中转角色，负责存储消息，转发消息。

• Broker是具体提供业务的服务器，单个Broker节点与所有的NameServer节点保持长连接及心跳，并会定时将Topic信息注册到NameServer，顺带一提底层的通信和连接都是基于Netty实现的。
• Broker负责消息存储，以Topic为纬度支持轻量级的队列，单机可以支撑上万队列规模，支持消息推拉模型。
  官网上有数据显示：具有上亿级消息堆积能力，同时可严格保证消息的有序性。

4.Consumer

消息消费者，负责消费消息，一般是后台系统负责异步消费。

• Consumer也由用户部署，支持PUSH和PULL两种消费模式，支持集群消费和广播消息，提供实时的消息订阅机制。

• Pull：拉取型消费者（Pull Consumer）主动从消息服务器拉取信息，只要批量拉取到消息，用户应用就会启动消费过程，所以 Pull 称为主动消费型。

• Push：推送型消费者（Push Consumer）封装了消息的拉取、消费进度和其他的内部维护工作，将消息到达时执行的回调接口留给用户应用程序来实现。所以 Push 称为被动消费类型，但从实现上看还是从消息服务器中拉取消息，不同于 Pull 的是 Push 首先要注册消费监听器，当监听器处触发后才开始消费消息。

2.消息领域模型

Message

Message（消息）就是要传输的信息。

一条消息必须有一个主题（Topic），主题可以看做是你的信件要邮寄的地址。

一条消息也可以拥有一个可选的标签（Tag）和额处的键值对，它们可以用于设置一个业务 Key 并在 Broker 上查找此消息以便在开发期间查找问题。

Topic

Topic（主题）可以看做消息的规类，它是消息的第一级类型。比如一个电商系统可以分为：交易消息、物流消息等，一条消息必须有一个 Topic 。

Topic 与生产者和消费者的关系非常松散，一个 Topic 可以有0个、1个、多个生产者向其发送消息，一个生产者也可以同时向不同的 Topic 发送消息。

一个 Topic 也可以被 0个、1个、多个消费者订阅。

Tag

Tag（标签）可以看作子主题，它是消息的第二级类型，用于为用户提供额外的灵活性。使用标签，同一业务模块不同目的的消息就可以用相同 Topic 而不同的 Tag 来标识。比如交易消息又可以分为：交易创建消息、交易完成消息等，一条消息可以没有 Tag 。

标签有助于保持您的代码干净和连贯，并且还可以为 RocketMQ 提供的查询系统提供帮助。

Group

分组，一个组可以订阅多个Topic。

分为ProducerGroup，ConsumerGroup，代表某一类的生产者和消费者，一般来说同一个服务可以作为Group，同一个Group一般来说发送和消费的消息都是一样的

Queue

在Kafka中叫Partition，每个Queue内部是有序的，在RocketMQ中分为读和写两种队列，一般来说读写队列数量一致，如果不一致就会出现很多问题。

Message Queue

Message Queue（消息队列），主题被划分为一个或多个子主题，即消息队列。

一个 Topic 下可以设置多个消息队列，发送消息时执行该消息的 Topic ，RocketMQ 会轮询该 Topic 下的所有队列将消息发出去。

消息的物理管理单位。一个Topic下可以有多个Queue，Queue的引入使得消息的存储可以分布式集群化，具有了水平扩展能力。

Offset

在RocketMQ 中，所有消息队列都是持久化，长度无限的数据结构，所谓长度无限是指队列中的每个存储单元都是定长，访问其中的存储单元使用Offset 来访问，Offset 为 java long 类型，64 位，理论上在 100年内不会溢出，所以认为是长度无限。

也可以认为 Message Queue 是一个长度无限的数组，Offset 就是下标。

消息消费模式

消息消费模式有两种：Clustering（集群消费）和Broadcasting（广播消费）。

默认情况下就是集群消费，该模式下一个消费者集群共同消费一个主题的多个队列，一个队列只会被一个消费者消费，如果某个消费者挂掉，分组内其它消费者会接替挂掉的消费者继续消费。

而广播消费消息会发给消费者组中的每一个消费者进行消费。

Message Order

Message Order（消息顺序）有两种：Orderly（顺序消费）和Concurrently（并行消费）。

顺序消费表示消息消费的顺序同生产者为每个消息队列发送的顺序一致，所以如果正在处理全局顺序是强制性的场景，需要确保使用的主题只有一个消息队列。

并行消费不再保证消息顺序，消费的最大并行数量受每个消费者客户端指定的线程池限制。

3.一次完整的通信流程是怎样的？

Producer 与 NameServer集群中的其中一个节点（随机选择）建立长连接，定期从 NameServer 获取 Topic 路由信息，并向提供 Topic 服务的 Broker Master 建立长连接，且定时向 Broker 发送心跳。

Producer 只能将消息发送到 Broker master，但是 Consumer 则不一样，它同时和提供 Topic 服务的 Master 和 Slave建立长连接，既可以从 Broker Master 订阅消息，也可以从 Broker Slave 订阅消息。
NameService启动流程

在org.apache.rocketmq.namesrv目录下的NamesrvStartup这个启动类基本上描述了他的启动过程我们可以看一下代码：

第一步是初始化配置

创建NamesrvController实例，并开启两个定时任务：

每隔10s扫描一次Broker，移除处于不激活的Broker；

每隔10s打印一次KV配置。

第三步注册钩子函数，启动服务器并监听Broker。

NameService还有很多东西的哈我这里就介绍他的启动流程，大家还可以去看看代码，还是很有意思的，比如路由注册会发送心跳包，还有心跳包的处理流程，路由删除，路由发现等等。
Producer

链路很长涉及的细节也多，我就发一下链路图。

Producer是消息发送方，那他怎么发送的呢？

通过轮询，Producer轮询某个Topic下面的所有队列实现发送方的负载均衡
Broker

Broker在RocketMQ中是进行处理Producer发送消息请求，Consumer消费消息的请求，并且进行消息的持久化，以及HA策略和服务端过滤，就是集群中很重的工作都是交给了Broker进行处理。

Broker模块是通过BrokerStartup进行启动的，会实例化BrokerController，并且调用其初始化方法

大家去看Broker的源码的话会发现，他的初始化流程很冗长，会根据配置创建很多线程池主要用来发送消息、拉取消息、查询消息、客户端管理和消费者管理，也有很多定时任务，同时也注册了很多请求处理器，用来发送拉取消息查询消息的。
Consumer

Consumer是消息接受，那他怎么接收消息的呢？

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

4.基本使用

1、简单消息示例

• 可靠的同步传输

  应用：可靠的同步传输广泛应用于重要通知消息，短信通知，短信营销系统等…

  public class SyncProducer {
      public static void main(String[] args) throws Exception {
          //Instantiate with a producer group name.
          DefaultMQProducer producer = new
              DefaultMQProducer("please_rename_unique_group_name");
          //Launch the instance.
          producer.start();
          for (int i = 0; i < 100; i++) {
              //Create a message instance, specifying topic, tag and message body.
              Message msg = new Message("TopicTest" /* Topic */,
                  "TagA" /* Tag */,
                  ("Hello RocketMQ " +
                      i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
              );
              //Call send message to deliver message to one of brokers.
              SendResult sendResult = producer.send(msg);
              System.out.printf("%s%n", sendResult);
          }
          //Shut down once the producer instance is not longer in use.
          producer.shutdown();
      }
  }
  

• 可靠的异步传输

  应用：异步传输通常用于响应时间敏感的业务场景。

  public class AsyncProducer {
      public static void main(String[] args) throws Exception {
          //Instantiate with a producer group name.
          DefaultMQProducer producer = new DefaultMQProducer("ExampleProducerGroup");
          //Launch the instance.
          producer.start();
          producer.setRetryTimesWhenSendAsyncFailed(0);
          for (int i = 0; i < 100; i++) {
                  final int index = i;
                  //Create a message instance, specifying topic, tag and message body.
                  Message msg = new Message("TopicTest",
                      "TagA",
                      "OrderID188",
                      "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
                  producer.send(msg, new SendCallback() {
                      @Override
                      public void onSuccess(SendResult sendResult) {
                          System.out.printf("%-10d OK %s %n", index,
                              sendResult.getMsgId());
                      }
                      @Override
                      public void onException(Throwable e) {
                          System.out.printf("%-10d Exception %s %n", index, e);
                          e.printStackTrace();
                      }
                  });
          }
          //Shut down once the producer instance is not longer in use.
          producer.shutdown();
      }
  }
  

• 单向传输

  应用：单向传输用于需要中等可靠性的情况，例如日志收集.

  public class OnewayProducer {
      public static void main(String[] args) throws Exception{
          //Instantiate with a producer group name.
          DefaultMQProducer producer = new DefaultMQProducer("ExampleProducerGroup");
          //Launch the instance.
          producer.start();
          for (int i = 0; i < 100; i++) {
              //Create a message instance, specifying topic, tag and message body.
              Message msg = new Message("TopicTest" /* Topic */,
                  "TagA" /* Tag */,
                  ("Hello RocketMQ " +
                      i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
              );
              //Call send message to deliver message to one of brokers.
              producer.sendOneway(msg);
  
          }
          //Shut down once the producer instance is not longer in use.
          producer.shutdown();
      }
  }
  

2、有序的消息示例

• 发送消息示例代码

  public class OrderedProducer {
      public static void main(String[] args) throws Exception {
          //Instantiate with a producer group name.
          MQProducer producer = new DefaultMQProducer("example_group_name");
          //Launch the instance.
          producer.start();
          String[] tags = new String[] {"TagA", "TagB", "TagC", "TagD", "TagE"};
          for (int i = 0; i < 100; i++) {
              int orderId = i % 10;
              //Create a message instance, specifying topic, tag and message body.
              Message msg = new Message("TopicTestjjj", tags[i % tags.length], "KEY" + i,
                      ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
              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);
  
              System.out.printf("%s%n", sendResult);
          }
          //server shutdown
          producer.shutdown();
      }
  }
  

• 订阅消息简单示例代码

  public class OrderedConsumer {
      public static void main(String[] args) throws Exception {
          DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("example_group_name");
  
          consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
  
          consumer.subscribe("TopicTest", "TagA || TagC || TagD");
  
  		// 注册监听器，也可以用@EventListener实现
          consumer.registerMessageListener(new MessageListenerOrderly() {
  
              AtomicLong consumeTimes = new AtomicLong(0);
              @Override
              public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs,
                                                         ConsumeOrderlyContext context) {
                  context.setAutoCommit(false);
                  System.out.printf(Thread.currentThread().getName() + " Receive New Messages: " + msgs + "%n");
                  this.consumeTimes.incrementAndGet();
                  if ((this.consumeTimes.get() % 2) == 0) {
                      return ConsumeOrderlyStatus.SUCCESS;
                  } else if ((this.consumeTimes.get() % 3) == 0) {
                      return ConsumeOrderlyStatus.ROLLBACK;
                  } else if ((this.consumeTimes.get() % 4) == 0) {
                      return ConsumeOrderlyStatus.COMMIT;
                  } else if ((this.consumeTimes.get() % 5) == 0) {
                      context.setSuspendCurrentQueueTimeMillis(3000);
                      return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                  }
                  return ConsumeOrderlyStatus.SUCCESS;
  
              }
          });
  
          consumer.start();
  
          System.out.printf("Consumer Started.%n");
      }
  }
  

3、广播消息示例

• 什么是广播

  广播是向所有用户发送消息。 如果您希望所有订阅者都能收到有关某个主题的消息，则广播是一个不错的选择。

• 生产者示例

  public class BroadcastProducer {
      public static void main(String[] args) throws Exception {
          DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
          producer.start();
  
          for (int i = 0; i < 100; i++){
              Message msg = new Message("TopicTest",
                  "TagA",
                  "OrderID188",
                  "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
              SendResult sendResult = producer.send(msg);
              System.out.printf("%s%n", sendResult);
          }
          producer.shutdown();
      }
  }
  

• 消费者示例

  public class BroadcastConsumer {
      public static void main(String[] args) throws Exception {
          DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("example_group_name");
  
          consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
  
          //set to broadcast mode
          consumer.setMessageModel(MessageModel.BROADCASTING);
  
          consumer.subscribe("TopicTest", "TagA || TagC || TagD");
  
          consumer.registerMessageListener(new MessageListenerConcurrently() {
  
              @Override
              public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                  ConsumeConcurrentlyContext context) {
                  System.out.printf(Thread.currentThread().getName() + " Receive New Messages: " + msgs + "%n");
                  return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
              }
          });
  
          consumer.start();
          System.out.printf("Broadcast Consumer Started.%n");
      }
  }
  

4、定时消息示例

• 什么是定时消息?

  定时消息与正常消息的不同之处在于，它是在指定的时间后执行。

  • 启动消费者等待传入的订阅消息

     import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
     import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
     import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
     import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
     import org.apache.rocketmq.common.message.MessageExt;
     import java.util.List;
        
     public class ScheduledMessageConsumer {
        
         public static void main(String[] args) throws Exception {
             // Instantiate message consumer
             DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ExampleConsumer");
             // Subscribe topics
             consumer.subscribe("TestTopic", "*");
             // Register message listener
             consumer.registerMessageListener(new MessageListenerConcurrently() {
                 @Override
                 public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> messages, ConsumeConcurrentlyContext context) {
                     for (MessageExt message : messages) {
                         // Print approximate delay time period
                         System.out.println("Receive message[msgId=" + message.getMsgId() + "] "
                                 + (System.currentTimeMillis() - message.getStoreTimestamp()) + "ms later");
                     }
                     return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                 }
             });
             // Launch consumer
             consumer.start();
         }
     }
    

  • 发送定时消息

     import org.apache.rocketmq.client.producer.DefaultMQProducer;
     import org.apache.rocketmq.common.message.Message;
        
     public class ScheduledMessageProducer {
        
         public static void main(String[] args) throws Exception {
             // Instantiate a producer to send scheduled messages
             DefaultMQProducer producer = new DefaultMQProducer("ExampleProducerGroup");
             // Launch producer
             producer.start();
             int totalMessagesToSend = 100;
             for (int i = 0; i < totalMessagesToSend; i++) {
                 Message message = new Message("TestTopic", ("Hello scheduled message " + i).getBytes());
                 // This message will be delivered to consumer 10 seconds later.
                 message.setDelayTimeLevel(3);
                 // Send the message
                 producer.send(message);
             }
        
             // Shutdown producer after use.
             producer.shutdown();
         }
            
     }
    

  • 核实

    您应该看到消息比其存储时间晚约10秒钟。

5、批量消息示例

• 为什么选择批量消息?

  批量发送消息可提高单次发送消息的性能.

• 使用限制

  相同批次的消息应具有：相同的主题，相同的等待消息处理成功但是不支持定时处理. 此外，一个批量的消息的总大小不要错过1MB.

• 怎么使用批量消息

  如果您一次只发送不超过1MB的消息，使用批量发送很方便:

  String topic = "BatchTest";
  List<Message> messages = new ArrayList<>();
  messages.add(new Message(topic, "TagA", "OrderID001", "Hello world 0".getBytes()));
  messages.add(new Message(topic, "TagA", "OrderID002", "Hello world 1".getBytes()));
  messages.add(new Message(topic, "TagA", "OrderID003", "Hello world 2".getBytes()));
  try {
      producer.send(messages);
  } catch (Exception e) {
      e.printStackTrace();
      //handle the error
  }
  

• 分割成列表

  只有在发送大批量时才会增加复杂性，并且您可能不确定是否超出了大小限制（1MiB）。

  目前，你最好分开列表:

  public class ListSplitter implements Iterator<List<Message>> {
      private final int SIZE_LIMIT = 1000 * 1000;
      private final List<Message> messages;
      private int currIndex;
      public ListSplitter(List<Message> messages) {
              this.messages = messages;
      }
      @Override public boolean hasNext() {
          return currIndex < messages.size();
      }
      @Override public List<Message> next() {
          int nextIndex = currIndex;
          int totalSize = 0;
          for (; nextIndex < messages.size(); nextIndex++) {
              Message message = messages.get(nextIndex);
              int tmpSize = message.getTopic().length() + message.getBody().length;
              Map<String, String> properties = message.getProperties();
              for (Map.Entry<String, String> entry : properties.entrySet()) {
                  tmpSize += entry.getKey().length() + entry.getValue().length();
              }
              tmpSize = tmpSize + 20; //for log overhead
              if (tmpSize > SIZE_LIMIT) {
                  //it is unexpected that single message exceeds the SIZE_LIMIT
                  //here just let it go, otherwise it will block the splitting process
                  if (nextIndex - currIndex == 0) {
                     //if the next sublist has no element, add this one and then break, otherwise just break
                     nextIndex++;  
                  }
                  break;
              }
              if (tmpSize + totalSize > SIZE_LIMIT) {
                  break;
              } else {
                  totalSize += tmpSize;
              }
      
          }
          List<Message> subList = messages.subList(currIndex, nextIndex);
          currIndex = nextIndex;
          return subList;
      }
  }
  //then you could split the large list into small ones:
  ListSplitter splitter = new ListSplitter(messages);
  while (splitter.hasNext()) {
     try {
         List<Message>  listItem = splitter.next();
         producer.send(listItem);
     } catch (Exception e) {
         e.printStackTrace();
         //handle the error
     }
  }
  

6、过滤消息示例

在大多数情况下，tag是一种简单而有用的设计，用于选择所需的信息。 例如:

DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_EXAMPLE");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");

消费者将收到包含TAGA或TAGB或TAGB的消息. 但限制是一条消息只能有一个标签，而这对于复杂的情况可能无效。 在这种情况下，您可以使用SQL表达式筛选出消息.

原理：

SQL功能可以通过您在发送消息时放入的属性进行一些计算。 在RocketMQ定义的语法下，您可以实现一些有趣的逻辑。 这是一个例子:

------------
| message  |
|----------|  a > 5 AND b = 'abc'
| a = 10   |  --------------------> Gotten
| b = 'abc'|
| c = true |
------------
------------
| message  |
|----------|   a > 5 AND b = 'abc'
| a = 1    |  --------------------> Missed
| b = 'abc'|
| c = true |
------------

语法

RocketMQ只定义了一些基本的语法来支持这个功能。 你也可以很容易地扩展它.

1. 数字比较, 像 >, >=, <, <=, BETWEEN, =;
2. 字符比较, 像 =, <>, IN;
3. IS NULL 或者 IS NOT NULL;
4. 逻辑运算AND, OR, NOT;

常量类型是:

1. 数字, 像123, 3.1415;

2. 字符串, 像‘abc’,必须使用单引号;

3. NULL, 特殊常数;

4. 布尔常量, TRUE 或FALSE;

使用限制

只有消费者可以通过SQL92选择消息。 示例:

public void subscribe(final String topic, final MessageSelector messageSelector)

生产者示例

发送时，您可以通过putUserProperty方法在消息中放置属性.

DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
producer.start();

Message msg = new Message("TopicTest",
    tag,
    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)
);
// Set some properties.
msg.putUserProperty("a", String.valueOf(i));

SendResult sendResult = producer.send(msg);
   
producer.shutdown()

消费者示例

消费时，使用Message Selector.by Sql通过SQL92选择消息.

DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_4");

// only subsribe messages have property a, also a >=0 and a <= 3
consumer.subscribe("TopicTest", MessageSelector.bySql("a between 0 and 3");

consumer.registerMessageListener(new MessageListenerConcurrently() {
    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }
});
consumer.start();

7、日志追加消息示例

OpenMessaging，其中包括建立行业准则和消息传递，流式规范，为金融，电子商务，物联网和大数据领域提供通用框架。 设计原则是分布式异构环境中面向云，简单，灵活和独立于语言的设计原则。 符合这些规范将使在所有主要平台和操作系统上开发异构消息传递应用成为可能。

RocketMQ提供了OpenMessaging 0.1.0-alpha的部分实现，以下示例演示了如何基于OpenMessaging访问RocketMQ。

OMSProducer

以下示例显示如何以同步，异步或单向传输的方式向RocketMQ代理发送消息.

public class OMSProducer {
    public static void main(String[] args) {
        final MessagingAccessPoint messagingAccessPoint = MessagingAccessPointFactory
            .getMessagingAccessPoint("openmessaging:rocketmq://IP1:9876,IP2:9876/namespace");

        final Producer producer = messagingAccessPoint.createProducer();

        messagingAccessPoint.startup();
        System.out.printf("MessagingAccessPoint startup OK%n");

        producer.startup();
        System.out.printf("Producer startup OK%n");

        {
            Message message = producer.createBytesMessageToTopic("OMS_HELLO_TOPIC", "OMS_HELLO_BODY".getBytes(Charset.forName("UTF-8")));
            SendResult sendResult = producer.send(message);
            System.out.printf("Send sync message OK, msgId: %s%n", sendResult.messageId());
        }

        {
            final Promise<SendResult> result = producer.sendAsync(producer.createBytesMessageToTopic("OMS_HELLO_TOPIC", "OMS_HELLO_BODY".getBytes(Charset.forName("UTF-8"))));
            result.addListener(new PromiseListener<SendResult>() {
                @Override
                public void operationCompleted(Promise<SendResult> promise) {
                    System.out.printf("Send async message OK, msgId: %s%n", promise.get().messageId());
                }

                @Override
                public void operationFailed(Promise<SendResult> promise) {
                    System.out.printf("Send async message Failed, error: %s%n", promise.getThrowable().getMessage());
                }
            });
        }

        {
            producer.sendOneway(producer.createBytesMessageToTopic("OMS_HELLO_TOPIC", "OMS_HELLO_BODY".getBytes(Charset.forName("UTF-8"))));
            System.out.printf("Send oneway message OK%n");
        }

        producer.shutdown();
        messagingAccessPoint.shutdown();
    }
}

OMSPullConsumer

使用OMS PullConsumer轮询来自指定队列的消息.

public class OMSPullConsumer {
    public static void main(String[] args) {
        final MessagingAccessPoint messagingAccessPoint = MessagingAccessPointFactory
            .getMessagingAccessPoint("openmessaging:rocketmq://IP1:9876,IP2:9876/namespace");

        final PullConsumer consumer = messagingAccessPoint.createPullConsumer("OMS_HELLO_TOPIC",
            OMS.newKeyValue().put(NonStandardKeys.CONSUMER_GROUP, "OMS_CONSUMER"));

        messagingAccessPoint.startup();
        System.out.printf("MessagingAccessPoint startup OK%n");
        
        consumer.startup();
        System.out.printf("Consumer startup OK%n");

        Message message = consumer.poll();
        if (message != null) {
            String msgId = message.headers().getString(MessageHeader.MESSAGE_ID);
            System.out.printf("Received one message: %s%n", msgId);
            consumer.ack(msgId);
        }

        consumer.shutdown();
        messagingAccessPoint.shutdown();
    }
}

OMSPushConsumer

通过MessageListener将OMS PushConsumer附加到指定的队列并使用消息

public class OMSPushConsumer {
    public static void main(String[] args) {
        final MessagingAccessPoint messagingAccessPoint = MessagingAccessPointFactory
            .getMessagingAccessPoint("openmessaging:rocketmq://IP1:9876,IP2:9876/namespace");

        final PushConsumer consumer = messagingAccessPoint.
            createPushConsumer(OMS.newKeyValue().put(NonStandardKeys.CONSUMER_GROUP, "OMS_CONSUMER"));

        messagingAccessPoint.startup();
        System.out.printf("MessagingAccessPoint startup OK%n");

        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            @Override
            public void run() {
                consumer.shutdown();
                messagingAccessPoint.shutdown();
            }
        }));
        
        consumer.attachQueue("OMS_HELLO_TOPIC", new MessageListener() {
            @Override
            public void onMessage(final Message message, final ReceivedMessageContext context) {
                System.out.printf("Received one message: %s%n", message.headers().getString(MessageHeader.MESSAGE_ID));
                context.ack();
            }
        });
        
    }
}

---

RocketMQ logappender提供log4j appender，log4j2 appender和logback appender供业务使用，下面是配置示例.

log4j

当使用log4j属性配置文件时，config如下.

log4j.appender.mq=org.apache.rocketmq.logappender.log4j.RocketmqLog4jAppender
log4j.appender.mq.Tag=yourTag
log4j.appender.mq.Topic=yourLogTopic
log4j.appender.mq.ProducerGroup=yourLogGroup
log4j.appender.mq.NameServerAddress=yourRocketmqNameserverAddress
log4j.appender.mq.layout=org.apache.log4j.PatternLayout
log4j.appender.mq.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-4r [%t] (%F:%L) %-5p - %m%n

当使用log4j xml配置文件时，将其配置为此，并添加一个异步appender:

<appender name="mqAppender1" class="org.apache.rocketmq.logappender.log4j.RocketmqLog4jAppender">
    <param name="Tag" value="yourTag" />
    <param name="Topic" value="yourLogTopic" />
    <param name="ProducerGroup" value="yourLogGroup" />
    <param name="NameServerAddress" value="yourRocketmqNameserverAddress"/>
    <layout class="org.apache.log4j.PatternLayout">
        <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss}-%p %t %c - %m%n" />
    </layout>
</appender>

<appender name="mqAsyncAppender1" class="org.apache.log4j.AsyncAppender">
    <param name="BufferSize" value="1024" />
    <param name="Blocking" value="false" />
    <appender-ref ref="mqAppender1"/>
</appender>

log4j2

当使用log4j2时，config为这个。如果你想要noneblock，只需要为ref配置一个asyncAppender.

<RocketMQ name="rocketmqAppender" producerGroup="yourLogGroup" nameServerAddress="yourRocketmqNameserverAddress"
     topic="yourLogTopic" tag="yourTag">
    <PatternLayout pattern="%d [%p] hahahah %c %m%n"/>
</RocketMQ>

logback

在使用logback时，还需要一个asyncAppender.

<appender name="mqAppender1" class="org.apache.rocketmq.logappender.logback.RocketmqLogbackAppender">
    <tag>yourTag</tag>
    <topic>yourLogTopic</topic>
    <producerGroup>yourLogGroup</producerGroup>
    <nameServerAddress>yourRocketmqNameserverAddress</nameServerAddress>
    <layout>
        <pattern>%date %p %t - %m%n</pattern>
    </layout>
</appender>

<appender name="mqAsyncAppender1" class="ch.qos.logback.classic.AsyncAppender">
    <queueSize>1024</queueSize>
    <discardingThreshold>80</discardingThreshold>
    <maxFlushTime>2000</maxFlushTime>
    <neverBlock>true</neverBlock>
    <appender-ref ref="mqAppender1"/>
</appender>

5.消息总线项目

项目分为三部分

1. mq-manager：topic（tag）、 应用、DB管理平台，在平台上配置后才能使用，topic（tag）与应用、topic（tag）与DB均为多对多的关系；
2. mq-sdk：为其他项目提供发送消息，接收消息的接口，需集成该sdk；项目启动后，sdk会查询db，将配置好的信息缓存至内存，发送或接收消息时，校验权限，通过后发送消息到消息队列，该项目采用了设计模式中的适配器模式；
3. mq-worker：一个单独部署的监听项目，方便日后分布式，监听异步消息到数据库。当监听到消息时，与数据库创建连接，执行sql，aop监听db与topic关系的改变，刷新监听。

pom

 <!--RocketMQ依赖-->
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-client</artifactId>
        <version>4.5.2</version>
    </dependency>

public class RocketMQProperties{
	String namesrvAddr;
	producerGroupName;
	
}

@Data
public class MessageEvent extends ApplicationEvent{
	DefaultMQPushConsumer consumer;
	List<MessageExt> msgs;
	
	public MessageEvent (List<MessageExt> msgs,DefaultMQPushConsumer consumer){
		super();
		this.consumer=consumer;
		this.msgs=msgs;
	}
}

// 当db使用关系变化时，重新初始化监听器
@Aspect
@Component
public class InitListenerAspect{
	@Resource
	RocketConsumer consumer;
	
	@Pointcut("@annotation(com.....InitListenerAnno)")
	public void anyMethod(){}

	@After("...anyMethod()")
	public void afterMethod(JoinPoint point){
		consumer.initListener();
	}
}

6.思考题

1.优缺点

RocketMQ优点：

• 单机吞吐量：十万级
• 可用性：非常高，分布式架构
• 消息可靠性：经过参数优化配置，消息可以做到0丢失
• 功能支持：MQ功能较为完善，还是分布式的，扩展性好
• 支持10亿级别的消息堆积，不会因为堆积导致性能下降
• 源码是java，我们可以自己阅读源码，定制自己公司的MQ，可以掌控
• 天生为金融互联网领域而生，对于可靠性要求很高的场景，尤其是电商里面的订单扣款，以及业务削峰，在大量交易涌入时，后端可能无法及时处理的情况
• RoketMQ在稳定性上可能更值得信赖，这些业务场景在阿里双11已经经历了多次考验，如果你的业务有上述并发场景，建议可以选择RocketMQ

RocketMQ缺点：

• 支持的客户端语言不多，目前是java及c++，其中c++不成熟
• 社区活跃度不是特别活跃那种
• 没有在 mq 核心中去实现JMS等接口，有些系统要迁移需要修改大量代码

2.消息去重

去重原则：使用业务端逻辑保持幂等性

幂等性：就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用，数据库的结果都是唯一的，不可变的。

只要保持幂等性，不管来多少条重复消息，最后处理的结果都一样，需要业务端来实现。

去重策略：保证每条消息都有唯一编号(比如唯一流水号)，且保证消息处理成功与去重表的日志同时出现。

建立一个消息表，拿到这个消息做数据库的insert操作。给这个消息做一个唯一主键（primary key）或者唯一约束，那么就算出现重复消费的情况，就会导致主键冲突，那么就不再处理这条消息。

3.消息重复

消息领域有一个对消息投递的QoS（Quality of Service，服务质量）定义，分为：

• 最多一次（At most once）
• 至少一次（At least once）
• 仅一次（ Exactly once）

几乎所有的MQ产品都声称自己做到了At least once。

既然是至少一次，那避免不了消息重复，尤其是在分布式网络环境下。

比如：网络原因闪断，ACK返回失败等等故障，确认信息没有传送到消息队列，导致消息队列不知道自己已经消费过该消息了，再次将该消息分发给其他的消费者。

不同的消息队列发送的确认信息形式不同，例如RabbitMQ是发送一个ACK确认消息，RocketMQ是返回一个CONSUME_SUCCESS成功标志，Kafka实际上有个offset的概念。

RocketMQ没有内置消息去重的解决方案，最新版本是否支持还需确认。

4.消息的可用性

当我们选择好了集群模式之后，那么我们需要关心的就是怎么去存储和复制这个数据，RocketMQ对消息的刷盘提供了同步和异步的策略来满足我们的需求，当我们选择同步刷盘之后，如果刷盘超时会给返回FLUSH_DISK_TIMEOUT，如果是异步刷盘不会返回刷盘相关信息，选择同步刷盘可以尽最大程度满足我们的消息不会丢失。

除了存储有选择之后，我们的主从同步提供了同步和异步两种模式来进行复制，当然选择同步可以提升可用性，但是消息的发送RT时间会下降10%左右。

RocketMQ采用的是混合型的存储结构，即为Broker单个实例下所有的队列共用一个日志数据文件（即为CommitLog）来存储。

而Kafka采用的是独立型的存储结构，每个队列一个文件。

RocketMQ采用混合型存储结构的缺点在于，会存在较多的随机读操作，因此读的效率偏低。同时消费消息需要依赖ConsumeQueue，构建该逻辑消费队列需要一定开销。

5.RocketMQ 刷盘实现

Broker 在消息的存取时直接操作的是内存（内存映射文件），这可以提供系统的吞吐量，但是无法避免机器掉电时数据丢失，所以需要持久化到磁盘中。

刷盘的最终实现都是使用NIO中的 MappedByteBuffer.force() 将映射区的数据写入到磁盘，如果是同步刷盘的话，在Broker把消息写到CommitLog映射区后，就会等待写入完成。

异步而言，只是唤醒对应的线程，不保证执行的时机，流程如图所示。

顺序消息：

我简单的说一下我们使用的RocketMQ里面的一个简单实现吧。

Tip：为啥用RocketMQ举例呢，这玩意是阿里开源的，我问了下身边的朋友很多公司都有使用，所以读者大概率是这个的话我就用这个举例吧，具体的细节我后面会在RocketMQ和Kafka各自章节说到。

生产者消费者一般需要保证顺序消息的话，可能就是一个业务场景下的，比如订单的创建、支付、发货、收货。

那这些东西是不是一个订单号呢？一个订单的肯定是一个订单号的说，那简单了呀。

一个topic下有多个队列，为了保证发送有序，RocketMQ提供了MessageQueueSelector队列选择机制，他有三种实现:

我们可使用Hash取模法，让同一个订单发送到同一个队列中，再使用同步发送，只有同个订单的创建消息发送成功，再发送支付消息。这样，我们保证了发送有序。

RocketMQ的topic内的队列机制,可以保证存储满足FIFO（First Input First Output 简单说就是指先进先出）,剩下的只需要消费者顺序消费即可。

RocketMQ仅保证顺序发送，顺序消费由消费者业务保证!!!

这里很好理解，一个订单你发送的时候放到一个队列里面去，你同一个的订单号Hash一下是不是还是一样的结果，那肯定是一个消费者消费，那顺序是不是就保证了？

真正的顺序消费不同的中间件都有自己的不同实现我这里就举个例子，大家思路理解下。

分布式事务：

Half Message(半消息)

是指暂不能被Consumer消费的消息。Producer 已经把消息成功发送到了 Broker 端，但此消息被标记为暂不能投递状态，处于该种状态下的消息称为半消息。需要 Producer

对消息的二次确认后，Consumer才能去消费它。
消息回查

由于网络闪段，生产者应用重启等原因。导致 Producer 端一直没有对 Half Message(半消息) 进行 二次确认。这是Brock服务器会定时扫描长期处于半消息的消息，会

主动询问 Producer端 该消息的最终状态(Commit或者Rollback),该消息即为 消息回查。

1. A服务先发送个Half Message给Brock端，消息中携带 B服务 即将要+100元的信息。
2. 当A服务知道Half Message发送成功后，那么开始第3步执行本地事务。
3. 执行本地事务(会有三种情况1、执行成功。2、执行失败。3、网络等原因导致没有响应)
4. 如果本地事务成功，那么Product像Brock服务器发送Commit,这样B服务就可以消费该message。
5. 如果本地事务失败，那么Product像Brock服务器发送Rollback,那么就会直接删除上面这条半消息。
6. 如果因为网络等原因迟迟没有返回失败还是成功，那么会执行RocketMQ的回调接口,来进行事务的回查。

消息过滤

Broker端消息过滤　　
在Broker中，按照Consumer的要求做过滤，优点是减少了对于Consumer无用消息的网络传输。缺点是增加了Broker的负担，实现相对复杂。
Consumer端消息过滤
这种过滤方式可由应用完全自定义实现，但是缺点是很多无用的消息要传输到Consumer端。

Broker的Buffer问题

Broker的Buffer通常指的是Broker中一个队列的内存Buffer大小，这类Buffer通常大小有限。

另外，RocketMQ没有内存Buffer概念，RocketMQ的队列都是持久化磁盘，数据定期清除。

RocketMQ同其他MQ有非常显著的区别，RocketMQ的内存Buffer抽象成一个无限长度的队列，不管有多少数据进来都能装得下，这个无限是有前提的，Broker会定期删除过期的数据。

例如Broker只保存3天的消息，那么这个Buffer虽然长度无限，但是3天前的数据会被从队尾删除。

回溯消费

回溯消费是指Consumer已经消费成功的消息，由于业务上的需求需要重新消费，要支持此功能，Broker在向Consumer投递成功消息后，消息仍然需要保留。并且重新消费一般是按照时间维度。

例如由于Consumer系统故障，恢复后需要重新消费1小时前的数据，那么Broker要提供一种机制，可以按照时间维度来回退消费进度。

RocketMQ支持按照时间回溯消费，时间维度精确到毫秒，可以向前回溯，也可以向后回溯。

消息堆积

消息中间件的主要功能是异步解耦，还有个重要功能是挡住前端的数据洪峰，保证后端系统的稳定性，这就要求消息中间件具有一定的消息堆积能力，消息堆积分以下两种情况：

• 消息堆积在内存Buffer，一旦超过内存Buffer，可以根据一定的丢弃策略来丢弃消息，如CORBA Notification规范中描述。适合能容忍丢弃消息的业务，这种情况消息的堆积能力主要在于内存Buffer大小，而且消息堆积后，性能下降不会太大，因为内存中数据多少对于对外提供的访问能力影响有限。
• 消息堆积到持久化存储系统中，例如DB，KV存储，文件记录形式。 当消息不能在内存Cache命中时，要不可避免的访问磁盘，会产生大量读IO，读IO的吞吐量直接决定了消息堆积后的访问能力。

评估消息堆积能力主要有以下四点：

• 消息能堆积多少条，多少字节？即消息的堆积容量。
• 消息堆积后，发消息的吞吐量大小，是否会受堆积影响？
• 消息堆积后，正常消费的Consumer是否会受影响？
• 消息堆积后，访问堆积在磁盘的消息时，吞吐量有多大？

定时消息

定时消息是指消息发到Broker后，不能立刻被Consumer消费，要到特定的时间点或者等待特定的时间后才能被消费。

如果要支持任意的时间精度，在Broker层面，必须要做消息排序，如果再涉及到持久化，那么消息排序要不可避免的产生巨大性能开销。

RocketMQ支持定时消息，但是不支持任意时间精度，支持特定的level，例如定时5s，10s，1m等。