RocketMQ（二）

2024-03-17 16:01:04

消息发送样例

  • 导入MQ客户端依赖
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.7.1</version>
</dependency>
  • 消息发送者步骤分析
1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者producer
  • 消息生产者步骤分析
1.创建消费者Consumer，制定消费者组名
2.指定Nameserver地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer

基本样例

发送消息

发送同步消息

这种可靠性同步发送方式使用比较广泛，比如：重要的消息通知、短信通知。

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        //1. 创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.135:9876");
        //3. 启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("TopicA","TagA", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            //5. 发送消息
            SendResult sendResult = producer.send(msg);
            System.out.printf("%s%n", sendResult); //通过sendResult返回消息是否成功送达

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 关闭生产者producer
        producer.shutdown();
    }
}

发送异步消息

异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待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.56.134:9876;192.168.56.135:9876");
        //3. 启动producer
        producer.start();

        producer.setRetryTimesWhenSendAsyncFailed(0);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            //4. 创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("TopicA", "TagB", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));

            //5. 发送异步消息
            producer.send(msg, new SendCallback() { 
                //SendCallback接收异步返回结果的回调
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.printf("%-10d 0K%s%n", index, sendResult);
                }

                @Override
                public void onException(Throwable e) {
                    System.out.printf("%-10d Exception%s%n", index, e);
                    e.printStackTrace();
                }
            });

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 关闭生产者producer
        producer.shutdown();
    }
}

发送单向消息

public class OneWayProducer {
    public static void main(String[] args) throws Exception {
        //1. 创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("TopicA", "TagA", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            //5. 发送单向消息
            producer.sendOneway(msg);

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 关闭生产者producer
        producer.shutdown();
    }
}

消费消息

负载均衡模式

默认的消费模式，多个消费者共同消费队列消息，每个消费者处理的消息不同。

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("TopicA", "TagA || TagB");//消费全部tag可以用*
        //设置消费模式：负载均衡|广播
        consumer.setMessageModel(MessageModel.CLUSTERING);
        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list)
                    System.out.println(new String(msg.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
    }
}

广播模式

每个消费者消费的消息是相同的。

consumer.setMessageModel(MessageModel.BROADCASTING);

顺序消息

消息有序指的是可以按照消息的发送顺序来消费（FIFO）。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。
顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue（分区队列）；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。
下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个Orderld获取到的肯定是同一个队列。

生产者

