说说 MQ 之 RocketMQ ( 二 )

最新推荐文章于 2024-05-12 23:39:30 发布
最新推荐文章于 2024-05-12 23:39:30 发布
阅读量363 收藏
点赞数
分类专栏： kafa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjq008/article/details/83054031
版权

RocketMQ 的 Java API

 

RocketMQ 是用 Java 语言开发的，因此，其 Java API 相对是比较丰富的，当然也有部分原因是 RocketMQ 本身提供的功能就比较多。RocketMQ API 提供的功能包括，

 

  1. 广播消费，这个在之前已经提到过；

  2. 消息过滤，支持简单的 Message Tag 过滤，也支持按 Message Header、body 过滤；

  3. 顺序消费和乱序消费，之前也提到过，这里的顺序消费应该指的是普通顺序性，这一点与 Kafka 相同；

  4. Pull 模式消费，这个是相对 Push 模式来说的，Kafka 就是 Pull 模式消费；

  5. 事务消息，这个好像没有开源，但是 example 代码中有示例，总之，不推荐用；

  6. Tag，RocketMQ 在 Topic 下面又分了一层 Tag，用于表示消息类别，可以用来过滤，但是顺序性还是以 Topic 来看；

 

单看功能的话，即使不算事务消息，也不算 Tag，RocketMQ 也远超 Kafka，Kafka 应该只实现了 Pull 模式消费 + 顺序消费这2个功能。RocketMQ 的代码示例在 rocketmq-example 中，注意，代码是不能直接运行的，因为所有的代码都少了设置 name server 的部分，需要自己手动加上，例如，producer.setNamesrvAddr("192.168.232.23:9876");。

 

先来看一下生产者的 API，比较简单，只有一种，如下，

 

import com.alibaba.rocketmq.client.exception.MQClientException;

import com.alibaba.rocketmq.client.producer.DefaultMQProducer;

import com.alibaba.rocketmq.client.producer.MessageQueueSelector;

import com.alibaba.rocketmq.client.producer.SendResult;

import com.alibaba.rocketmq.common.message.Message;

import com.alibaba.rocketmq.common.message.MessageQueue;

import java.util.List;

public class Producer {

    public static void main(String[] args) throws MQClientException, InterruptedException {

        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");

        producer.setNamesrvAddr("192.168.232.23:9876");

        producer.start();

        for (int i = 0; i < 10; i++)

            try {

                {

                    Message msg = new Message("TopicTest1",// topic

                        "TagA",// tag

                        "OrderID188",// key

                        ("RocketMQ "+String.format("%05d", i)).getBytes());// body

                    SendResult sendResult = producer.send(msg, new MessageQueueSelector() {

                        @Override

                        public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {

                            Integer id = (Integer) arg;

                            int index = id % mqs.size();

                            return mqs.get(index);

                        }

                    }, i));

                    System.out.println(String.format("%05d", i)+sendResult);

                }

            }

            catch (Exception e) {

                e.printStackTrace();

            }

        producer.shutdown();

    }

}

 

可以发现，相比 Kafka 的 API，只多了 Tag，但实际上行为有很大不同。Kafka 的生产者客户端，有同步和异步两种模式，但都是阻塞模式，send 方法返回发送状态的 Future，可以通过 Future 的 get 方法阻塞获得发送状态。而 RocketMQ 采用的是同步非阻塞模式，发送之后立刻返回发送状态（而不是 Future）。正常情况下，两者使用上差别不大，但是在高可用场景中发生主备切换的时候，Kafka 的同步可以等待切换完成并重连，最后返回；而 RocketMQ 只能立刻报错，由生产者选择是否重发。所以，在生产者的 API 上，其实 Kafka 是要强一些的。

 

另外，RocketMQ 可以通过指定 MessageQueueSelector 类的实现来指定将消息发送到哪个分区去，Kafka 是通过指定生产者的 partitioner.class 参数来实现的，灵活性上 RocketMQ 略胜一筹。

 

再来看消费者的API，由于 RocketMQ 的功能比较多，我们先看 Pull 模式消费的API，如下，

 

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import com.alibaba.rocketmq.client.consumer.DefaultMQPullConsumer;

import com.alibaba.rocketmq.client.consumer.PullResult;

