RocketMQ消息发送方式

普通消息

同步

生产者

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendResult;  
3. import org.apache.rocketmq.client.producer.SendStatus;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.concurrent.TimeUnit;  
6. /** 
7.  * 发送同步消息 
8.  */  
9. public class SyncProducer {  
10.     public static void main(String[] args) throws Exception {  
11.         //1.创建消息生产者producer，并制定生产者组名  
12.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
13.         //2.指定Nameserver地址  
14.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
15.         //3.启动producer  
16.         producer.start();  
17.         for (int i = 0; i < 10; i++) {  
18.             //4.创建消息对象，指定主题Topic、Tag和消息体  
19.             /** 
20.              * 参数一：消息主题Topic 
21.              * 参数二：消息Tag 
22.              * 参数三：消息内容 
23.              */  
24.             Message msg = new Message("springboot-mq", "Tag1", ("Hello World" + i).getBytes());  
25.             //5.发送消息：同步消息--此处会阻塞，一直到broker给响应  
26.             SendResult result = producer.send(msg);  
27.             //发送状态  
28.             SendStatus status = result.getSendStatus();  
29.             // mq 对某个消息产生的唯一标识  
30.             String msgId = result.getMsgId();  
31.             System.out.println("消息id: " + msgId);  
32.   
33.             int queueId = result.getMessageQueue().getQueueId();  
34.             System.out.println("该消息所在队列的id： " + queueId);  
35.             // 发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80A11681818B4AAC21BBD81AE0000, offsetMsgId=C0A876A000002A9F00000000000FB9B4, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-a, queueId=0], queueOffset=1]  
36.             System.out.println("发送结果:" + result);  
37.   
38.             //线程睡1秒  
39.             TimeUnit.SECONDS.sleep(1);  
40.         }  
41.   
42.         //6.关闭生产者producer  
43.         producer.shutdown();  
44.     }  
45. }  

消费者

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
4. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
5. import org.apache.rocketmq.common.message.MessageExt;  
6. import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;  
7. import java.util.List;  
8.   
9. /** 
10.  * 消息的接受者 
11.  */  
12. public class Consumer {  
13.   
14.     public static void main(String[] args) throws Exception {  
15.         //1.创建消费者Consumer，制定消费者组名  
16.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group2");  
17.         //2.指定Nameserver地址  
18.         consumer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
19.   //3.订阅主题Topic和Tag，tag可以用于过滤，方法声明： void subscribe(String topic, String subExpression)  
20.         consumer.subscribe("springboot-mq", "*");  
21.         // 有陷阱，参考类集ConsumeFromWhere详解  
22. //        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);  
23. //        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_TIMESTAMP);  
24.         //4. 设定消费模式：负载均衡|广播模式  
25.         consumer.setMessageModel(MessageModel.BROADCASTING);  
26. //        consumer.setMessageModel(MessageModel.CLUSTERING);  
27.   
28.         //5. 设置回调函数（监听器），处理消息  
29.         consumer.registerMessageListener(new MessageListenerConcurrently() {  
30.   
31.             //接受消息内容  
32.             @Override  
33.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
34.                 for (MessageExt msg : msgs) {  
35.                     System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));  
36.                 }  
37.                 // 消费结果  
38.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;  
39.             }  
40.         });  
41.         //5.启动消费者consumer  
42.         consumer.start();  
43.     }  
44. }  

异步

