RocketMq基本原理

最新推荐文章于 2024-02-25 21:21:21 发布
最新推荐文章于 2024-02-25 21:21:21 发布
阅读量294 收藏 2
点赞数 1
分类专栏： 消息中间件 文章标签： rabbitmq java kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanlijuan2015/article/details/119935713
版权

一、新建Topic

在管理界面中新建主题Topic1，为了方便观察测试效果，这里把写队列和读队列的数量都设置成3。
在这里插入图片描述
在这里插入图片描述

这样，在 broker-a 和 broker-b 上都创建了 Topic1 主题，并各创建了3写3读队列，共6写6读，如下图所示：
在这里插入图片描述

二、Topic 收发消息原理

生产者将消息发送到 Topic1 的其中一个写队列，消费者从对应的一个读队列接收消息
在这里插入图片描述

1 生产者的负载均衡

生产者以轮询的方式向所有写队列发送消息，这些队列可能会分布在多个broker实例上。
在这里插入图片描述

2 消费者的负载均衡策略

一个 group 中的多个消费者，可以以负载均衡的方式来接收消息。
读取队列被均匀分配给这些消费者，它们从指定的队列来接收消息。队列的分配可以采用不同的策略，

2.1 AllocateMessageQueueAveragely 平均分配（默认策略）

在这里插入图片描述

2.2 AllocateMessageQueueAveragelyByCircle 环形分配

如果使用环形分配，在消费者的代码中需要设置分配策略

consumer.setAllocateMessageQueueStrategy(new AllocateMessageQueueAveragelyByCircle());

0号队列分给0号消费者，所有1号队列分给1号消费者
在这里插入图片描述

2.3 AllocateMessageQueueConsistentHash 一致性哈希

如果使用一致性哈希算法进行分配，在消费者的代码中需要设置分配策略

consumer.setAllocateMessageQueueStrategy(new AllocateMessageQueueConsistentHash());

这种算法依靠一致性哈希算法，看当前消费者可以落到哪个虚拟节点，该虚拟节点对应哪个队列。
详情一致性hash算法点这里

三、NameServer 基本原理

NameServer 是 rocketmq 自己开发的一个轻型注册中心，他的作用相当于是 zk、eureka等，早期版本使用的就是 zookeeper

基本认知

  1. NameServer主要用于存储Topic，Broker关系信息，功能简单，稳定性高
  2. 各个NameServer节点之间不相关，不需要通信，单台宕机不影响其它节点
  3. NameServer集群整体宕机不影响已建立关系的Concumer，Producer，Broker

Broker、Producer、Consumer 与NameServer的通信
4. 每个Borker和所有NameServer保持长连接，心跳间隔为30秒。每次心跳时还会携带当前的Topic信息。当某个Broker两分钟之内没有心跳，则认为该Broker下线，并调整内存中与该Broker相关的Topic信息。
5. Consumer 从 NameServer 获得 Topic 的路由信息，与对应的 Broker 建立长连接。间隔30秒发送心跳至Broker。Broker检查若发现某 Consumer 两分钟内无心跳则认为该Consumer下线，并通知该Consumer所有的消费者集群中的其他实例，触发该消费者集群重新负载均衡。
6. Producer 与消费者一样，也是从 NameServer 获得 Topic 的路由信息，与对应的 Broker 建立长连接，30秒发送一次心跳。Broker 也会认为两分钟内没有心跳的 Producer 下线。

四、RocketMQ原生API收发消息代码

pom.xml文件添加依赖

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.7.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-store</artifactId>
            <version>4.7.1</version>
        </dependency>

1 同步消息

同步消息发送要保证强一致性，发到master的消息向slave复制后，才会向生产者发送反馈信息。
这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
在这里插入图片描述

