RocketMQ入坑指南（三）：生产者和常用消息类型（含代码示例）

前言

上次分享介绍了Java整合RocketMQ-client的方式，并且简单的了解了生产者生产数据，消费者消费数据的整个流程，这次，我们详细的了解一下生产者和几种消息类别

一、生产者概述

发送消息的一方被称为生产者，我们先了解下几个基础概念

生产者组：一个逻辑概念，在使用生产者实例的时候需要指定一个组名。一个生产者组可以生产多个Topic的消息。

生产者实例：一个生产者组部署了多个进程，每个进程都可以称为一个生产者实例。

Topic：主题名字，一个Topic由若干Queue组成。

RocketMQ 客户端中的生产者有两个独立实现类：

• org.apache.rocketmq.client.producer.DefaultMQProducer
• org.apache.rocketmq.client.producer.TransactionMQProducer。

前者用于生产普通消息、顺序消息、单向消息、批量消息、延迟消息，后者主要

用于生产事务消息

二、RocketMQ五种消息类型

1.普通消息

普通消息也称为并发消息，和传统的队列相比，并发消息没有顺序， 但是生产消费都是并行进行的，单机性能可达十万级别的TPS。

再上一章中介绍的方式就是普通消息，这里就不再重复示例，忘记的小伙伴可以移步复习一下

2.有序消息

与Kafka中的分区类似，把一个Topic消息分为多个分区“保存”和消费，在一个分区内的消息就是传统的队列，遵循FIFO（先进先出）原则。 简单的理解就是把需要按序发送的信息放在同一个队列中。

//创建DefaultMQProducer消息生产者对象
        DefaultMQProducer producer = new DefaultMQProducer("TestProducerGroup");
        //设置NameServer
        producer.setNamesrvAddr("192.168.2.5:9876");
        //设置NameServer节点地址，多个节点间用分号分割
        try {
            //与NameServer建立长连接
            producer.start();
            //设置个集合，集合信息中是要发送订单消息、支付消息、物流消息。要保证相同订单号的在同一个队列
            List<JSONObject> orderInfos = new ArrayList<>();
            JSONObject orderInfo1 = new JSONObject();
            orderInfo1.put("orderId",3347);
            orderInfo1.put("info","我是订单消息");
            orderInfos.add(orderInfo1);
            JSONObject orderInfo2 = new JSONObject();
            orderInfo2.put("orderId",3348);
            orderInfo2.put("info","我是订单消息");
            orderInfos.add(orderInfo2);
            JSONObject orderInfo3 = new JSONObject();
            orderInfo3.put("orderId",3347);
            orderInfo3.put("info","我是订单支付消息");
            orderInfos.add(orderInfo3);
            JSONObject orderInfo4 = new JSONObject();
            orderInfo4.put("orderId",3348);
            orderInfo4.put("info","我是订单支付消息");
            orderInfos.add(orderInfo4);
            JSONObject orderInfo5 = new JSONObject();
            orderInfo5.put("orderId",3347);
            orderInfo5.put("info","我是订单物流消息");
            orderInfos.add(orderInfo5);
            for (JSONObject orderInfo : orderInfos) {
                int orderId = orderInfo.getInteger("orderId");
                Message msg = new Message("TopicOrder", "orderinfo", orderId+"",
                        orderInfo.toJSONString().getBytes());
                SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                    @Override
                    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                        //附加参数 producer.send方法中的第三个参数
                        int id = (Integer) arg;
                        System.out.println("*******************orderId:"+id+"***********************");

                        //和队列总数取余，来决定选择哪个队列，因为相同的订单ID取余的结果是一样的，这样就能保证相同的订单，我们选择的是同一个队列
                        int index = id % mqs.size();
                        MessageQueue messageQueue = mqs.get(index);
                        System.out.println("队列："+messageQueue);
                        return messageQueue;
                    }
                }, orderId);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                producer.shutdown();
            } catch (Exception e) {
            }
        }

执行之后，我们可以看到以下打印消息：

从信息中，我们不难看出，相同ID的信息，我们是通过同一个队列发送的。

3.延迟消息

消息发送后，消费者要在一定时间后，或者指定某个时间点才可以消费。在没有延迟消息时，基本的做法是基于定时计划任务调度，定时发送消息。在RocketMQ中只需要在发送消息时设置延迟级别即可实现。

Apache RocketMQ 一共支持18个等级的延迟投递，具体时间如下：