import com.alibaba.rocketmq.client.consumer.store.OffsetStore;

import com.alibaba.rocketmq.client.consumer.store.RemoteBrokerOffsetStore;

import com.alibaba.rocketmq.client.exception.MQClientException;

import com.alibaba.rocketmq.common.message.MessageExt;

import com.alibaba.rocketmq.common.message.MessageQueue;

public class PullConsumer {

    private static final Map<MessageQueue, Long> offseTable = new HashMap<MessageQueue, Long>();

    public static void main(String[] args) throws MQClientException {

        DefaultMQPullConsumer consumer = new DefaultMQPullConsumer("please_rename_unique_group_name_5");

        consumer.setNamesrvAddr("192.168.232.23:9876");

        consumer.start();

        Set<MessageQueue> mqs = consumer.fetchSubscribeMessageQueues("TopicTest1");

        for (MessageQueue mq : mqs) {

            System.out.println("Consume from the queue: " + mq);

            SINGLE_MQ: while (true) {

                try {

                    long offset = consumer.fetchConsumeOffset(mq, true);

                    PullResult pullResult =

                            consumer.pullBlockIfNotFound(mq, null, getMessageQueueOffset(mq), 32);

                    if (null != pullResult.getMsgFoundList()) {

                        for (MessageExt messageExt : pullResult.getMsgFoundList()) {

                            System.out.print(new String(messageExt.getBody()));

                            System.out.print(pullResult);

                            System.out.println(messageExt);

                        }

                    }

                    putMessageQueueOffset(mq, pullResult.getNextBeginOffset());

                    switch (pullResult.getPullStatus()) {

                    case FOUND:

                        // TODO

                        break;

                    case NO_MATCHED_MSG:

                        break;

                    case NO_NEW_MSG:

                        break SINGLE_MQ;

                    case OFFSET_ILLEGAL:

                        break;

                    default:

                        break;

                    }

                }

                catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

        consumer.shutdown();

    }

    private static void putMessageQueueOffset(MessageQueue mq, long offset) {

        offseTable.put(mq, offset);

    }

    private static long getMessageQueueOffset(MessageQueue mq) {

        Long offset = offseTable.get(mq);

        if (offset != null)

            return offset;

        return 0;

    }

}

 

这部分的 API 其实是和 Kafka 很相似的，唯一不同的是，RocketMQ 需要手工管理 offset 和指定分区，而 Kafka 可以自动管理（当然也可以手动管理），并且不需要指定分区（分区是在 Kafka 订阅的时候指定的）。例子中，RocketMQ 使用 HashMap 自行管理，也可以用 OffsetStore 接口，提供了两种管理方式，本地文件和远程 Broker。这部分感觉两者差不多。

 

下面再看看 Push 模式顺序消费，代码如下，

 

import java.util.List;

import java.util.concurrent.atomic.AtomicLong;

import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;

import com.alibaba.rocketmq.client.consumer.listener.ConsumeOrderlyContext;

import com.alibaba.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;

import com.alibaba.rocketmq.client.consumer.listener.MessageListenerOrderly;

import com.alibaba.rocketmq.client.exception.MQClientException;

import com.alibaba.rocketmq.common.consumer.ConsumeFromWhere;

import com.alibaba.rocketmq.common.message.MessageExt;

public class Consumer {

    public static void main(String[] args) throws MQClientException {

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_3");

        consumer.setNamesrvAddr("192.168.232.23:9876");

        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

        consumer.subscribe("TopicTest1", "TagA || TagC || TagD");

        consumer.registerMessageListener(new MessageListenerOrderly() {

            AtomicLong consumeTimes = new AtomicLong(0);

            @Override

            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {

                context.setAutoCommit(false);

                System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

                this.consumeTimes.incrementAndGet();

                if ((this.consumeTimes.get() % 2) == 0) {

                    return ConsumeOrderlyStatus.SUCCESS;

                }

                else if ((this.consumeTimes.get() % 3) == 0) {

                    return ConsumeOrderlyStatus.ROLLBACK;

                }

                else if ((this.consumeTimes.get() % 4) == 0) {

                    return ConsumeOrderlyStatus.COMMIT;

                }

                else if ((this.consumeTimes.get() % 5) == 0) {

                    context.setSuspendCurrentQueueTimeMillis(3000);

                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;

                }

                return ConsumeOrderlyStatus.SUCCESS;

            }

        });

        consumer.start();

        System.out.println("Consumer Started.");

    }

}

 

虽然提供了 Push 模式，RocketMQ 内部实际上还是 Pull 模式的 MQ，Push 模式的实现应该采用的是长轮询，这点与 Kafka 一样。使用该方式有几个注意的地方，

 

  1. 接收消息的监听类要使用 MessageListenerOrderly；

  2. ConsumeFromWhere 有几个参数，表示从头开始消费，从尾开始消费，还是从某个 TimeStamp 开始消费；

  3. 可以控制 offset 的提交，应该就是 context.setAutoCommit(false); 的作用；

 

控制 offset 提交这个特性非常有用，某种程度上扩展一下，就可以当做事务来用了，看代码 ConsumeMessageOrderlyService 的实现，其实并没有那么复杂，在不启用 AutoCommit 的时候，只有返回 COMMIT 才 commit offset；启用 AutoCommit 的时候，返回 COMMIT、ROLLBACK（这个比较扯）、SUCCESS 的时候，都 commit offset。

 

后来发现，commit offset 功能在 Kafka 里面也有提供，使用新的 API，调用 consumer.commitSync。

 

再看一个 Push 模式乱序消费 + 消息过滤的例子，消费者的代码如下，

 

import java.util.List;

import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;

import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;

import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;

import com.alibaba.rocketmq.client.consumer.listener.MessageListenerConcurrently;

import com.alibaba.rocketmq.client.exception.MQClientException;

import com.alibaba.rocketmq.common.message.MessageExt;

public class Consumer {

    public static void main(String[] args) throws InterruptedException, MQClientException {

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupNamecc4");

        consumer.setNamesrvAddr("192.168.232.23:9876");

        consumer.subscribe("TopicTest1", MessageFilterImpl.class.getCanonicalName());

        consumer.registerMessageListener(new MessageListenerConcurrently() {

            @Override

            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,

                    ConsumeConcurrentlyContext context) {

                System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

            }

        });

        consumer.start();

        System.out.println("Consumer Started.");

    }

}

 

这个例子与之前顺序消费不同的地方在于，

 