生产者（消费者跟同步一样，主要定义的主题和tag）

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendCallback;  
3. import org.apache.rocketmq.client.producer.SendResult;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. /** 
8.  * 发送异步消息 
9.  */  
10. public class AsyncProducer {  
11.   
12.     public static void main(String[] args) throws Exception {  
13.         //1.创建消息生产者producer，并制定生产者组名  
14.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
15.         //2.指定Nameserver地址  
16.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
17.         //3.启动producer  
18.         producer.start();  
19.   
20.         for (int i = 0; i < 10; i++) {  
21.             //4.创建消息对象，指定主题Topic、Tag和消息体  
22.             /** 
23.              * 参数一：消息主题Topic 
24.              * 参数二：消息Tag 
25.              * 参数三：消息内容 
26.              */  
27.             Message msg = new Message("base", "Tag2", ("Hello World" + i).getBytes());  
28.             //5.发送异步消息，此处不会阻塞等broker的响应: 有一个回调  
29.             producer.send(msg, new SendCallback() {  
30.                 /** 
31.                  * 发送成功回调函数 
32.                  * @param sendResult 
33.                  */  
34.                 public void onSuccess(SendResult sendResult) {  
35. // 发送结果：SendResult [sendStatus=SEND_OK, msgId=0A3A0429AED418B4AAC2118F44FF0000, offsetMsgId=C0A876A100002A9F00000000000F6DF3, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=0]  
36.                     System.out.println("发送结果：" + sendResult);  
37.                 }    
38.                 /** 
39.                  * 发送失败回调函数 
40.                  * @param e 
41.                  */  
42.                 public void onException(Throwable e) {  
43.                     System.out.println("发送异常：" + e);  
44.                 }  
45.             });  
46.   
47.             //线程睡1秒  
48.             TimeUnit.SECONDS.sleep(1);  
49.         }  
50.   
51.         //6.关闭生产者producer  
52.         producer.shutdown();  
53.     }  
54. }  

单向

生产者（消费者跟同步一样，主要定义的主题和tag）

1. import org.apache.rocketmq.client.exception.MQBrokerException;  
2. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
3. import org.apache.rocketmq.common.message.Message;  
4. import java.util.concurrent.TimeUnit;    
5. /** 
6.  * 发送单向消息：生产者不特别关心发送结果的场景，eg：日志发送 
7.  */  
8. public class OneWayProducer {  
9.   
10.     public static void main(String[] args) throws Exception, MQBrokerException {  
11.         //1.创建消息生产者producer，并制定生产者组名  
12.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
13.         //2.指定Nameserver地址  
14.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
15.         //3.启动producer  
16.         producer.start();  
17.   
18.         for (int i = 0; i < 3; i++) {  
19.             //4.创建消息对象，指定主题Topic、Tag和消息体  
20.             /** 
21.              * 参数一：消息主题Topic 
22.              * 参数二：消息Tag 
23.              * 参数三：消息内容 
24.              */  
25.             Message msg = new Message("base", "Tag3", ("Hello World，单向消息" + i).getBytes());  
26.             //5.发送单向消息，没有发送消息的结果状态，方法声明：public void sendOneway(Message msg)  
27.             producer.sendOneway(msg);  
28.   
29.             //线程睡1秒  
30.             TimeUnit.SECONDS.sleep(5);  
31.         }  
32.   
33.         //6.关闭生产者producer  
34.         producer.shutdown();  
35.     }  
36. }  

顺序消息

发送有序，但broker存在不同的queue里，消费者并发消费消息

全局消息顺序没有必要的，只要保证发送者张三、李四他们各自的消息是有序的即可（局部消息顺序）

如何保证？让张三的消息都扔到一个队列里面即可，消费时，每个线程独立消费一个队列