由于只有固定的18个延迟级别，所以通常我们很少使用这种方式，大部分会通过定时任务去执行，而不是通过延迟消息，所以我们只需要了解一下，写法和普通消息基本一样

//创建DefaultMQProducer消息生产者对象
        DefaultMQProducer producer = new DefaultMQProducer("TestProducerGroup");
        //设置NameServer
        producer.setNamesrvAddr("192.168.2.5:9876");
        //设置NameServer节点地址，多个节点间用分号分割
        try {
            //与NameServer建立长连接
            producer.start();
            JSONObject json = new JSONObject();
            json.put("orderId", "8888");
            json.put("desc", "这是延迟队列测试");
            //数据正文
            String data = json.toJSONString();
            Message message = new Message("TopicOrder", "PAY_TAG", data.getBytes());
            //1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
            message.setDelayTimeLevel(3);//代表延迟10S发送
            //发送消息，获取发送结果
            SendResult result = producer.send(message);
            //将发送结果对象打印在控制台
            System.out.println("发送时间："+ DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
            System.out.println("消息已发送：MsgId:" + result.getMsgId() + "，发送状态:"
                    + result.getSendStatus());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                producer.shutdown();
            } catch (Exception e) {
            }
        }

通过上一节写的示例接受消息并打印时间，可以看到下面的信息

发送方：

接收方：

4.批量消息

在对吞吐率有一定要求的情况下，Apache RocketMQ可以将一些消息聚成一批以后进行发送，可以增加吞吐率，并减少API和网络调用次数。

//创建DefaultMQProducer消息生产者对象
        DefaultMQProducer producer = new DefaultMQProducer("TestProducerGroup");
        //设置NameServer
        producer.setNamesrvAddr("192.168.2.5:9876");
        //设置NameServer节点地址，多个节点间用分号分割
        try {
            //与NameServer建立长连接
            producer.start();
            String topic = "TopicOrder";
            List<Message> messageList = new ArrayList<>();
            for (int i = 1; i < 10; i++) {
                JSONObject json = new JSONObject();
                json.put("orderId", "8888");
                json.put("desc", "测试批量发送");
                //数据正文
                String data = json.toJSONString();
                Message message = new Message(topic, "PAY_TAG", data.getBytes());
                messageList.add(message);
            }
            //发送消息，获取发送结果
            SendResult result = producer.send(messageList);
            //将发送结果对象打印在控制台
            System.out.println("消息已发送：MsgId:" + result.getMsgId() + "，发送状态:"
                    + result.getSendStatus());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                producer.shutdown();
            } catch (Exception e) {
            }
        }

注意：这里调用非常简单，将消息打包成 Collection<Message> msgs 传入方法中即可，需要注意的是批量消息的大小不能超过 1MiB（否则需要自行分割），其次同一批 batch 中 topic 必须相同。

5.事务消息（重要）

主要涉及分布式事务，即需要保证在多个操作同时成功或者同时失败时，消费者才能消费消息。RocketMQ通过发送Half消息、处理本地事务、提交（Commit）消息或者回滚（Rollback）消息实现分布式事务。

事务消息发送分为两个阶段。

第一阶段会发送一个半事务消息，半事务消息是指暂不能投递的消息，生产者已经成功地将消息发送到了 Broker，但是Broker 未收到生产者对该消息的二次确认，此时该消息被标记成“暂不能投递”状态，如果发送成功则执行本地事务，并根据本地事务执行成功与否，向 Broker 半事务消息状态（commit或者rollback），半事务消息只有 commit 状态才会真正向下游投递。

如果由于网络闪断、生产者应用重启等原因，导致某条事务消息的二次确认丢失，Broker 端会通过扫描发现某条消息长期处于“半事务消息”时，需要主动向消息生产者询问该消息的最终状态（Commit或是Rollback）。这样最终保证了本地事务执行成功，下游就能收到消息，本地事务执行失败，下游就收不到消息。总而保证了上下游数据的一致性。

整个事务消息的详细交互流程如下图所示：

例子

发送两个订单信息，一个订单号是6666，一个订单号是8888

6666订单用于测试信息二次确认返回失败，mq信息不会被消费

8888用于测试二次确认失败，broker回调查询成功，mq信息被消费的情况

实现方法

1.新增监听器实现TransactionListener接口，重写方法，一个用来发送半事务二次确认消息，一个用来处理回调查询事务状态