1.1 生产者

 public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        /**
         * 创建生产着
         * group 相同的生产者成为一个生产者组,标识发送同一类消息的Producer，通常发送逻辑一致。发送普通消息的时候，仅标识使用，并无特别用处
         */
        DefaultMQProducer producer = new DefaultMQProducer("producer1");
        //设置name server,先从注册中心得到broker地址，然后才能连接broker
        producer.setNamesrvAddr("192.168.64.141:9876");
        //启动，连接服务器
        producer.start();
        //消息封装成Message对象,发送消息
        while (true) {
            System.out.print("输入消息：");
            String s = new Scanner(System.in).nextLine();
            /**
             * 主题Topic1相当于是消息的分类, 一类消息使用一个主题
             * Topic1---相当于一级分类
             * Tag1---相当于二级分类,在一个主题下, 可以通过 tag 再对消息进行分类
             * org.apache.rocketmq.common.message.Message
             */
            Message message = new Message("Topic1", "Tag1", s.getBytes());//一级分类, 二级分类, 消息内容
            SendResult send = producer.send(message);// 发送消息后会得到服务器反馈, 包含: smsgId, sendStatus, queue, queueOffset, offsetMsgId
            System.out.println(send);
        }
    }

1.2 消费者

public static void main(String[] args) throws MQClientException {
        /**
         * 创建消费者
         * 消费者有两种模式：
         *    push 模式由服务器主动向消费者发送消息
         *    pull pull 模式由消费者主动向服务器请求消息, 在消费者处理能力有限时，为了减轻消费者的压力，可以采用pull模式。多数情况下都采用 pull 模式。
         *
         * consumer1标识一类Consumer的集合名称，这类Consumer通常消费一类消息，且消费逻辑一致。 同一个Consumer Group下的各个实例将共同消费topic的消息，起到负载均衡的作用。
         *
         * 消费进度以Consumer Group为粒度管理，不同Consumer Group之间消费进度彼此不受影响，即消息A被Consumer Group1消费过，也会再给Consumer Group2消费。
         * 注： RocketMQ要求同一个Consumer Group的消费者必须要拥有相同的注册信息，即必须要听一样的topic(并且tag也一样)。
         */
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer1");
        //设置name server
        consumer.setNamesrvAddr("192.168.64.141:9876");
        /**
         * 消费者需要向 NameServer 询问 Topic 的路由信息。
         * 从哪里订阅(接收)消息
         * 标签：
         *   Tag1  只接收Tag1标签
         *   Tag1 || Tag2 || Tag3  Tag1,Tag2,Tag3标签都可以接收
         *   * 可以接收所有标签
         */
        consumer.subscribe("Topic1", "Tag1");
        /**
         * 处理消息的监听器
         * Concurrently 会启动多个线程，并发的处理消息
         */
        consumer.setMessageListener((MessageListenerConcurrently) (list, consumeConcurrentlyContext) -> {
            for(MessageExt msg:list){
                System.out.println("收到消息："+new String(msg.getBody()));
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;//返回 RECONSUME_LATER 服务器重新发送
        });
        //启动消费者
        consumer.start();
    }

2 延时消息

消息发送到 Rocketmq 服务器后， 延迟一定时间再向消费者进行投递
使用场景：提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存
生产者发送消息时，仅仅需要对消息进行延时设置，其余代码与同步消息一样

msg.setDelayTimeLevel(3);

其中 3 代表级别而不是一个具体的时间值，级别和延时时长对应关系是在 MessageStoreConfig 类种进行定义的：

this.messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
              #级别次数是=1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

注：设置消息的延迟时间，不支持任意的时间,只支持18个固定的延迟时长

3 顺序消息

特点：
7. 同一组有序的消息序列，会被发送到同一个队列，按照 FIFO 的方式进行处理
8. 一个队列只允许一个消费者线程接收消息，这样就保证消息按顺序被接收
在这里插入图片描述

3.1 生产者

    /**
     * 一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中。消费时，从同一个队列接收同一个订单的消息。
     * 以下消息, 相同id的消息按顺序发送到同一个队列,消费时也从同一个队列按顺序消费
     */
    static String[] msgs = { "15103111039,创建","15103111065,创建","15103111039,付款", "15103117235,创建","15103111065,付款",
            "15103117235,付款","15103111065,完成","15103111039,推送","15103117235,完成","15103111039,完成"};
            
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //生产者
        DefaultMQProducer producer = new DefaultMQProducer("producer2");
        //设置name server
        producer.setNamesrvAddr("192.168.64.141:9876");
        //启动，连接服务器
        producer.start();
        //遍历订单消息，发送消息，设置队列选择器
        for (String s : msgs) {
            Long orderId = Long.valueOf(s.split(",")[0]);
            Message message = new Message("Topic2", s.getBytes());
            /**
             * producer.send(msg,队列选择器MessageQueueSelector，选择依据), 第三个参数会传递到queueSelector, 作为它的第三个参数
             * 三个参数的含义: queueList: 当前Topic中所有队列的列表
             *               message: 消息
             *               o: send()方法传入的orderId
             */
            SendResult sendResult = producer.send(message, (mqs, message1, o) -> {
                //三个参数：服务器端的队列列表，正要发送的消息，选择依据
                Long orderId1 = (Long) o;
                int index = (int) (orderId1 % mqs.size());//订单的id对队列数量取余来计算队列索引
                return mqs.get(index);
            }, orderId);
            System.out.println(orderId + "----->" + sendResult.getMessageQueue().getQueueId());
        }
    }