生产者（消费者跟同步一样，主要定义的主题和tag）

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.MessageQueueSelector;  
3. import org.apache.rocketmq.client.producer.SendResult;  
4. import org.apache.rocketmq.common.message.Message;  
5. import org.apache.rocketmq.common.message.MessageQueue;  
6. import java.util.List;  
7. public class Producer {  
8.   
9.     public static void main(String[] args) throws Exception {  
10.         //1.创建消息生产者producer，并制定生产者组名  
11.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
12.         //2.指定Nameserver地址  
13.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
14.         //3.启动producer  
15.         producer.start();  
16.         //构建消息集合  
17.         List<OrderStep> orderSteps = OrderStep.buildOrders();  
18.         //发送消息  
19.         for (int i = 0; i < orderSteps.size(); i++) {  
20.             String body = orderSteps.get(i) + "";  
21.             Message message = new Message("OrderTopic", "Order", "i" + i, body.getBytes());  
22.             /** 
23.              * 顺序消息的关键代码 
24.              * 参数一：消息对象 
25.              * 参数二：消息队列的选择器 
26.              * 参数三：选择队列的业务标识（订单ID） 
27.              */  
28.             SendResult sendResult = producer.send(message, new MessageQueueSelector() {  
29.                 /** 
30.                  * 
31.                  * @param mqs：消息队列集合 
32.                  * @param msg：消息对象 
33.                  * @param arg：业务标识的参数，此处就是orderSteps.get(i).getOrderId() 
34.                  * @return 
35.                  */  
36.                 @Override  
37.                 public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {  
38.                     long orderId = (long) arg;  
39.                     long index = orderId % mqs.size();  
40.                     return mqs.get((int) index);  
41.                 }  
42.             }, orderSteps.get(i).getOrderId());  
43.   
44.             System.out.println("发送结果：" + sendResult);  
45.         }  
46.         producer.shutdown();  
47.     }  
48.   
49. }  

1. import java.util.ArrayList;  
2. import java.util.List;  
3.   
4. /** 
5.  * 订单构建者 
6.  */  
7. public class OrderStep {  
8.     private long orderId;  
9.     private String desc;  
10.   
11.     public long getOrderId() {  
12.         return orderId;  
13.     }  
14.   
15.     public void setOrderId(long orderId) {  
16.         this.orderId = orderId;  
17.     }  
18.   
19.     public String getDesc() {  
20.         return desc;  
21.     }  
22.   
23.     public void setDesc(String desc) {  
24.         this.desc = desc;  
25.     }  
26.   
27.     @Override  
28.     public String toString() {  
29.         return "OrderStep{" +  
30.                 "orderId=" + orderId +  
31.                 ", desc='" + desc + '\'' +  
32.                 '}';  
33.     }  
34.   
35.     public static List<OrderStep> buildOrders() {  
36.         //  1039L   : 创建    付款 推送 完成  
37.         //  1065L   ： 创建   付款  
38.         //  7235L   ：创建    付款  
39.         List<OrderStep> orderList = new ArrayList<OrderStep>();  
40.   
41.         OrderStep orderDemo = new OrderStep();  
42.         orderDemo.setOrderId(1039L);  
43.         orderDemo.setDesc("创建");  
44.         orderList.add(orderDemo);  
45.   
46.         orderDemo = new OrderStep();  
47.         orderDemo.setOrderId(1065L);  
48.         orderDemo.setDesc("创建");  
49.         orderList.add(orderDemo);  
50.   
51.         orderDemo = new OrderStep();  
52.         orderDemo.setOrderId(1039L);  
53.         orderDemo.setDesc("付款");  
54.         orderList.add(orderDemo);  
55.   
56.         orderDemo = new OrderStep();  
57.         orderDemo.setOrderId(7235L);  
58.         orderDemo.setDesc("创建");  
59.         orderList.add(orderDemo);  
60.   
61.         orderDemo = new OrderStep();  
62.         orderDemo.setOrderId(1065L);  
63.         orderDemo.setDesc("付款");  
64.         orderList.add(orderDemo);  
65.   
66.         orderDemo = new OrderStep();  
67.         orderDemo.setOrderId(7235L);  
68.         orderDemo.setDesc("付款");  
69.         orderList.add(orderDemo);  
70.   
71.         orderDemo = new OrderStep();  
72.         orderDemo.setOrderId(1065L);  
73.         orderDemo.setDesc("完成");  
74.         orderList.add(orderDemo);  
75.   
76.         orderDemo = new OrderStep();  
77.         orderDemo.setOrderId(1039L);  
78.         orderDemo.setDesc("推送");  
79.         orderList.add(orderDemo);  
80.   
81.         orderDemo = new OrderStep();  
82.         orderDemo.setOrderId(7235L);  
83.         orderDemo.setDesc("完成");  
84.         orderList.add(orderDemo);  
85.   
86.         orderDemo = new OrderStep();  
87.         orderDemo.setOrderId(1039L);  
88.         orderDemo.setDesc("完成");  
89.         orderList.add(orderDemo);  
90.   
91.         return orderList;  
92.     }  
93. }  

