RocketMQ 发送消息的基本案例

RocketMQ 消息发送的基本样例

“一发、一存、一消费” 是消息中间件的本质，本文简单的记录来RocketMQ消息的基本样例，包含消息的发送（同步消息/异步消息/单向消息）、消息消费（负载均衡模式/广播模式）、顺序消息、延时消息、批量消息以及事务消息。

首先在测试项目中引入依赖

<dependency><groupId>org.apache.rocketmq</groupId><artifactId>rocketmq-client</artifactId><version>4.3.0</version>
</dependency>

一、基本样例

1、消息的发送

消息发送可以拆分为如下几个基本步骤：1. 创建消息生产者producer，并制定生产者组名2. 指定nameserver地址3. 启动producter4. 创建消息对象，指定topic、tag和消息体5. 发送消息6. 关闭生产者

a）发送同步消息

在重要的通知消息、SMS通知，SMS营销系统等广泛的场景中使用可靠的同步传输。

public class BaseProducer {public static void main(String[] args) throws Exception {//1.创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("base-group");//2.指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.启动生产者producer.start();//每隔一秒发送1条消息，循环发送100条for (int i = 0; i < 100; i++) {String msgBody = "This is a msg to MQ" + i;System.out.println("发送消息:"+msgBody);//4.创建消息对象 指定主题、标签、消息体Message message = new Message("base-topic", "base-tag", msgBody.getBytes(RemotingHelper.DEFAULT_CHARSET));//5.发送顺序消息SendResult result = producer.send(message);//获取发送结果System.err.println("发送响应：MsgId:【" + result.getMsgId() + "】，发送状态:【" + result.getSendStatus()+"】");//线程休眠一秒再去发送下一条消息TimeUnit.SECONDS.sleep(1);}//6.关闭生产者producer.shutdown();}
}

启动执行main方法，控制台得到如下打印输出：

b）发送异步消息

异步传输通常用于对时间敏感的业务场景中,如果发送端不能容忍长时间的等待broker的响应的情况下可以选择发送异步消息。
与发送同步消息基本上一致，只有在第五步消息发送环节，通过提供的public void send(Message msg, SendCallback sendCallback) throws MQClientException, RemotingException, InterruptedException 方法来发送异步消息。在发送时创建一个SendCallback接口的匿名内部实现类，实现消息发送成功的回调方法onSuccess(SendResult sendResult)，以及消息发送失败出现异常时的onException(Throwable throwable)方法。

public class AsyncProducer1 {public static void main(String[] args) throws Exception{//1.创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("async-group");//2.指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.启动生产者producer.start();//循环发送100条消息for (int i = 0; i < 100; i++) {String msgBody = "This is an async msg to MQ" + i;System.out.println("发送消息:"+msgBody);//4.创建消息对象 指定主题、标签、消息体Message message = new Message("async-topic", "async-tag", msgBody.getBytes(RemotingHelper.DEFAULT_CHARSET));//5.发送异步消息producer.send(message, new SendCallback() {/*** 发送成功的回调函数* @param sendResult*/@Overridepublic void onSuccess(SendResult sendResult) {System.out.println("发送结果："+sendResult);}/*** 发送异常的回调函数* @param throwable*/@Overridepublic void onException(Throwable throwable) {System.out.println("发送异常："+throwable);}});}//6.关闭生产者producer.shutdown();}
}

启动执行main方法，控制台得到如下打印输出：

c）单向发送消息

单向消息一般用于不是特别关心发送结果的场景，例如发送日志。
发送单向消息，只是在基本单顺序消息发送案例的基础上使用public void sendOneway(Message msg) throws MQClientException, RemotingException, InterruptedException 方法对消息进行发送。

public class OnewayProducer1 {public static void main(String[] args) throws Exception{//1.创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("one-way-group");//2.指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.启动生产者producer.start();//循环发送10条消息for (int i = 0; i < 10; i++) {String msgBody = "This is an one way msg to MQ" + i;System.out.println("发送消息:"+msgBody);//4.创建消息对象 指定主题、标签、消息体Message message = new Message("one-way-topic", "one-way-tag", msgBody.getBytes(RemotingHelper.DEFAULT_CHARSET));//5.发送单向消息producer.sendOneway(message);}//6.关闭生产者producer.shutdown();}
}

2、消费消息

消费消息可以分为如下几个步骤：1. 创建消费者consumer，制定消费者组名2. 指定nameserver地址3. 订阅主题topic和tag4. 设置回调函数，处理消息5. 启动消费者consumer

消费者DefaultMQPushConsumer提供了public void setMessageModel(MessageModel messageModel)方法来设置消费的模式。

MessageModel.BROADCASTING   广播模式
MessageModel.CLUSTERING  负载均衡模式（默认）

a）负载均衡模式（默认）

负载均衡模式指的是：一个消费者组内所有对消费者，共同承担消息的消费，每一个消费者消费的消息都是不同的。

public class BaseConsumer {public static void main(String[] args) throws Exception{//1.创建消费者DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("base-group");//2.指定nameserver地址consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.订阅主题topic和tagconsumer.subscribe("base-topic", "*");//4.注册消息监听器consumer.registerMessageListener(new MessageListenerConcurrently() {@Overridepublic ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {try {for (MessageExt messageExt : list) {System.err.println("消费消息: " + new String(messageExt.getBody()));}} catch (Exception e) {e.printStackTrace();return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试}return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功}});//5.启动消费者consumer.start();}
}

c）广播模式

广播模式是指组内的所有消费者都会消费全量的消息，在在消费者启动前，设置消费模式为MessageModel.BROADCASTING即可。

public class BaseConsumer {public static void main(String[] args) throws Exception{//1.创建消费者DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("base-group");//2.指定nameserver地址consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.订阅主题topic和tagconsumer.subscribe("base-topic", "*");//设定消费模式 【负载均衡模式(默认)/广播模式MessageModel.BROADCASTING】consumer.setMessageModel(MessageModel.BROADCASTING);//4.注册消息监听器consumer.registerMessageListener(new MessageListenerConcurrently() {@Overridepublic ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list,ConsumeConcurrentlyContext consumeConcurrentlyContext) {try {for (MessageExt messageExt : list) {System.err.println("消费消息: " + new String(messageExt.getBody()));}} catch (Exception e) {e.printStackTrace();return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试}return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功}});//5.启动消费者consumer.start();}
}

二、顺序消息

消息中间件在数据结构上是一种先进先出的数据结构，消息的生产者将消息发送到broker中，存储在队列中，但实际上在一个broker中队列的数量往往大于一个，例如下图即为控制台中展示的broker中拥有四个队列。

可以得出，当有消息发送到broker中到时候，在默认的情况下消息会采取Round Robin轮询方式把消息发送到不同的queue（分区队列）。而消费者来消费消息时，是从多个queue上拉取消息，这种情况发送和消费是不能保证顺序的，如何保证消息当顺序消费，是用户在使用时需要结合业务场景来考虑的问题之一。

果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上拉去消息，就保证了顺序。- 将某些需要保持顺序的局部消息放到broker的同一个队列中。- 用同一个线程保证其处理broker中的一个队列的消息。

订单模型类

public class OrderStep {private Long orderId;private String desc;public OrderStep(Long orderId, String desc) {this.orderId = orderId;this.desc = desc;}public OrderStep() {}@Overridepublic String toString() {return "OrderStep{" +"orderId=" + orderId +", desc='" + desc + '\'' +'}';}public static List<OrderStep> buildOrders(){List<OrderStep> orderlist = new ArrayList<>();Long[] ids = {1001l,1002l,1003l,1004l};for(Long id : ids){OrderStep orderStep = new OrderStep(id,"创建");orderlist.add(orderStep);OrderStep orderStep = new OrderStep(id,"付款");orderlist.add(orderStep);OrderStep orderStep = new OrderStep(id,"发货");orderlist.add(orderStep);OrderStep orderStep = new OrderStep(id,"关闭");orderlist.add(orderStep);}return orderlist;}
}

顺序消息的生产者
消息生产者通过MessageQueueSelector 分区队列选择器，通过订单ID以及自定义的规则，对消息进行分区队列对选择。

public class OrderProducer {public static void main(String[] args) throws Exception{//创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("order-group");//指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//启动生产者producer.start();//构建消息集合List<OrderStep> orderSteps = OrderStep.buildOrders();//发送消息int i = 0 ;for(OrderStep orderStep : orderSteps){String body = JSON.toJSONString(orderStep);Message msg = new Message("OrderTopic","order",""+(i++),body.getBytes());/*** 参数一：消息对象* 参数二：消息队列的选择器* 参数三：选择队列的业务表识（订单ID）*/SendResult sendResult = producer.send(msg, new MessageQueueSelector() {/**** @param list 队列集合* @param message 消息对象* @param o 业务标示的参数* @return*/@Overridepublic MessageQueue select(List<MessageQueue> list, Message message, Object o) {Long orderId = (long) o;long index = orderId % list.size(); //订单ID除分区队列总数取模 System.out.println("队列总数【"+list.size()+"】，当前订单ID【"+orderId+"】选择的队列下标【"+index+"】");return list.get((int) index);}}, orderStep.getOrderId());System.out.println("发送结果：" + sendResult);}producer.shutdown();}
}

顺序消息的消费者
顺序消息的消费者通过MessageListenerOrderly ，让一个队列的消息用一个线程去处理。

public class OrderConsumer {public static void main(String[] args) throws Exception{//1.创建消费者DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order-group");//2.指定nameserver地址consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.订阅主题topic和tagconsumer.subscribe("OrderTopic", "*");//4.注册消息监听器  MessageListenerOrderly 一个队列的消息用一个线程去处理consumer.registerMessageListener(new MessageListenerOrderly() {/**** @param  msgs 获取到的消息* @param consumeOrderlyContext* @return*/@Overridepublic ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs,ConsumeOrderlyContext consumeOrderlyContext) {for(MessageExt msg : msgs){String str = new String(msg.getBody());System.out.println("线程名称【"+Thread.currentThread().getName()+"】消费消息：" + str);}return ConsumeOrderlyStatus.SUCCESS;}});//5.启动消费者consumer.start();}
}

三、延时消息

当发送当消息不需要立即消费，需要设置一定当延迟时间时，可以悬着发送延迟消息，该类型当消息并不会立即被消费，会延迟一段设定好的时间后才会被消费者消费。