3.2 消费者

    public static void main(String[] args) throws MQClientException {
        //创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer2");
        //设置name server
        consumer.setNamesrvAddr("192.168.64.141:9876");
        //订阅
        consumer.subscribe("Topic2", "*");
        //设置单线程监听器 Orderly一个线程顺序处理消息
        consumer.setMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext consumeOrderlyContext) {

                for (MessageExt msg:msgs) {
                    System.out.println("收到： "+new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        //启动
        consumer.start();
    }

4 事务消息(可靠性消息)

4.1 原理

在这里插入图片描述
在这里插入图片描述
下面来看 RocketMQ 的事务消息是如何来发送“可靠消息”的，只需要以下三步：

第一步： 发送半消息（半消息不会发送给消费者）
在这里插入图片描述
第二步： 执行本地事务
在这里插入图片描述
第三步： 提交消息
在这里插入图片描述
完成事务消息发送后，消费者就可以以正常的方式来消费数据。
RocketMQ 的自动重发机制在绝大多数情况下，都可以保证消息被正确消费。假如消息最终消费失败了，还可以由人工处理进行托底。
在这里插入图片描述
上面分析的是正常情况下的执行流程。下面再来看两种错误情况：
第一种：事务执行失败时回滚消息
在这里插入图片描述

第二种：服务器无法得知消息状态时，需要主动回查消息状态
在这里插入图片描述
在这里插入图片描述

4.2 生产者

public static void main(String[] args) throws MQClientException {
        //创建事务消息生产者
        TransactionMQProducer producer = new TransactionMQProducer("producer3");
        //设置name server
        producer.setNamesrvAddr("192.168.64.141:9876");
        //设置事务消息监听器，执行本地事务，处理服务器的回查
        producer.setTransactionListener(new TransactionListener() {
            @Override//执行本地事务
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                if(Math.random()<1){//100%
                    //执行本地事务的方法中一般不会返回UNKNOW状态，这里只是为了测试网络中断，无法向服务器发送状态的情况
                    System.out.println("模拟网络中断");
                    return LocalTransactionState.UNKNOW;
                }

                System.out.println("执行本地事务，参数："+arg);
                if(Math.random()<0.5){
                    System.out.println("本地事务执行成功");
                    return LocalTransactionState.COMMIT_MESSAGE;
                }else {
                    System.out.println("本地事务执行失败");
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }
            }

            @Override//获取本地事务执行的状态
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                System.out.println("处理服务器的事务状态回查");
                System.out.println("模拟网络中断");
                return LocalTransactionState.UNKNOW;
            }
        });
        //启动
        producer.start();
        //发送事务消息，会触发监听器来执行本地事务
        while (true){
            System.out.print("输入消息：");
            String s=new Scanner(System.in).nextLine();
            Message message= new Message("Topic3", s.getBytes());
            producer.sendMessageInTransaction(message, "执行本地事务的参数数据");

        }
    }

4.3 消费者

    public static void main(String[] args) throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer3");
        //设置name server
        consumer.setNamesrvAddr("192.168.64.141:9876");
        consumer.subscribe("Topic3", "*");
        /**
         * 处理消息的监听器
         * Concurrently 会启动多个线程，并发的处理消息
         */
        consumer.setMessageListener((MessageListenerConcurrently) (list, consumeConcurrentlyContext) -> {
            for(MessageExt msg:list){
                System.out.println("收到消息："+new String(msg.getBody()));
            }
            System.out.println("处理消息失败");
            return ConsumeConcurrentlyStatus.RECONSUME_LATER;//返回 RECONSUME_LATER 服务器重新发送
        });
        //启动消费者
        consumer.start();
    }