消费者

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;  
4. import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;  
5. import org.apache.rocketmq.client.exception.MQClientException;  
6. import org.apache.rocketmq.common.message.MessageExt;  
7.   
8. import java.util.List;  
9.   
10. public class Consumer {  
11.     public static void main(String[] args) throws MQClientException {  
12.         //1.创建消费者Consumer，制定消费者组名  
13.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");  
14.         //2.指定Nameserver地址  
15.         consumer.setNamesrvAddr("192.168.118.161:9876;192.168.118.160:9876");  
16.         //3.订阅主题Topic和Tag  
17.         consumer.subscribe("OrderTopic", "*");  
18.   
19.         //4.注册消息监听器： 消费者特殊地方  
20.         consumer.registerMessageListener(new MessageListenerOrderly() {  
21.            // MessageListenerOrderly 一个队列只对应一个线程，来消费，来保证消息消费的顺序  
22.             @Override  
23.             public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {  
24.                 for (MessageExt msg : msgs) {  
25.                     System.out.println("线程名称：【" + Thread.currentThread().getName() + "】:" + new String(msg.getBody()));  
26.                 }  
27.                 return ConsumeOrderlyStatus.SUCCESS;  
28.             }  
29.         });  
30.   
31.         //5.启动消费者  
32.         consumer.start();  
33.   
34.         System.out.println("消费者启动");  
35.   
36.     }  
37. }  

延迟消息

是通过消息本身的级别来设置的，1到18级别，最多2小时

生产者

1. import org.apache.rocketmq.client.exception.MQBrokerException;  
2. import org.apache.rocketmq.client.exception.MQClientException;  
3. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
4. import org.apache.rocketmq.client.producer.SendResult;  
5. import org.apache.rocketmq.client.producer.SendStatus;  
6. import org.apache.rocketmq.common.message.Message;  
7. import org.apache.rocketmq.remoting.exception.RemotingException;  
8. import java.util.concurrent.TimeUnit;  
9.   
10. public class Producer {  
11.   
12.     public static void main(String[] args) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {  
13.         //1.创建消息生产者producer，并制定生产者组名  
14.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
15.         //2.指定Nameserver地址  
16.         producer.setNamesrvAddr("192.168.118.161:9876;192.168.118.160:9876");  
17.         //3.启动producer  
18.         producer.start();  
19.         for (int i = 0; i < 10; i++) {  
20.             //4.创建消息对象，指定主题Topic、Tag和消息体  
21.             /** 
22.              * 参数一：消息主题Topic 
23.              * 参数二：消息Tag 
24.              * 参数三：消息内容 
25.              */  
26.             Message msg = new Message("DelayTopic", "Tag1", ("Hello World" + i).getBytes());  
27.             //设定延迟时间  
28.             msg.setDelayTimeLevel(2);  
29.             //5.发送消息  
30.             SendResult result = producer.send(msg);  
31.             //发送状态  
32.             SendStatus status = result.getSendStatus();  
33.   
34.             System.out.println("发送结果:" + result);  
35.   
36.             //线程睡1秒  
37.             TimeUnit.SECONDS.sleep(1);  
38.         }  
39.   
40.         //6.关闭生产者producer  
41.         producer.shutdown();  
42.     }  
43.   
44. }  

