目录
准备工作
所需的MQ客户端依赖
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>4.4.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.29</version>
</dependency>
基本属性解释
GroupName(组名):代表具有相同角色的生产者组合或消费者组合,称为生产者组或消费者组。作用是在集群HA的情况下,一个生产者宕机,本地事务回滚后,可以继续联系该组下的另外一个生产者实例,不至于导致业务走不下去。
Topic(主题):可理解为消息的一级目录,目的是能够把同一业务的消息归类。
Tag(标签):可理解为消息的二级目录,能够对同一业务模块下的不同目的的消息再次分类。
发送方式
生产者步骤
- 创建消息生产者producer,并制定生产者组名
- 指定Nameserver地址
- 启动producer
- 创建消息对象,指定主题Topic、Tag和消息体
- 发送消息
- 关闭生产者producer
1)同步消息
同步消息指,消息发送后会等待broker响应,接收到响应结果后再发送下一条,一般用于对消息可靠性要求较高的场景,例如短信通知。
public class SyncProducer {
public static void main(String[] args) throws Exception {
// 1.创建消息生产者producer,并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("group1");
// 2.指定Nameserver地址
producer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
// 3.启动producer
producer.start();
for (int i = 0; i < 10; i++) {
// 4.创建消息对象,指定主题Topic、Tag和消息体
Message msg = new Message("base", "tag1", ("Sync msg-" + i).getBytes());
// 5.发送同步消息
SendResult result = producer.send(msg);
System.out.println("发送状态:" + result);
System.out.println("消息ID:" + result.getMsgId());
System.out.println("队列ID:" + result.getMessageQueue().getQueueId());
}
// 6.关闭生产者producer
producer.shutdown();
}
}
运行结果
2)异步消息
异步消息,消息发送后不会等待broker响应,而是在其回调函数中接收。用于发送端不能容忍长时间等待broker响应的场景。
public class AsyncProducer {
public static void main(String[] args) throws Exception {
// 1.创建消息生产者producer,并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("group1");
// 2.指定Nameserver地址
producer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
// 3.启动producer
producer.start();
for (int i = 0; i < 10; i++) {
// 4.创建消息对象,指定主题Topic、Tag和消息体
Message msg = new Message("base", "tag2", ("Async msg-" + i).getBytes());
// 5.发送异步消息,并传递一个回调的匿名对象
producer.send(msg, new SendCallback() {
// 消息发送成功的回调
@Override
public void onSuccess(SendResult sendResult) {
System.out.println("发送状态:" + sendResult.getSendStatus());
System.out.println("消息ID:" + sendResult.getMsgId());
System.out.println("队列ID:" + sendResult.getMessageQueue().getQueueId());
}
// 消息发送失败的回调
@Override
public void onException(Throwable throwable) {
System.out.println(throwable);
}
});
}
// 由于是异步,防止消息未发送完生产者就关闭了
Thread.sleep(5000);
producer.shutdown();
}
}
值得注意的是,让主线程睡眠是为了防止生产者提前关闭,否则可能会抛出"The producer service state not OK, SHUTDOWN_ALREADY","No route info of this topic, xxx"
3)单向消息
一般用于不关心发送结果的场景,例如日志发送
public class OnewayProducer {
public static void main(String[] args) throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("group1");
producer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
producer.start();
for (int i = 0; i < 10; i++) {
// 4.创建消息对象,指定主题Topic、Tag和消息体
Message msg = new Message("base", "tag3", ("Oneway msg" + i).getBytes());
// 5.发送单向消息
producer.sendOneway(msg);
}
// 6.关闭生产者producer
producer.shutdown();
}
}
接收方式
消费者步骤
- 创建消费者Consumer,制定消费者组名
- 指定Nameserver地址
- 订阅主题Topic和Tag
- 设置回调函数,处理消息
- 启动消费者consumer
1)负载均衡
负载均衡模式是消息消费的默认模式,多个消费者消费队列消息,每个消费者处理的消息不同
public class Comsumer {
public static void main(String[] args) throws Exception {
// 创建消费者Consumer,制定消费者组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
// 指定Nameserver地址
consumer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
// 订阅主题Topic和Tag
consumer.subscribe("base", "tag1");
// 设置消费模式负载均衡(不设置也是默认)
consumer.setMessageModel(MessageModel.CLUSTERING);
// 设置匿名内部类,处理消息
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
list.forEach(item -> {
System.out.println(new String(item.getBody()));
});
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
// 启动消费者consumer
consumer.start();
}
}
结果可以看到不同消费者消费的消息
2)广播模式
广播模式与负载均衡相反,每个消费者消费到的消息是相同的,只需要设置消费者的模式为
consumer.setMessageModel(MessageModel.BROADCASTING);
顺序消息
消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序,可以分为分区有序或者全局有序。
有读者可能会问,消息队列本身就是FIFO(先进先出),为何还要保证顺序。是因为,消费者将消息发送至broker中后,会采用Round Robin 轮询的方式,把消息存储到不同的消息队列中。而消费者会同时从多个消息队列拉取消息。这时如果多个消息具有连续性,例如订单的(创建→付款→推送→完成)这四个消息的顺序就不能保证一致。
要解决这个问题,就必须让同一订单的消息发送至同一个队列,消费者也只消费这一个队列(单线程)即可。当发送和消费参与的queue只有一个,则是全局有序;如果多个queue参与,则为分区有序,即相对每个queue,消息都是有序的。
订单类
下面的例子以订单流程为基础,一个完整订单有四个消息(创建→付款→推送→完成),订单号相同的消息被先后发送至同一个队列。
public class Order {
private int orderId; // 订单号
private String desc; // 内容
// 省略get/set,构造方法
@Override
public String toString() {
return "Order{" +
"orderId=" + orderId +
", desc='" + desc + '\'' +
'}';
}
public List<Order> buildOrders() {
List<Order> orderList = new ArrayList<Order>();
Order orderDemo = new Order(1, "创建");
orderList.add(orderDemo);
orderDemo = new Order(2, "创建");
orderList.add(orderDemo);
orderDemo = new Order(1,"付款");
orderList.add(orderDemo);
orderDemo = new Order(3, "创建");
orderList.add(orderDemo);
orderDemo = new Order(2, "付款");
orderList.add(orderDemo);
orderDemo = new Order(3, "付款");
orderList.add(orderDemo);
orderDemo = new Order(2, "完成");
orderList.add(orderDemo);
orderDemo = new Order(1, "推送");
orderList.add(orderDemo);
orderDemo = new Order(3, "完成");
orderList.add(orderDemo);
orderDemo = new Order(1, "完成");
orderList.add(orderDemo);
return orderList;
}
}
生产者
生产者要做的事通过订单id的不同,为消息指定送往的消息队列
public class OrderProducer {
public static void main(String[] args) throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("group1");
producer.setNamesrvAddr("192.168.1.1:9876");
producer.start();
// 构建出消息集合
List<Order> orderList = new Order().buildOrders();
for (Order order : orderList) {
Message msg = new Message("orderTopic", "order", order.toString().getBytes());
/**
* 参数一:消息对象
* 参数二:消息队列选择器
* 参数三:选择队列的业务标识
*/
SendResult result = producer.send(msg, new MessageQueueSelector() {
/**
*
* @param list 消息队列集合
* @param message 消息
* @param o 业务标识(send方法传递的标识,会在这个方法接收到)
* @return
*/
@Override
public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
int orderId = (int) o;
int index = 0;
// 根据id选择不同的索引用于消息队列集合
switch (orderId) {
case 1:
index = 0;
break;
case 2:
index = 1;
break;
case 3:
index = 2;
break;
}
// 返回的结果是要选择的消息队列
return list.get(index);
}
}, order.getOrderId()); // 这里是send方法第三个参数
}
producer.shutdown();
}
}
消费者
消费者需要将消费消息的匿名内部类由MessageListenerConcurrently改为MessageListenerOrderly。
public class OrderConsumer {
public static void main(String[] args) throws Exception {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
consumer.setNamesrvAddr("192.168.1.1:9876");
consumer.subscribe("orderTopic", "order");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
list.forEach(msg -> {
// 可以看到一个consume线程只消费一个queue, 订单对每个queue(分区)有序
System.out.println("【" + Thread.currentThread().getName() + "】从消息队列id为" + msg.getQueueId() + "消费了:" + new String(msg.getBody()));
});
return ConsumeOrderlyStatus.SUCCESS;
}
});
consumer.start();
System.out.println("消费者启动");
}
}
从结果可以看出,每个订单的流程顺序是正确的,达到了分区有序。且一个线程只会消费一个队列里的消息。