5 异步消息

master 收到消息后立即向生产者进行反馈。之后再以异步方式向 slave 复制消息。
异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
在这里插入图片描述

5.1 生产者

    /**
     * 异步发送消息一条消息送出后, 不必暂停等待服务器针对这条消息的反馈, 而是可以立即发送后续消息. 使用监听器, 以异步的方式接收服务器的反馈
     */
    public static void main(String[] args) throws RemotingException, MQClientException, InterruptedException {
        DefaultMQProducer producer = new DefaultMQProducer("producer4");
        producer.setNamesrvAddr("192.168.64.141:9876");
        producer.start();
        producer.setRetryTimesWhenSendAsyncFailed(0);
        while (true) {
            System.out.print("输入消息: ");
            String s = new Scanner(System.in).nextLine();
            Message msg = new Message("Topic4", "Tag4", "key4", s.getBytes());
            producer.send(msg, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("消息发送成功 : " + sendResult);
                }

                @Override
                public void onException(Throwable throwable) {
                    System.out.println("消息发送失败");
                }
            });
            System.out.println("--------------------消息已送出-----------------------");
        }
    }

5.2 消费者

异步消息消费者的代码与同步消息的代码完全一样，仅仅注意组名，topic名字，tag名字

6 单向消息

单向消息，消息发出后, 服务器不会返回结果。这种方式主要用在不特别关心发送结果的场景，例如日志发送。
在这里插入图片描述

6.1 生产者

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException {
        DefaultMQProducer producer = new DefaultMQProducer("producer5");
        producer.setNamesrvAddr("192.168.64.141:9876");
        producer.start();
        while (true) {
            System.out.print("输入消息: ");
            String s = new Scanner(System.in).nextLine();
            Message msg = new Message("Topic5", "Tag5", s.getBytes());
            producer.sendOneway(msg);
            System.out.println("--------------------消息已送出-----------------------");
        }
    }

6.2 消费者

异步消息消费者的代码与同步消息的代码完全一样，仅仅注意组名，topic名字，tag名字

7 批量消息

批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。此外，这一批消息的总大小不应超过4MB。
如果超出4M需要进行数据分割, 请参考官方代码样例https://github.com/apache/rocketmq/blob/master/docs/cn/RocketMQ_Example.md

7.1 生产者

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        DefaultMQProducer producer = new DefaultMQProducer("producer5");
        producer.setNamesrvAddr("192.168.64.141:9876");
        producer.start();
        while (true) {
            System.out.print("输入消息,用逗号分隔多条消息: ");
            String[] a = new Scanner(System.in).nextLine().split(",");

            ArrayList<Message> messages = new ArrayList<>();
            for (String s : a) {
                messages.add(new Message("Topic6", s.getBytes()));
            }
            producer.send(messages);
            System.out.println("批量消息已发送");
        }
    }

7.2 消费者

    public static void main(String[] args) throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer1");
        //设置name server
        consumer.setNamesrvAddr("192.168.64.141:9876");
        consumer.subscribe("Topic6", "*");
        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;
            }
        });
        //启动消费者
        consumer.start();
    }

8 消息过滤

8.1 Tag 过滤

Tag 可以满足大多数消息过滤的需求。使用 Tag 过滤非常简单

consumer.subscribe("Topic1", "TagA || TagB || TagC");

8.2 对自定义属性过滤

生产者可以在消息中添加自定义的属性：

msg.putUserProperty("prop1", "1");
msg.putUserProperty("prop2", "2");

消费者接收数据时，可以根据属性来过滤消息：

consumer.subscribe("Topic7", MessageSelector.bySql("prop1=1 or prop2=2"));

可以看到，自定义属性的过滤语法是 Sql 语法，RocketMQ只定义了一些基本语法来支持这个特性，支持的 Sql 过滤语法如下：

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