  1. 接收消息的监听类使用的是 MessageListenerConcurrently；

  2. 回调方法中，使用的是自动 offset commit；

  3. 订阅的时候增加了消息过滤类 MessageFilterImpl；

 

消息过滤类 MessageFilterImpl 的代码如下，

 

import com.alibaba.rocketmq.common.filter.MessageFilter;

import com.alibaba.rocketmq.common.message.MessageExt;

public class MessageFilterImpl implements MessageFilter {

    @Override

    public boolean match(MessageExt msg) {

        String property = msg.getUserProperty("SequenceId");

        if (property != null) {

            int id = Integer.parseInt(property);

            if ((id % 3) == 0 && (id > 10)) {

                return true;

            }

        }

        return false;

    }

}

 

RocketMQ 执行过滤是在 Broker 端，Broker 所在的机器会启动多个 FilterServer 过滤进程；Consumer 启动后，会向 FilterServer 上传一个过滤的 Java 类；Consumer 从 FilterServer 拉消息，FilterServer 将请求转发给 Broker，FilterServer 从 Broker 收到消息后，按照 Consumer 上传的 Java 过滤程序做过滤，过滤完成后返回给 Consumer。这种过滤方法可以节省网络流量，但是增加了 Broker 的负担。可惜我没有实验出来使用过滤的效果，即使是用 github wiki 上的例子8也没成功，不纠结了。RocketMQ 的按 Tag 过滤的功能也是在 Broker 上做的过滤，能用，是个很方便的功能。

 

还有一种广播消费模式，比较简单，可以去看代码，不再列出。

 

总之，RocketMQ 提供的功能比较多，比 Kafka 多很多易用的 API。

wjq008
关注
专栏目录
rocketmq 源码 C语言,rocketmq初识
weixin_32349577的博客
05-23 938
概念说明通常一个消息队列需要掌握的知识点有Topic(主体)、Producer(生产者)、Consumer(消费者)、Queue(队列)、Delivery Semantics(消息传递范式)蛋疼的是不同的消息队列关于这些名词叫法不一样，含义也不是很精确。所以阿里起了一个项目OpenMessaging去发起首个分布式消息领域的国际标准。不过好像并没有多少人买账，但这并不妨碍我们按照这个规范去梳理学习...
rocketmq是什么语言写的_RocketMQ设计——低延迟可用性探索
weixin_39916360的博客
11-25 2044
疾风吹征帆，倏尔向空没。千里在俄顷，三江坐超忽。—孟浩然低延迟与可用性随着Java语言生态的完善，JVM性能的提高，C和C++已经不再是低延迟场景唯一的选择。本章节重点介绍RocketMQ在低延迟可用性方面的一些探索。应用程序的性能度量标准一般从吞吐量和延迟两方面考量。吞吐量是指程序在一段时间内能处理的请求数量。延迟是指端到端的响应时间。低延迟在不同的环境下有不同的定义，比如在聊天应用中低延迟可以...
rocketmq（二）
hd20086996的博客
05-31 153
1. 高级功能 1.1 消息存储 分布式队列因为有高可靠性的要求，所以数据要进行持久化存储。 消息生成者发送消息 MQ收到消息，将消息进行持久化，在存储中新增一条记录 返回ACK给生产者 MQ push 消息给对应的消费者，然后等待消费者返回ACK 如果消息消费者在指定时间内成功返回ack，那么MQ认为消息消费成功，在存储中删除消息，即执行第6步；如果MQ在指定时间内没有收到ACK，则认为消息消费失败，会尝试重新push消息,重复执行4、5、6步骤 MQ删除消息 1.1.1 存储介质 关系型数据库
RocketMQ二（工作原理:消费的生产、存储、消费、indexFile）
lxsxkf的博客
09-13 460
3. RocketMQ工作原理 3.1 消息的生产 消息的生产过程 Producer可以将消息写入到某Broker中的某Queue中，其经历了如下过程： Producer发送消息之前，会先向NameServer发出获取消息Topic的路由信息的请求 NameServer返回该Topic的路由表及Broker列表 Producer根据代码中指定的Queue选择策略，从Queue列表中选出一个队列，用于后续存储消息 Produer对消息做一些特殊处理，例如，消息本身超过4M，则会对其进行压缩 Producer
rocketMQ之二 安装
weixin_42672777的博客
01-04 176
安装 下载 http://rocketmq.apache.org/dowloading/releases/ 安装 把下载的安装包扔到自己的虚拟机上,解压 目录介绍 bin:启动的脚本,包括shell脚本和CMD脚本 conf:配制文件,包括broker配置文件 lib:依赖的jar包,Netty,commons-lang,FastJson等 启动MQ 启动NameServer 启...
RocketMQ—（总结）一篇就搞懂 RocketMQ
Netty711的博客
09-21 549
rocketMq 作为低延迟、高并发、高可用、高可靠的分布式消息中间件，其详细知识点非常多，如需深入，建议源码入坑。【这里想说，因为自己也走了很多弯路过来的，所以才下定决心整理，收集过程虽不易，但想到能帮助到一部分自学java 的人，心里也是甜的！有需要的伙伴请点㊦方】↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓。
消息队列之RocketMQ常见面试题
KangJinXuan的博客
09-05 336
消息队列之RocketMQ常见面试题
RocketMQ
qq_43581919的博客
12-09 776
标题RocketMQ基础面试题 一.首先你要知道MQ解决了你们系统中的哪些问题？ 答： 1、支付订单流程中步骤过多，订单系统完成核心的步骤，发送消息到MQ，其他的服务从MQ获取消息，执行比较耗时的操作。 2、退款失败问题，订单支付系统完成公司系统内部业务的核心流程，发送消息到MQ，使用一个专门的系统区处理和第三方支付系统的交互。 3、大促时，大量下单请求放到MQ，订单系统以合适的速度消费消息，处理相关业务 对于我的项目而言，我的项目比较简单，有个订单系统，订单系统会每次下一个新的订单的时候，就会发送时一条消
rocketmq消息获取tag_长文梳理 RocketMQ
weixin_39812224的博客
10-27 2050
RocketMq是什么一个纯Java、分布式队列模型的消息中间件，具有高可用、高可靠、高实时、低延迟的特点。(记住这句就行了)RocketMq有什么功能先答出消息中间件的通用功能1、业务解耦：这也是发布订阅的消息模型。生产者发送指令到MQ中，然后下游订阅这类指令的消费者会收到这个指令执行相应的逻辑，整个过程与具体业务无关，抽象成了一个发送指令，存储指令，消费指令的过程。2、前端削峰：前端...
面试官：RocketMQ 如何保证消息不丢失，如何保证消息不被重复消费？
m0_72885838的博客
08-23 325
Kafka 实际上有个 offset 的概念，就是每个消息写进去，都有一个 offset，代表消息的序号，然后 consumer 消费了数据之后，每隔一段时间（定时定期），会把自己消费过的消息的 offset 提交一下，表示“我已经消费过了，下次我要是重启啥的，你就让我继续从上次消费到的 offset 来继续消费吧”。但是凡事总有意外，比如我们之前生产经常遇到的，就是你有时候重启系统，看你怎么重启了，如果碰到点着急的，直接 kill 进程了，再重启。重启之后，少数消息会再次消费一次。
说说MQ之RocketMQ（一）
Bzwanghao的博客
05-13 264
RocketMQ 是出自 A 公司的开源产品，用 Java 语言实现，在设计时参考了 Kafka，并做出了自己的一些改进，消息可靠性上比 Kafka 更好，目前，RocketMQ 的文档仍然不够丰富 1 2，社区仍然无法与 Kafka 比肩，但 A 公司已经推出了基于 RocketMQ 的云产品 3，相信未来 RocketMQ 也会有不错的发展。本文采用 RocketMQ 3.2.6 进行实验，...
RocketMQ概述
Java_Fly1的博客
02-22 367
RocketMQ概述
RocketMq详解：一、RocketMQ 介绍及基本概念
zhiyikeji的博客
04-28 9000
RocketMQ 是阿里巴巴开源的分布式消息中间件,现已成为 Apache 软件基金会的顶级项目。支持事务消息、顺序消息、批量消息、定时消息、消息回溯等。它里面有几个区别于标准消息中件间的概念，如Group、Topic、Queue等。系统组成则由Producer、Consumer、Broker、NameServer等组件组成。
2024年C C++最全linux nginx 注册服务_env etc init，百度、华为、京东、B站最新面试题汇集
最新发布
2401_84976607的博客
05-12 132
【代码】2024年C C++最全linux nginx 注册服务_env etc init，百度、华为、京东、B站最新面试题汇集。
【消息队列】RocketMQ 快速入门 - 基于go语言调用
Jzin的博客
02-11 2111
RocketMQ 是一个强大的消息中间件，为大规模分布式系统提供高效、可靠和可扩展的消息。
rocketMQ 的简单介绍
dongying1751的博客
12-27 1356
rocketMQ是阿里开源产品，后捐献给了apache成为旗下产品。 rocketMQ是根据amqp协议采用java语言编写的成熟企业级消息产品。 This diagram shows the flow of messages through the AMQ model server: 路由规则：从exchange路由到messageQueue的逻辑： The Direct Excha...
RocketMQ 是什么 专业术语
qq_37754792的博客
03-19 366
RocketMQ 是什么Github 上关于 RocketMQ 的介绍：RcoketMQ 是一款低延迟、高可靠、可伸缩、易于使用的消息中间件。具有以下特性：支持发布/订阅（Pub/Sub）和点对点（P2P）消息模型在一个队列中可靠的先进先出（FIFO）和严格的顺序传递支持拉（pull）和推（push）两种消息模式单一队列百万消息的堆积能力支持多种消息协议，如 JMS、MQTT 等分布式高可用的部署...
RocketMQ简介及核心概念说明
学亮编程手记
02-11 662
1.1、RocketMQ简介 Apache RocketMQ是一个采用Java语言开发的分布式的消息系统，由阿里巴巴团队开发，与2016年底贡献给 Apache，成为了Apache的一个顶级项目。 在阿里内部，RocketMQ 很好地服务了 集 团大大小小上千个应用，在每年的双十一当天，更有不可思议的万亿级 消息通过 RocketMQ 流转(在 2017 年的双十一当天，整个阿里巴巴集团通过 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值