消费者

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
4. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
5. import org.apache.rocketmq.common.message.MessageExt;  
6. import java.util.List;  
7.   
8. public class Consumer {  
9.   
10.     public static void main(String[] args) throws Exception {  
11.         //1.创建消费者Consumer，制定消费者组名  
12.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");  
13.         //2.指定Nameserver地址  
14.         consumer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
15.         //3.订阅主题Topic和Tag  
16.         consumer.subscribe("DelayTopic", "*");  
17.   
18.         //4.设置回调函数，处理消息  
19.         consumer.registerMessageListener(new MessageListenerConcurrently() {  
20.   
21.             //接受消息内容  
22.             @Override  
23.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
24.                 for (MessageExt msg : msgs) {  
25.                     System.out.println("消息ID：【" + msg.getMsgId() + "】,延迟时间：" + (System.currentTimeMillis() - msg.getStoreTimestamp()));  
26.                 }  
27.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;  
28.             }  
29.         });  
30.         //5.启动消费者consumer  
31.         consumer.start();  
32.   
33.         System.out.println("消费者启动");  
34.     }  
35. }  

发送批量消息

  SendResult result = producer.send(msgs);发送的是消息集合，其他不变

  大小限制：大于4M会消息分割即消息分割

生产者

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendResult;  
3. import org.apache.rocketmq.client.producer.SendStatus;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.ArrayList;  
6. import java.util.List;  
7. import java.util.concurrent.TimeUnit;  
8. public class Producer {  
9.     public static void main(String[] args) throws Exception {  
10.         //1.创建消息生产者producer，并制定生产者组名  
11.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
12.         //2.指定Nameserver地址  
13.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
14.         //3.启动producer  
15.         producer.start();  
16.         List<Message> msgs = new ArrayList<Message>();  
17.         //4.创建消息对象，指定主题Topic、Tag和消息体  
18.         /** 
19.          * 参数一：消息主题Topic 
20.          * 参数二：消息Tag 
21.          * 参数三：消息内容 
22.          */  
23.         Message msg1 = new Message("BatchTopic", "Tag1", ("Hello World" + 1).getBytes());  
24.         Message msg2 = new Message("BatchTopic", "Tag1", ("Hello World" + 2).getBytes());  
25.         Message msg3 = new Message("BatchTopic", "Tag1", ("Hello World" + 3).getBytes());  
26.   
27.         msgs.add(msg1);  
28.         msgs.add(msg2);  
29.         msgs.add(msg3);  
30.   
31.         //5.发送消息  
32.         SendResult result = producer.send(msgs);  
33.         //发送状态  
34.         SendStatus status = result.getSendStatus();  
35.   
36.         System.out.println("发送结果:" + result);  
37.   
38.         //线程睡1秒  
39.         TimeUnit.SECONDS.sleep(1);  
40.         //6.关闭生产者producer  
41.         producer.shutdown();  
42.     }  
43.   
44. }  

消费者

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
4. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
5. import org.apache.rocketmq.common.message.MessageExt;  
6.   
7. import java.util.List;  
8.   
9. public class Consumer {  
10.     public static void main(String[] args) throws Exception {  
11.         //1.创建消费者Consumer，制定消费者组名  
12.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");  
13.         //2.指定Nameserver地址  
14.         consumer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
15.         //3.订阅主题Topic和Tag  
16.         consumer.subscribe("BatchTopic", "*");  
17.   
18.         //4.设置回调函数，处理消息  
19.         consumer.registerMessageListener(new MessageListenerConcurrently() {  
20.   
21.             //接受消息内容  
22.             @Override  
23.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
24.                 for (MessageExt msg : msgs) {  
25.                     System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));  
26.                 }  
27.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;  
28.             }  
29.         });  
30.         //5.启动消费者consumer  
31.         consumer.start();  
32.   
33.         System.out.println("消费者启动");  
34.     }  
35. }  

带额外属性的消息--消息过滤sql