8.3 生产者

    /**
     * 发送的消息中包含 tag 和 userProperty,消费者接收时，可以选择用 tag 或 userProperty 进行过滤
     */
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        DefaultMQProducer producer = new DefaultMQProducer("producer6");
        producer.setNamesrvAddr("192.168.64.141:9876");
        producer.start();
        while (true) {
            System.out.print("输入消息: ");
            String s = new Scanner(System.in).nextLine();
            System.out.print("输入Tag: ");
            String tag = new Scanner(System.in).nextLine();
            Message msg = new Message("Topic6", tag, s.getBytes());
            msg.putUserProperty("rnd", "" + new Random().nextInt(4));
            producer.send(msg);
        }
    }

8.4 消费者

/**
     * 如果使用sql过滤,需要在 broker.properties 中添加配置来启用 sql 过滤：enablePropertyFilter=true
     */
    public static void main(String[] args) throws MQClientException {
        System.out.print("使用Tag过滤还是使用Sql过滤(tag/sql): ");
        String ts = new Scanner(System.in).nextLine();
        DefaultMQPushConsumer c = new DefaultMQPushConsumer("consumer-demo7");
        c.setNamesrvAddr("192.168.64.141:9876");
        if (ts.equalsIgnoreCase("tag")) {
            System.out.println("使用Tag过滤: TagA || TagB || TagC");
            c.subscribe("Topic7", "TagA || TagB || TagC");
        } else {
            System.out.println("使用Sql过滤: rnd=1 or rnd > 2");
            c.subscribe("Topic7", MessageSelector.bySql("rnd=1 or rnd > 2"));
        }
        c.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list) {
                    System.out.println(new String(msg.getBody()) + " - " + msg.getUserProperty("rnd"));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        c.start();
        System.out.println("开始消费数据");
    }