 RocketMq并不支持任意时间的延迟，需要设置几个固定的延时等级，从1s到2h分别对应着等级1到18“1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h”

通过Message类中提供的 public void setDelayTimeLevel(int level)方法来设置延迟的级别。

延迟消息的生产者：

public class DelayProducer {public static void main(String[] args) throws Exception{//创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("order-group");//指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//启动生产者producer.start();//构建消息集合List<OrderStep> orderSteps = OrderStep.buildOrders();//发送消息int i = 0 ;for(OrderStep orderStep : orderSteps){String body = JSON.toJSONString(orderStep);Message msg = new Message("DelayTopic","d1",""+(i++),body.getBytes());msg.setDelayTimeLevel(2); //设置延迟时间级别/*** 参数一：消息对象* 参数二：消息队列的选择器* 参数三：选择队列的业务表识（订单ID）*/SendResult sendResult = producer.send(msg);System.out.println("发送结果：" + sendResult);}producer.shutdown();}
}

四、批量消息

当消息数量很多当时候，可以通过批量发送当形式来提高消息的发送效率。批量发送消息能够显著提高传递小消息的性能。

   限制：- 这批消息应该拥有相同的topic，相同分waitStoremsgOK，而且不能是延迟消息。- 批消息的总大小不应该超过4MB

批量消息的生产者：

public class BatchProducer {public static void main(String[] args) throws Exception{//1.创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("batch-group");//2.指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.启动生产者producer.start();//4.构建一个消息集合List<Message> msgs = new ArrayList<>();for(int i = 1 ; i<=10 ; i++){Message message = new Message("batch-topic", "batch-tag", ("Hello World" + i ).getBytes());msgs.add(message);}//5.发送批量消息SendResult send = producer.send(msgs);System.out.println("批量发送结果：" + send);//6.关闭生产者producer.shutdown();}
}

五、事务消息

RocketMQ提供事务消息的发送，主要是为了解决本地事务执行与消息发送的原子性问题。即解决Producer执行业务逻辑成功之后投递消息可能失败的场景。

事务消息的状态
1.提交状态：允许消费者消费此消息
2.回归状态：消息将被删除，不允许被消费
3.中间状态：代表需要检查消息队列来确定状态
事务消息发送及提交
1.发送消息（half消息）
2.服务端响应写入结果
3.根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）
4.根据本地事务状态执行commit或者rollback （commit操作生成消息索引，消息对消费者可见）
事务补偿
1.对没有commit/rolback对事务消息（pending状态对消息）从服务端发起一次回查
2.Producer收到回查消息，检查回查消息对应对的本地事务的状态
3.根据本地事务状态，重新commit汇总rollback，其中，补偿阶段用于解决消息commiy或者rollback发生超时或者失败的情况。
使用的限制
1.事务消息不支持延迟消息和批量消息
2.未来避免单个消息被检查太多次而导致半队列消息积累，可以设置默认单个消息的检查次数限制为15次，但是用户可以通过Broker配置文件的transactionCheckMax参数来修改此限制。如果已检查某条消息超过N次的话（N=transactionCheckMax）则Broker将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写AbstractTransactionCheckListener类来修改这个行为。
3.事务消息将在broker配置文件中的参数transactionMsgTimeout这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性CHECK_IMMUNITY_TIME_IN_SECONDS来改变这个限制，该参数优先于transactionMsgTimeout参数。
4.事务性消息可能不止一次被检查或消费。
5.提交给用户的目标主题消费可能会失败，目前这依据日志的记录而定，它的高可用性机制来保证，如果希望确保事务消费不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
6.事务消息的生产者ID不能与其他类型消费的生产者ID共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者ID查询到消费者。

事务消息的生产者

public class Producer {public static void main(String[] args) throws Exception{//1.创建事务消息生产者producer，并制定生产者的组名TransactionMQProducer producer = new TransactionMQProducer("transaction-group");//2.指定NameServer地址producer.setNamesrvAddr("39.108.128.240:9876");//3.设置事务监听器producer.setTransactionListener(new MyTransactionListener());//4.启动生产者producer.start();//每隔一秒，循环发送5条消息for (int i = 0; i < 4; i++) {String body = "事务消息【"+i+"】";//创建消息对象 指定主题、标签、消息体  同步和异步是一致到Message message = new Message("transaction-topic", "T-"+i, body.getBytes());//同步发送消息SendResult sendResult = producer.sendMessageInTransaction(message,null);//打印消息发送的结果System.out.println("发送结果："+sendResult);//线程休眠一秒再去发送下一条消息TimeUnit.SECONDS.sleep(1);}//关闭生产者 不建议在事务消息中关闭，可能回导致事务监听器不执行//producer.shutdown();}
}

自定义的事务监听器

public class MyTransactionListener implements TransactionListener {//在该方法中执行本地的一些事务@Overridepublic LocalTransactionState executeLocalTransaction(Message message, Object o) {if(message.getTags().equals("T-1")){System.out.println("tag【"+message.getTags()+"】-- 事务提交");return LocalTransactionState.COMMIT_MESSAGE;}else if(message.getTags().equals("T-2")){System.out.println("tag【"+message.getTags()+"】-- 事务回滚");return LocalTransactionState.ROLLBACK_MESSAGE;}else {System.out.println("tag【"+message.getTags()+"】-- 事务结果未知");return LocalTransactionState.UNKNOW;}}//MQ在没有接收到事务结果时，发送请求来二次核对 ，消息事务状态的回查@Overridepublic LocalTransactionState checkLocalTransaction(MessageExt messageExt) {System.out.println("MQ开始事务状态的回查");if(messageExt.getTags().equals("T-3")){System.out.println("tag【"+messageExt.getTags()+"】-- 事务提交");return LocalTransactionState.COMMIT_MESSAGE;}else{System.out.println("tag【"+messageExt.getTags()+"】-- 仍然结果未知");return LocalTransactionState.UNKNOW;}}
}

事务消息的消费者

public class Consumer {public static void main(String[] args) throws Exception{//1.创建消费者DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("transaction-group");//2.指定nameserver地址consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.订阅主题topic和tagconsumer.subscribe("transaction-topic", "*");//4.设置回调函数 处理消息consumer.registerMessageListener((MessageListenerConcurrently) (list, context) -> {try {for (MessageExt messageExt : list) {System.err.println("消费消息: " + new String(messageExt.getBody()));//输出消息内容}} catch (Exception e) {e.printStackTrace();return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试}return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功});//5.启动消费者consumer.start();//6.打印启动状态System.out.println("消费者启动成功");}
}

六、消费消息的过滤

针对消费者，消费者来决定对哪些消息进行消费，对哪些消息不消费。
提供两种消息过滤的方式
1.依据tag来过滤
2.依据RocketMQ定义了一些基本语法来支持过滤（只有使用push模式对消费者才能使用SQL92标准对sql语句）

数值比较例如： > , >= ,< , <= , BETWEEN ， = ;
字符比较例如：= ，<> ,IN;
IS NULL 或者 IS NOT NULL ；
逻辑符号 AND ， OR ，NOT；
常量支持类型：
数值例如：123，3.1415926
字符例如：‘abc’ 必须用单引号包裹起来
特殊字符例如：NULL
布尔值 TRUE 或 FALSE

sql模式过滤的消息生产者
通过Message对象提供的 public void putUserProperty(String name, String value) 方法，添加自定义sql查询的标示与内容。

public class Producer {public static void main(String[] args) throws Exception{//创建消息生产者producer，并制定生产者的组名DefaultMQProducer producer = new DefaultMQProducer("sql-filter-group");//指定NameServer地址producer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//启动生产者producer.start();//每隔一秒，循环发送5条消息for (int i = 0; i < 5; i++) {String body = "通过tag过滤消息"+i;//创建消息对象 指定主题、标签、消息体  同步和异步是一致到Message message = new Message("sql-filter-topic", "sql-filter-tag", body.getBytes());//设置消息 用户自定义属性message.putUserProperty("i",String.valueOf(i));//同步发送消息SendResult sendResult = producer.send(message);//打印消息发送的结果System.out.println("发送结果："+sendResult);//线程休眠一秒再去发送下一条消息TimeUnit.SECONDS.sleep(1);}}
}

sql模式过滤的消息消费者

public class Consumer {public static void main(String[] args) throws Exception{//1.创建消费者DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("sql-filter-group");//2.指定nameserver地址consumer.setNamesrvAddr("***.***.***.***:9876");//您MQ的地址，集群用英文逗号隔开//3.订阅主题topic和tag  依据消息sql过滤器来过滤消息consumer.subscribe("sql-filter-topic", MessageSelector.bySql("i>=0"));//4.设置回调函数 处理消息consumer.registerMessageListener((MessageListenerConcurrently) (list, context) -> {try {for (MessageExt messageExt : list) {System.err.println("消费消息:【 " + new String(messageExt.getBody())+"】");}} catch (Exception e) {e.printStackTrace();return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试}return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功});//5.启动消费者consumer.start();//6.打印启动状态System.out.println("消费者启动成功");}
}

参考学习视频黑马程序员《RocketMQ系统精讲，经受历年双十一狂欢节考验的分布式消息中间件》，图片来源于网络侵删～