生产者

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendResult;  
3. import org.apache.rocketmq.client.producer.SendStatus;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.concurrent.TimeUnit;  
6. public class Producer {  
7.   
8.     public static void main(String[] args) throws Exception {  
9.         //1.创建消息生产者producer，并制定生产者组名  
10.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
11.         //2.指定Nameserver地址  
12.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
13.         //3.启动producer  
14.         producer.start();  
15.   
16.         for (int i = 0; i < 10; i++) {  
17.             //4.创建消息对象，指定主题Topic、Tag和消息体  
18.             /** 
19.              * 参数一：消息主题Topic 
20.              * 参数二：消息Tag 
21.              * 参数三：消息内容 
22.              */  
23.             Message msg = new Message("FilterSQLTopic", "Tag1", ("Hello World" + i).getBytes());  
24.             // 自定义一个过滤条件  
25.             msg.putUserProperty("i", String.valueOf(i));  
26.   
27.             //5.发送消息  
28.             SendResult result = producer.send(msg);  
29.             //发送状态  
30.             SendStatus status = result.getSendStatus();  
31.   
32.             System.out.println("发送结果:" + i + result);  
33.   
34.             //线程睡1秒  
35.             TimeUnit.SECONDS.sleep(2);  
36.         }  
37.   
38.         //6.关闭生产者producer  
39.         producer.shutdown();  
40.     }  
41.   
42. }  

消费者

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.MessageSelector;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
4. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
5. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
6. import org.apache.rocketmq.common.message.MessageExt;  
7. import java.util.List;  
8. public class Consumer {  
9.     public static void main(String[] args) throws Exception {  
10.         //1.创建消费者Consumer，制定消费者组名  
11.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");  
12.         //2.指定Nameserver地址  
13.         consumer.setNamesrvAddr("192.168.118.161:9876;192.168.118.160:9876");  
14.         //3.订阅主题Topic和Tag  
15.         consumer.subscribe("FilterSQLTopic", MessageSelector.bySql("i>5"));  
16.   
17.         //4.设置回调函数，处理消息  
18.         consumer.registerMessageListener(new MessageListenerConcurrently() {  
19.   
20.             //接受消息内容  
21.             @Override  
22.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
23.                 for (MessageExt msg : msgs) {  
24.                     System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));  
25.                 }  
26.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;  
27.             }  
28.         });  
29.         //5.启动消费者consumer  
30.         consumer.start();  
31.         System.out.println("消费者启动");  
32.     }  
33. }  

消息过滤-tag

生产者1

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendResult;  
3. import org.apache.rocketmq.client.producer.SendStatus;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.concurrent.TimeUnit;  
6. public class Producer {  
7.   
8.     public static void main(String[] args) throws Exception {  
9.         //1.创建消息生产者producer，并制定生产者组名  
10.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
11.         //2.指定Nameserver地址  
12.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
13.         //3.启动producer  
14.         producer.start();  
15.   
16.         for (int i = 0; i < 3; i++) {  
17.             //4.创建消息对象，指定主题Topic、Tag和消息体  
18.             /** 
19.              * 参数一：消息主题Topic 
20.              * 参数二：消息Tag 
21.              * 参数三：消息内容 
22.              */  
23.             Message msg = new Message("FilterTagTopic", "Tag1", ("Hello World-Tag1" + i).getBytes());  
24.             //5.发送消息  
25.             SendResult result = producer.send(msg);  
26.             //发送状态  
27.             SendStatus status = result.getSendStatus();  
28.   
29.             System.out.println("发送结果:" + result);  
30.   
31.             //线程睡1秒  
32.             TimeUnit.SECONDS.sleep(1);  
33.         }  
34.   
35.         //6.关闭生产者producer  
36.         producer.shutdown();  
37.     }  
38.   
39. }  

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendResult;  
3. import org.apache.rocketmq.client.producer.SendStatus;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. public class Producer2 {  
8.   
9.     public static void main(String[] args) throws Exception {  
10.         //1.创建消息生产者producer，并制定生产者组名  
11.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
12.         //2.指定Nameserver地址  
13.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
14.         //3.启动producer  
15.         producer.start();  
16.   
17.         for (int i = 0; i < 3; i++) {  
18.             //4.创建消息对象，指定主题Topic、Tag和消息体  
19.             /** 
20.              * 参数一：消息主题Topic 
21.              * 参数二：消息Tag 
22.              * 参数三：消息内容 
23.              */  
24.             Message msg = new Message("FilterTagTopic", "Tag2", ("Hello World-Tag2" + i).getBytes());  
25.             //5.发送消息  
26.             SendResult result = producer.send(msg);  
27.             //发送状态  
28.             SendStatus status = result.getSendStatus();  
29.   
30.             System.out.println("发送结果:" + result);  
31.   
32.             //线程睡1秒  
33.             TimeUnit.SECONDS.sleep(1);  
34.         }  
35.   
36.         //6.关闭生产者producer  
37.         producer.shutdown();  
38.     }  
39.   
40. }  