import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;

public class OrderTransactionListenerImpl implements TransactionListener {
    @Override
    public LocalTransactionState executeLocalTransaction(Message message, Object o) {
        String key = message.getKeys();
        if("6666".equals(key)){
            System.out.println("接收到orderId:"+key +"的信息");
            System.out.println("模拟本地执行方法失败的情况");
            //执行本地订单插入方法报错，执行回滚
            return LocalTransactionState.ROLLBACK_MESSAGE;
        }else if ("8888".equals(key)){
            System.out.println("接收到orderId:"+key +"的信息");
            System.out.println("模拟本地方法成功，但是未成功发送确认方法");
            //执行本地方法成功，发送MQ提交确认信息
            return LocalTransactionState.UNKNOW;
        }
        return null;
    }

    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
        String key = messageExt.getKeys();
        if("6666".equals(key)){
            System.out.println("这是回调方法,订单号是："+key);
            return LocalTransactionState.ROLLBACK_MESSAGE;
        }else if ("8888".equals(key)){
            System.out.println("这是回调方法,订单号是："+key);
            System.out.println("订单号:"+key+"的回查成功");
            //执行本地方法成功，发送MQ提交确认信息
            return LocalTransactionState.COMMIT_MESSAGE;
        }
        return null;
    }
}

2.编写producer

 //使用TransactionMQProducer事务生产者创建
        TransactionMQProducer producer = new
                TransactionMQProducer("transaction_producer_group");
        //从NameServer获取配置数据
        producer.setNamesrvAddr("192.168.2.5:9876");
        //定义线程池用于回查本地事务状态
        ExecutorService executorService = new ThreadPoolExecutor(2,
                5,
                100,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(2000), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("check-thread");
                return thread;
            }
        });
        //将生产者与线程池绑定
        producer.setExecutorService(executorService);
        //绑定事务监听器，用于执行代码
        TransactionListener transactionListener = new OrderTransactionListenerImpl();
        producer.setTransactionListener(transactionListener);
        //启动生产者
        try {
            producer.start();
            //定义两条记录模拟事务回滚
            List<JSONObject> orderInfos = new ArrayList<>();
            // 6666的订单模拟发送MQ消息成功，但是本地方法（比如订单插入数据库失败）失败需要回滚的情况
            JSONObject orderInfo1 = new JSONObject();
            orderInfo1.put("orderId", 6666);
            orderInfo1.put("info", "发送MQ消息成功，本地方法失败");
            orderInfos.add(orderInfo1);
            // 8888的订单用来模拟，MQ发送成功，本地方法执行成功，
            // 但是通知MQ确认消息的时候失败，然后又通过MQ回查本地事务又成功的情况
            JSONObject orderInfo2 = new JSONObject();
            orderInfo2.put("orderId", 8888);
            orderInfo2.put("info", "MQ发送成功，本地方法执行成功，再次发送MQ提交信息失败，MQ回查本地事务情况又成功");
            orderInfos.add(orderInfo2);
            for (JSONObject orderInfo : orderInfos) {
                Message message = new Message("TopicOrder", "PAY_TAG",orderInfo.getString("orderId"), orderInfo.toJSONString().getBytes());
                TransactionSendResult result = producer.sendMessageInTransaction(message, null);
                System.out.println("订单号："+orderInfo.getString("orderId")+"的第一次MQ信息发送状态："+result.getSendStatus());
            }
            //用于等待broker的回调
            for (int i = 1; i < 100000; i++) {
                Thread.sleep(1000);
                System.out.println(i+"秒");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                producer.shutdown();
            } catch (Exception e) {
            }
        }

然后我们看一下控制台信息：

生产者：

消费者：

可以看出，订单6666因为二次确认失败，信息无法被消费，而8888虽然二次确认失败，但是通过回调查询还是成功的。所以8888成功被消费。

三、总结

普通消息：性能最好，但是消息的生产和消费是无序的。适用于大部分场景

有序消息：容易出现单点问题，如果broker宕机，会导致发送失败，有序消息场景适用

延迟消息：支持延迟特性，使用非常方便，但是灵活性较低，不能根据任何时间延迟，适用于非精确、延迟级别不多的场景

事务消息：RocketMQ是生产者事务，只有生产者参与，如果消费者处理失败则事务失败，适用于简单事务处理的场景。

接下来将详细的介绍消费者的相关知识

关注我，不迷路