public class Producer {
    public static void main(final String[] args) throws Exception {
        //1. 创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 启动producer
        producer.start();

        //创建消息集合
        List<OrderStep> orderSteps = OrderStep.buildOrders();
        for (int i = 0; i < orderSteps.size(); i++) {
            String body = JSON.toJSONString(orderSteps.get(i));
            //4. 创建消息对象，指定主题topic、tags、keys、消息体
            Message message = new Message("OrderTopic", "OrderTag", "key" + i, body.getBytes());
            /**
             * 5. 发送消息
             *
             * 参数一：消息对象
             * 参数二：消息队列的选择器
             * 参数三：选择队列的业务标识（订单ID）
             */
            SendResult sendResult = producer.send(message, new MessageQueueSelector() {
                /**
                 * @param list 队列集合
                 * @param message 消息对象
                 * @param o 业务标识的参数
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    Long orderId = (Long) o;
                    long index = orderId % list.size();
                    return list.get((int) index);
                }
            }, orderSteps.get(i).getOrderId());
            System.out.println("发送结果：" + sendResult);
        }

        //6. 关闭生产者producer
        producer.shutdown();
    }
}

消费者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("OrderTopic", "*");//消费全部tag可以用*
        //4.注册消息监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                for (MessageExt msg : list) {
                    System.out.println("线程名称：【" + Thread.currentThread().getName() + "】，消费消息：" + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");
    }
}

延时消息

比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        //1. 创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("DelayTopic", "TagA", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            msg.setDelayTimeLevel(2);
            //5. 发送消息
            SendResult sendResult = producer.send(msg);
            System.out.println("发送结果：" + sendResult);

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 关闭生产者producer
        producer.shutdown();
    }
}

使用限制

//org/apache/rocketmq/store/config/MessagestoreConfig.java 
private string messageDelayleve1 = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2th";

不支持任意时间的延时，需要设置几个固定的延时等级，从1s到2h分别对应1到18等级。

批量消息

批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。此外，这一批消息的总大小不应超过4MB。

发送批量消息

每次发送不超过4MB的消息，样例如下：

//4. 创建消息对象，指定主题Topic、Tag和消息体
List<Message> msgs = new ArrayList<Message>();
Message msg1 = new Message("BatchTopic", "TagA", ("Hello RocketMQ" + 1).getBytes());
Message msg2 = new Message("BatchTopic", "TagA", ("Hello RocketMQ" + 2).getBytes());
Message msg3 = new Message("BatchTopic", "TagA", ("Hello RocketMQ" + 3).getBytes());
msgs.add(msg1);
msgs.add(msg2);
msgs.add(msg3);

//5. 发送消息
SendResult sendResult = producer.send(msgs);
System.out.println("发送结果：" + sendResult);

如果消息的总长度可能大于4MB，最好把消息进行分割：

public class ListSplitter implements Iterator<List<Message>> {
    private final int SIZE_LIMIT = 1024 * 1024 * 4;
    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;//增加日志的开销20字节
            if (tmpSize > SIZE_LIMIT) {
                //单个消息超过了最大的限制
                //忽略,否则会阻塞分裂的进程
                if (nextIndex - currIndex == 0) {
                    //假如下一个子列表没有元素,则添加这个子列表然后退出循环,否则只是退出循环
                    nextIndex++;
                }
                break;
            }
            if (tmpSize + totalSize > SIZE_LIMIT) {
                break;
            } else {
                totalSize += tmpSize;
            }
        }
        List<Message> subList = messages.subList(currIndex, nextIndex);
        currIndex = nextIndex;
        return subList;
    }
}

过滤消息

Tag方式

SQL语法方式

SQL基本语法

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

  • 数值比较，比如：>，>=，<，<=，BETWEEN，=；
  • 字符比较，比如：=，<>，IN；
  • IS NULL或者IS NOT NULL；
  • 逻辑符号AND，OR，NOT；

常量支持类型为：

  • 数值，比如：123，3.1415；
  • 字符，比如：'abc'，必须用单引号包裹起来；
  • NULL，特殊的常量
  • 布尔值，TRUE或FALSE

只有使用push模式的消费者才能用使用SQL92标准的sql语句，接口如下：

public void subscribe（finalstring topic，final Messageselector messageselector）

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        //1. 创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("FilterSQLTopic", "Tag1", ("Hello RocketMQ" + i).getBytes());
            msg.putUserProperty("i", String.valueOf(i));

            //5. 发送消息
            SendResult sendResult = producer.send(msg);
            System.out.println("发送结果：" + sendResult);

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 关闭生产者producer
        producer.shutdown();
    }
}

消费者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("FilterSQLTopic", MessageSelector.bySql("i>5"));

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list)
                    System.out.println(new String(msg.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");
    }
}

事务消息

流程分析

RocketMQ（二）

上图说明了事务消息的大致方案，其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。

1）事务消息发送及提交

  1. 发送消息（half消息）
  2. 服务端响应消息写入结果
  3. 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）
  4. 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）

2）事务补偿

  1. 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一-次"回查”
  2. Producer收到回查消息，检查回查消息对应的本地事务的状态
  3. 根据本地事务状态，重新Commit或者 Rollback其中，补偿阶段用于解决消息Commit或者Rollback发生超时或者失败的情况。

3）事务消息状态

事务消息共有三种状态，提交状态、回滚状态、中间状态：

  • TransactionStatus.CommitTransaction：提交事务，它允许消费者消费此消息
  • TransactionStatus.RollbackTransaction：回滚事务，它代表该消息将被删除，不允许被消费
  • TransactionStatus.Unknown：中间状态，它代表需要检查消息队列来确定状态

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        //1. 创建消息生产者producer，并制定生产者组名
        TransactionMQProducer producer = new TransactionMQProducer("group2");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");

        //添加事务监听器
        producer.setTransactionListener(new TransactionListener() {
            /**
             * 本地事务
             * @param message
             * @param o
             * @return
             */
            @Override
            public LocalTransactionState executeLocalTransaction(Message message, Object o) {
                if (StringUtils.equals("TagA", message.getTags())) {
                    return LocalTransactionState.COMMIT_MESSAGE;
                } else if (StringUtils.equals("TagB", message.getTags())) {
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                } else {
                    return LocalTransactionState.UNKNOW;
                }
            }

            /**
             * 回查
             * @param messageExt
             * @return
             */
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
                System.out.println("回查消息的tag：" + messageExt.getTags());
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });

        //3. 启动producer
        producer.start();

        String[] tags = {"TagA", "TagB", "TagC"};
        for (int i = 0; i < 3; i++) {
            //4. 创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("TransactionTopic", tags[i], ("Hello RocketMQ" + i).getBytes());
            //5. 发送消息
            SendResult sendResult = producer.sendMessageInTransaction(msg, null);//事务可以应用到一个消息上面，也可以应用到整个producer上面，null表示整个producer
            System.out.println("发送结果：" + sendResult);

            TimeUnit.SECONDS.sleep(2);
        }

        //6. 关闭生产者producer
        //producer.shutdown();关闭producer就没法回查了
    }
}

消费者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group2");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("TransactionTopic", "*");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list)
                    System.out.println(new String(msg.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");
    }
}
上一篇：设计消息中间件时我关心什么?(解密电商数据一致性与完整性实现,含PPT)（转发）


下一篇：AOP中实现动态代理的两种方式