生产者2

1. import org.apache.rocketmq.client.producer.DefaultMQProducer;  
2. import org.apache.rocketmq.client.producer.SendResult;  
3. import org.apache.rocketmq.client.producer.SendStatus;  
4. import org.apache.rocketmq.common.message.Message;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. public class Producer2 {  
8.   
9.     public static void main(String[] args) throws Exception {  
10.         //1.创建消息生产者producer，并制定生产者组名  
11.         DefaultMQProducer producer = new DefaultMQProducer("group1");  
12.         //2.指定Nameserver地址  
13.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
14.         //3.启动producer  
15.         producer.start();  
16.   
17.         for (int i = 0; i < 3; i++) {  
18.             //4.创建消息对象，指定主题Topic、Tag和消息体  
19.             /** 
20.              * 参数一：消息主题Topic 
21.              * 参数二：消息Tag 
22.              * 参数三：消息内容 
23.              */  
24.             Message msg = new Message("FilterTagTopic", "Tag2", ("Hello World-Tag2" + i).getBytes());  
25.             //5.发送消息  
26.             SendResult result = producer.send(msg);  
27.             //发送状态  
28.             SendStatus status = result.getSendStatus();  
29.   
30.             System.out.println("发送结果:" + result);  
31.   
32.             //线程睡1秒  
33.             TimeUnit.SECONDS.sleep(1);  
34.         }  
35.   
36.         //6.关闭生产者producer  
37.         producer.shutdown();  
38.     }  
39.   
40. }  

消费者

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
4. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
5. import org.apache.rocketmq.common.message.MessageExt;  
6. import java.util.List;  
7.   
8. public class Consumer {  
9.     public static void main(String[] args) throws Exception {  
10.         //1.创建消费者Consumer，制定消费者组名  
11.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");  
12.         //2.指定Nameserver地址  
13.         consumer.setNamesrvAddr("192.168.118.161:9876;192.168.118.160:9876");  
14.         //3.订阅主题Topic和Tag(|| 或的关系)  
15.         consumer.subscribe("FilterTagTopic", "Tag1 || Tag2 ");  
16.   
17.         //4.设置回调函数，处理消息  
18.         consumer.registerMessageListener(new MessageListenerConcurrently() {  
19.   
20.             //接受消息内容  
21.             @Override  
22.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
23.                 for (MessageExt msg : msgs) {  
24.                     System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));  
25.                 }  
26.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;  
27.             }  
28.         });  
29.         //5.启动消费者consumer  
30.         consumer.start();  
31.         System.out.println("消费者启动");  
32.     }  
33. }  

事务消息

生产者