千呼万唤始出来，犹抱琵琶半遮面
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ教程(四)：RocketMQ的工作原理1
十三月的博客
06-06 774
RocketMQ 是一个高性能、高吞吐量的分布式消息和流计算平台，它基于发布-订阅模式工作。其核心设计理念是确保消息传递的高效性、稳定性和可扩展性。
03-05-26-RocketMQ基本原理分析1
08-04
RocketMQ 是一款由阿里巴巴开源的消息中间件，它在2012年首次开源，并于2017年成为Apache顶级项目。RocketMQ的设计受到了Kafka的启发，但在一些关键功能上有所不同，使其更适合大规模分布式系统的需求。以下是...
7000 字梳理 RocketMq
公众号：Java后端
09-21 1121
点击上方Java后端，选择设为星标优质文章，及时送达事情是这样的，只是刚好在简历写了项目用到了RocketMq，只是碰巧收到了一条Boss的信息，显示是阿里的招聘者，又刚好我把这份简...
RocketMQ之工作原理
最新发布
weixin_51089557的博客
02-25 3381
Rebalance即再均衡，指的是，将一个Topic下的多个Queue在同一个Consumer Group中的多个Consumer间进行重新分配的过程。Rebalance机制的本意是为了提升消息的并行消费能力。例如，一个Topic下 5 个队列，在只有 1 个消费者的情况下，这个消费者将负责消费这 5 个队列的消息。如果此时我们增加一个消费者，那么就可以给其中一个消费者分配 2 个队列，给另一个分配 3 个队列，从而提升消息的并行消费能力。
RocketMQ 基本概念与工作原理
cimbala的博客
12-30 3397
消息（Message）就是要传输的信息。一条消息必须有一个主题（Topic），主题可以看做是你的信件要邮寄的地址。
RocketMQ --- 原理篇
shuai_h的博客
06-26 1288
ProducerConsumerBroker广播消费集群消费一个 Consumer Group 中的 Consumer 实例平均分摊消费消息。例如某个 Topic 有 9 条消息，其中一个Consumer Group 有 3 个实例（可能是 3 个进程，或者 3 台机器），那么每个实例只消费其中的 3 条消息。在 CORBA Notification 规范中，无此消费方式。
Day366&367.RocketMQ工作原理 -RocketMQ
阿昌爱Java
08-21 1714
RocketMQ工作原理 一、消息的生产 1、消息的生产过程 Producer可以将消息写入到某Broker中的某Queue中，其经历了如下过程： Producer发送消息之前，会先向NameServer发出获取消息Topic的路由信息的请求 NameServer返回该Topic的路由表及Broker列表 Producer根据代码中指定的Queue选择策略，从Queue列表中选出一个队列，用于后续存储消息 Produer对消息做一些特殊处理，例如，消息本身超过4M，则会对其进行压缩 Producer向选择
rocketmq的工作原理
02-24
先简单了解一下各个模块...理解了Broker的原理，以及和其他服务交互的方式就基本弄懂了整个消息中间件的原理。 NameSrv是一个无状态的名称服务，可以集群部署。所有Broker启动的时候会向NameSrv注册自己的信息。Produc
RocketMQ 原理
杨宇昌的博客
04-27 1523
RocketMQ 原理 顺序消息、事务消息、延迟消息、负载、rebalance、重试与死信队列
RocketMQ原理
weixin_34237596的博客
09-24 590
一、RocketMQ概述 1. MessageFilter 1) Broker端消息过滤 在Broker中，按照Consumer的要求做过滤，优点是减少了对于Consumer无用消息的网络传输。缺点是增加了Broker的负担，实现相对复杂。 ² 淘宝Notify支持多种过滤方式，包含直接按照消息类型过滤，灵活的语法表达式过滤，几乎可以满足最苛...
RocketMQ原理解析
Liu_csdn_csdn的博客
06-04 944
RocketMQ的存储模型采用链式存储，即消息存储在CommitLog文件中，然后创建一个索引文件，将消息的偏移量和消息的属性存储到IndexFile文件中，以快速查询消息。NameServer负责消息的路由，Broker负责消息的存储和传输。RocketMQ支持消息的顺序性，具体实现方式是将相同业务的消息存储到同一个队列中，维护一个消息的顺序，使消息可以按照顺序被取出来。综上所述，RocketMQ是一款优秀的分布式消息队列系统，具有多种优秀的设计思想和架构模型，以及良好的性能、可靠性、可扩展性和灵活性。
人人都懂的RocketMQ基本原理
不是秃头的程序员小李
05-15 3086
RockerMQ基本原理
Rocket 架构设计
LoveSummer
07-08 878
1 技术架构 RocketMQ架构上主要分为四部分，如上图所示: Producer：消息发布的角色，支持分布式集群方式部署。Producer通过MQ的负载均衡模块选择相应的Broker集群队列进行消息投递，投递的过程支持快速失败并且低延迟。 Consumer：消息消费的角色，支持分布式集群方式部署。支持以push推，pull拉两种模式对消息进行消费。同时也支持集群方式和广播方式的消费，它提供实时消息订阅机制，可以满足大多数用户的需求。 NameServer：NameServer是一个非常简单的Topic
RocketMQ原理梳理总结
demohui的博客
07-28 2034
RocketMQ是阿里对外开源的一种分布式消息中间件，在阿里内部被叫做MetaQ，具有良好的可靠性、可用性以及稳定性 一：概念理解 NameServer 路由服务，类似于kafka中的zk，主要存储了Broker的路由信息，供Producer和Consumer使用，不然Producer怎么知道往哪个Broker发送消息，多个NameSever之间是互相独立且没有通信的，每个NameSever都会保存所有路由信息。 Broker 部署RocketMQ进程的服务被称之为Broker，Broker会接收
RocketMQ工作原理
weixin_38568503的博客
12-08 1608
一、消息的生产： 1.消息的生产过程： 2.Queue选择算法： 二、消息的存储： 1.commitlog文件： 文件与目录： 消息单元：
RocketMQ 原理介绍及详细安装教程
知道的越多 不知道的就越多
01-29 3845
本文详细介绍了RocketMq的相关概念，以图文的方式描述了相关运行原理，以及详细的安装教程和管理端工具的安装和使用。
RocketMQ实战与原理解析：阿里专家深度剖析
此外，书中还结合源码分析，帮助读者理解分布式消息队列的基本原理，这对于在复杂的业务环境中构建高效的消息传递系统至关重要。作者强调，尽管本书提供了丰富的实践指导，但技术类书籍的目的并非仅仅收藏，而是获取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值