1. import org.apache.commons.lang3.StringUtils;  
2. import org.apache.rocketmq.client.producer.*;  
3. import org.apache.rocketmq.common.message.Message;  
4. import org.apache.rocketmq.common.message.MessageExt;  
5. import java.util.concurrent.TimeUnit;  
6. public class Producer {  
7.   
8.     public static void main(String[] args) throws Exception {  
9.         //1.创建消息生产者producer，并制定生产者组名  
10.         TransactionMQProducer producer = new TransactionMQProducer("group5");  
11.         //2.指定Nameserver地址  
12.         producer.setNamesrvAddr("192.168.118.160:9876;192.168.118.161:9876");  
13.   
14.         //添加事务监听器  
15.         producer.setTransactionListener(new TransactionListener() {  
16.             /** 
17.              * 在该方法中执行本地事务 
18.              * @param msg 
19.              * @param arg 
20.              * @return 返回值决定了半消息是提交还是回滚，mq自己解决 
21.              */  
22.             @Override  
23.             public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {  
24.                 System.out.println(arg); // allen  
25.                 if (StringUtils.equals("TAGA", msg.getTags())) {  
26.                     // 提交，办消息变成可以被消息者消费的消息  
27.                     return LocalTransactionState.COMMIT_MESSAGE;  
28.                 } else if (StringUtils.equals("TAGB", msg.getTags())) {  
29.                     // 回滚半消息  
30.                     return LocalTransactionState.ROLLBACK_MESSAGE;  
31.                 } else if (StringUtils.equals("TAGC", msg.getTags())) {  
32.                     // 触发回查调用  
33.                     return LocalTransactionState.UNKNOW;  
34.                 }  
35.                 return LocalTransactionState.UNKNOW;  
36.             }  
37.   
38.             /** 
39.              * 该方法时MQ进行消息事务状态回查 
40.              * @param msg 
41.              * @return 
42.              */  
43.             @Override  
44.             public LocalTransactionState checkLocalTransaction(MessageExt msg) {  
45.                 System.out.println("回查消息的Tag:" + msg.getTags());  
46.                 return LocalTransactionState.COMMIT_MESSAGE;  
47.             }  
48.         });  
49.   
50.         //3.启动producer  
51.         producer.start();  
52.   
53.         String[] tags = {"TAGA", "TAGB", "TAGC"};  
54.   
55.         for (int i = 0; i < 3; i++) {  
56.             //4.创建消息对象，指定主题Topic、Tag和消息体  
57.             /** 
58.              * 参数一：消息主题Topic 
59.              * 参数二：消息Tag 
60.              * 参数三：消息内容 
61.              */  
62.             Message msg = new Message("TransactionTopic", tags[i], ("Hello World" + i).getBytes());  
63.             //5.发送消息 allen为Custom business parameter  
64.             SendResult result = producer.sendMessageInTransaction(msg, "allen");  
65.             //发送状态  
66.             SendStatus status = result.getSendStatus();  
67.   
68.             System.out.println("发送结果:" + result);  
69.   
70.             //线程睡1秒  
71.             TimeUnit.SECONDS.sleep(2);  
72.         }  
73.   
74.         //6.关闭生产者producer  
75.         //producer.shutdown();  
76.     }  
77. }  

消费者（跟普通的消费者一样）

1. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;  
2. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;  
3. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;  
4. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;  
5. import org.apache.rocketmq.common.message.MessageExt;  
6. import java.util.List;  
7.   
8. /** 
9.  * 消息的消费者者 
10.  */  
11. public class Consumer {  
12.   
13.     public static void main(String[] args) throws Exception {  
14.         //1.创建消费者Consumer，制定消费者组名  
15.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");  
16.         //2.指定Nameserver地址  
17.         consumer.setNamesrvAddr("192.168.118.161:9876;192.168.118.160:9876");  
18.         //3.订阅主题Topic和Tag  
19.         consumer.subscribe("TransactionTopic", "*");  
20.   
21.   
22.         //4.设置回调函数，处理消息  
23.         consumer.registerMessageListener(new MessageListenerConcurrently() {  
24.   
25.             //接受消息内容  
26.             @Override  
27.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {  
28.                 for (MessageExt msg : msgs) {  
29.                     System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));  
30.                 }  
31.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;  
32.             }  
33.         });  
34.         //5.启动消费者consumer  
35.         consumer.start();  
36.         System.out.println("消费者启动");  
37.     }  
38. }