RocketMQ的消息类型及简单代码示例

最新推荐文章于 2024-07-14 17:36:46 发布
最新推荐文章于 2024-07-14 17:36:46 发布
阅读量781 收藏
点赞数 1
分类专栏： MQ 文章标签： 队列 java 分布式 中间件 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xueguchen/article/details/114800938
版权

1. MQ简介

1.1 简介

MQ（Message Queue）消息队列，是基础数据结构中“先进先出”的一种数据结构。一般用来解决应用解耦，异步消息，流量削峰等问题，实现高性能，高可用，可伸缩和最终一致性架构。

把要传输的数据（消息）放在队列中，用队列机制来实现消息传递——生产者产生消息并把消息放入队列，然后由消费者去处理。消费者可以到指定队列拉取消息，或者订阅相应的队列，由MQ服务端给其推送消息。

1.2 作用
  1. 异步：主业务执行结束后从属业务通过MQ，异步执行，减低业务的响应时间，提高用户体验。
  2. 解耦：一个业务需要多个模块共同实现，或者一条消息有多个系统需要对应处理，只需要主业务完成以后，发送一条MQ，其余模块消费MQ消息，即可实现业务，降低模块之间的耦合。
  3. 削峰：高并发情况下，业务异步处理，提供高峰期业务处理能力，避免系统瘫痪。
1.3 缺点
  1. 系统可用性降低：如何保证MQ的高可用
  2. 系统复杂度提高：如何保证消费不会丢失？不会被重复调用？怎么保证消息的顺序性等问题
  3. 消息一致性问题：如何保证主业务和从属业务一致性的处理

2. 常见MQ应用的比较

—优点缺点使用场景
RabbitMQ消息可靠性高、功能全面吞吐量低、消息积累对性能影响较大小规模场景
RocketMQ高吞吐、高性能、功能全面开源版（阉割版）、只支持Java大部分场景
Kafka高吞吐、高性能、高可用会丢数据、功能比较单一日志分析、大数据采集分析

3. RocketMQ的编程模型

3.1 生产者
  1. 创建消息生产者producer，并指定生产者组名
  2. 指定Name server地址
  3. 启动producer
  4. 创建消息对象，指定主题Topic、Tag和消息体
  5. 发送消息
  6. 关闭生产者producer
3.2 消费者
  1. 创建消费者Consumer，指定消费者组名
  2. 指定Name server地址
  3. 订阅主题Topic和Tag
  4. 设置回调函数，处理消息
  5. 启动消费者consumer

4. RocketMQ的消息类型

4.1 基本类型（同步发送、异步发送、单向发送）

消费者：

package com.example.mq.synchronous;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

/**
 * 描述:
 * 消费者
 *
 * @author XueGuCheng
 * @create 2021-03-14 21:27
 */
public class Consumer {

    public static void main(String[] args) throws MQClientException {
        // 1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 2.指定Name server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");

        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);

        // 3.订阅主题Topic和Tag
        consumer.subscribe("TopicTest","*");
        // 4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext context) {
                System.out.printf("%s 收到的消息: %s %n", Thread.currentThread().getName(), list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 5.启动消费者consumer
        consumer.start();
        System.out.printf("消费者开始运行.%n");


    }

}
4.1.1 同步发送

原理：

同步发送是指消息发送方发出一条消息后，会在收到服务端返回响应之后才发下一条消息的通讯方式

应用场景：如重要通知邮件、报名短信通知等。

生产者：

package com.example.mq.synchronous;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;



/**
 * 描述:
 * 同步发送消息
 *
 * @author XueGuCheng
 * @create 2021-03-14 21:09
 */
public class SynchronousProducer {

    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 2.指定Name server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 3.启动producer
        producer.start();
        // 4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message("TopicTest", "Tag_Synchronous", "ID100",  "Synchronous".getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 5.同步发送消息，消息会发给集群中的一个Broker节点
            SendResult sendResult = producer.send(message);
        }
        // 6.关闭生产者producer
        producer.shutdown();

    }
}
4.1.2 异步发送

原理：

异步发送是指发送方发出一条消息后，不等服务端返回响应，接着发送下一条消息的通讯方式。RocketMQ异步发送，需要实现异步发送回调接口（SendCallback）。消息发送方在发送了一条消息后，不需要等待服务端响应即可发送第二条消息。发送方通过回调接口接收服务端响应，并处理响应结果。

应用场景：一般用于链路耗时较长，对响应时间较为敏感的业务场景，例如，视频上传后通知启动转码服务，转码完成后通知推送转码结果等。

生产者：

package com.example.mq.Async;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * 描述:
 * 异步发送
 *
 * @author XueGuCheng
 * @create 2021-03-14 21:56
 */
public class AsyncProducer {

    //异步发送，需要引入一个countDownLatch，来保证所有Producer发送消息的回调方法都执行完了再停止Producer服务
    static final CountDownLatch countDownLatch = new CountDownLatch(10);

    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 2.指定Name server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 3.启动producer
        producer.start();
        // 4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            final int index = i;
            Message message = new Message("TopicTest", "Tag_Async", "ID100",  "Async".getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 5.异步发送消息，消息会发给集群中的一个Broker节点
            producer.send(message, new SendCallback() {
                // 执行成功的回调
                @Override
                public void onSuccess(SendResult sendResult) {
                    countDownLatch.countDown();
                    System.out.printf("%-10d true %s %n", index, sendResult.getMsgId());
                }
                // 执行失败的回调
                @Override
                public void onException(Throwable throwable) {
                    countDownLatch.countDown();
                    System.out.printf("%-10d flase %s %n", index, throwable);
                    throwable.printStackTrace();
                }
            });
        }
        System.out.println("消息发送完成");
        countDownLatch.await(5, TimeUnit.SECONDS);
        // 6.关闭生产者producer
        producer.shutdown();

    }

}
4.1.3 单向发送

原理：

单向（Oneway）发送特点为只负责发送消息，不等待服务器回应且没有回调函数触发，即只发送请求不等待应答。此方式发送消息的过程耗时非常短，一般在微秒级别。

应用场景：适用于某些耗时非常短，但对可靠性要求并不高的场景，例如日志收集。

生产者：

package com.example.mq.ida;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

/**
 * 描述:
 * 单向发送
 *
 * @author XueGuCheng
 * @create 2021-03-14 22:08
 */
public class IDAProducer {

    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 2.指定Name server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 3.启动producer
        producer.start();
        // 4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message("TopicTest", "Tag_IDA", "ID100",  "IDA".getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 5.单向发送消息，消息会发给集群中的一个Broker节点
            producer.sendOneway(message);
        }
        Thread.sleep(5000);
        // 6.关闭生产者producer
        producer.shutdown();

    }


}
4.1.4 总结
发送方式发送 TPS发送结果反馈可靠性
同步发送快有不丢失
异步发送快有不丢失
单向发送最快无可能丢失
4.2 顺序消息

原理：

发送者端：
在默认情况下，消息发送者会采取Round Robin轮询方式把消息发送到不同的MessageQueue(分区队列)，而消费者消费的时候也从多个MessageQueue上拉取消息，这种情况下消息是不能保证顺序的。而只有当一组有序的消息发送到同一个MessageQueue上时，才能利用MessageQueue先进先出的特性保证这一组消息有序。

消费者端：
消费者会从多个消息队列上去拿消息。这时虽然每个消息队列上的消息是有序的，但是多个队列之间的消息仍然是乱序的。消费者端要保证消息有序，就需要按队列一个一个来取消息，即取完一个队列的消息后，再去取下一个队列的消息。

而给consumer注入的MessageListenerOrderly对象，在RocketMQ内部就会通过锁队列的方式保证消息是一个一个队列来取的。MessageListenerConcurrently这个消息监听器则不会锁队列，每次都是从多个Message中取一批数据（默认不超过32条）。因此也无法保证消息有序。

生产者：

package com.example.mq.order;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.util.List;

/**
 * 描述:
 * 顺序消息——生产者
 *
 * @author XueGuCheng
 * @create 2021-03-14 22:21
 */
public class OrderProducer {

    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 2.指定Name server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 3.启动producer
        producer.start();
        // 4.创建消息对象，指定主题Topic、Tag和消息体
        // 顺序消息：保证第二个循坏内的消息的顺序性，不保证第一个循坏的顺序性。即只保证局部有序，不保证全局有序
        for (int i = 0; i < 10; i++) {
            int orderId = i;
            for (int i1 = 0; i1 < 5; i1++) {
                Message message = new Message("TopicTest", "Tag_Order" + orderId, "ID100" + orderId, ("Order" + i1).getBytes(RemotingHelper.DEFAULT_CHARSET));
                // 5.同步发送消息，消息会发给集群中的一个Broker节点
                SendResult sendResult = producer.send(message, new MessageQueueSelector() {
                    @Override
                    public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                        Integer id = (Integer) o;
                        int index = id % list.size();
                        return list.get(index);
                    }
                }, orderId);

                System.out.printf("%s%n", sendResult);
            }
        }
        // 6.关闭生产者producer
        producer.shutdown();

    }


}

消费者：

package com.example.mq.order;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.*;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

/**
 * 描述:
 * 消费者
 *
 * @author XueGuCheng
 * @create 2021-03-14 21:27
 */
public class Consumer {

    public static void main(String[] args) throws MQClientException {
        // 1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 2.指定Name server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");

        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);

        // 3.订阅主题Topic和Tag
        consumer.subscribe("TopicTest","*");
        // 4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext context) {
                context.setAutoCommit(true);
                for (MessageExt message : list) {
                    System.out.println("收到消息内容 "+new String(message.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        // 5.启动消费者consumer
        consumer.start();
        System.out.printf("消费者开始运行.%n");


    }

}
4.3 广播消息

原理：

在集群状态(MessageModel.CLUSTERING)下，每一条消息只会被同一个消费者组中的一个实例消费到(这跟kafka和rabbitMQ的集群模式是一样的)。而广播模式则是把消息发给了所有订阅了对应主题的消费者，而不管消费者是不是同一个消费者组。

消费者：

package com.example.mq.broadcast;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.util.List;

/**
 * 描述:
 * 广播模式
 *
 * @author XueGuCheng
 * @create 2021-03-14 22:47
 */
public class PushConsumer {

    public static void main(String[] args) throws MQClientException {
        // 1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 2.指定Name server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");

        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);

        consumer.setMessageModel(MessageModel.BROADCASTING);
        
        // 3.订阅主题Topic和Tag
        consumer.subscribe("TopicTest","*");
        // 4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext context) {
                System.out.printf("%s 收到的消息: %s %n", Thread.currentThread().getName(), list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 5.启动消费者consumer
        consumer.start();
        System.out.printf("消费者开始运行.%n");
    }
}
4.4 延迟消息

延迟级别：

1到18分别对应messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h

生产者：

package com.example.mq.scheduled;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

/**
 * 描述:
 * 延时消息
 *
 * @author XueGuCheng
 * @create 2021-03-14 22:52
 */
public class ScheduledProducer {

    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 2.指定Name server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 3.启动producer
        producer.start();
        // 4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message("TopicTest", "Tag_Synchronous", "ID100",  "Synchronous".getBytes(RemotingHelper.DEFAULT_CHARSET));
            //设置延时级别
            message.setDelayTimeLevel(3);
            // 5.发送消息，消息会发给集群中的一个Broker节点
            producer.send(message);
        }
        // 6.关闭生产者producer
        producer.shutdown();

    }

}
4.5 批量消息

批量消息是指将多条消息合并成一个批量消息，一次发送出去。这样的好处是可以减少网络IO，提升吞吐量。

注意：推荐一个批次消息的大小不要超过1MB，实际最大的限制是4194304字节，大概4MB。而且批量消息的使用是有一定限制的，这些消息应该有相同的Topic，相同的waitStoreMsgOK。而且不能是延迟消息、事务消息等。

生产者：

package com.example.mq.batch;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.util.ArrayList;
import java.util.List;

/**
 * 描述:
 * 批量消息
 *
 * @author XueGuCheng
 * @create 2021-03-14 23:04
 */
public class BatchProducer {

    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 2.指定Name server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 3.启动producer
        producer.start();
        // 4.创建消息对象，指定主题Topic、Tag和消息体
        List<Message> messages = new ArrayList<>(16);
        for (int i = 0; i <  1000; i++) {
            messages.add(new Message("TopicTest", "Tag_Batch", "ID100" + i,  "Batch".getBytes()));
        }
        // 5.发送消息，消息会发给集群中的一个Broker节点
        producer.send(messages);
        // 6.关闭生产者producer
        producer.shutdown();

    }

}
4.6 过滤消息

即，使用Message的Tag属性来简单快速的过滤信息。

原理：

在消费者端使用MessageSelector.bySql(String sql)返回的一个MessageSelector。这里面的sql语句是按照SQL92标准来执行的。sql中可以使用的参数有默认的TAGS和一个在生产者中加入的a属性。

SQL92语法：

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

常量支持类型为：

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

注意：只有推模式的消费者可以使用SQL过滤。拉模式是用不了的。

生产者：

package com.example.mq.filter;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

/**
 * 描述:
 * 过滤模式
 *
 * @author XueGuCheng
 * @create 2021-03-14 23:18
 */
public class FilterProducer {

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

        String[] tags = new String[] {"TagA", "TagB", "TagC"};

        // 4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message("TopicTest", tags[i % tags.length], "ID100",  "Synchronous".getBytes(RemotingHelper.DEFAULT_CHARSET));
            message.putUserProperty("a",String.valueOf(i));
            // 5.发送消息，消息会发给集群中的一个Broker节点
            SendResult sendResult = producer.send(message);
            System.out.printf("%s%n", sendResult);
        }
        // 6.关闭生产者producer
        producer.shutdown();

    }

}

消费者：

package com.example.mq.filter;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.MessageSelector;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

/**
 * 描述:
 * 过滤模式
 *
 * @author XueGuCheng
 * @create 2021-03-14 23:21
 */
public class FilterConsumer {

    public static void main(String[] args) throws MQClientException {
        // 1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 2.指定Name server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 3.设置过滤主题Topic和Tag（TAGS不为空，且是A或者B，并且a属性不为空，且在0和3之间）
        consumer.subscribe("TopicTest", MessageSelector.bySql("(TAGS is not null and TAGS in ('TagA', 'TagB'))" +
                "and (a is not null and a between 0 and 3)"));
        //consumer.subscribe("TagFilterTest", "TagA || TagC");
        // 4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext context) {
                System.out.printf("%s 收到的消息: %s %n", Thread.currentThread().getName(), list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 5.启动消费者consumer
        consumer.start();
        System.out.printf("消费者开始运行.%n");
    }

}

5. ACL权限控制

5.1 简介

ACL权限控制，提供Topic资源级别的用户访问控制。

即，可以在Client客户端通过 RPCHook注入AccessKey和SecretKey签名，同时将对应的权限控制属性（包括Topic访问权限、IP白名单和AccessKey和SecretKey签名等）配置在$ROCKETMQ_HOME/conf/plain_acl.yml的配置文件中。

Broker端会对AccessKey所拥有的权限进行校验，校验不过，则抛出异常

5.2 maven坐标
<dependency> 
	<groupId>org.apache.rocketmq</groupId>
	<artifactId>rocketmq-acl</artifactId>
	<version>xxx</version>
 </dependency>
5.3 配置信息

plan_acl.yml的配置信息

#全局白名单，不受ACL控制，通常需要将主从架构中的所有节点加进来 
globalWhiteRemoteAddresses:
- 127.0.0.* 

accounts: 
#第一个账户 
- accessKey: RocketMQ 
  secretKey: 12345678 
  whiteRemoteAddress: 
  admin: false 
  defaultTopicPerm: DENY #默认Topic访问策略是拒绝 
  defaultGroupPerm: SUB #默认Group访问策略是只允许订阅 
  topicPerms: 
  - topicA=DENY #topicA拒绝 
  - topicB=PUB|SUB #topicB允许发布和订阅消息
  - topicC=SUB #topicC只允许订阅 
  groupPerms: 
  - groupA=DENY 
  - groupB=PUB|SUB 
  - groupC=SUB 
#第二个账户 
- accessKey: rocketmq2 
  secretKey: 12345678 
  ......
雪孤城
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
策略模式实现rocketmq的消息处理器解耦-完整代码.zip
01-19
在本示例中，我们看到如何将这种模式应用于RocketMQ消息处理器的解耦。RocketMQ是一款高性能、分布式的消息中间件，常用于构建大规模分布式系统中的消息传递。 首先，让我们深入理解策略模式。策略模式定义了一系列...
Rocketmq--环境搭建
qq_30810825的博客
03-12 196
环境搭建之前 jdk1.8 maven3.6.0(这是我电脑上的maven的版本） 在mac电脑上环境搭建步骤 1.下载安装包并解压 安装包rocketmq-all-4.2.0-source-release.zip，解压unzip -o rocketmq-all-4.2.0.tar.gz，解压的目录为/Users/join/jointemp/rocketm...
RocketMQ的demo代码
呼噜娃
05-30 1284
在发送消息时，我们使用MessageQueueSelector来选择要发送的消息队列，并通过参数指定了消息的顺序。然后，我们创建一个消息对象，指定主题、标签和消息内容。在主程序中，我们创建了一个消息对象，并通过调用sendMessageInTransaction方法发送事务消息。在上述示例代码中，OrderedProducer类用于发送顺序消息，而OrderedConsumer类用于接收和处理顺序消息。在上述示例代码中，Producer类用于发送消息，而Consumer类用于接收和处理消息。
RocketMQ~消息的种类与生命周期（普通消息、延时&定时消息、事务消息）
最新发布
Shangxingya的博客
07-14 985
普通消息一般应用于微服务解耦、事件驱动、数据集成等场景，这些场景大多数要求数据传输通道具有的能力，且对消息的没有特别要求。以在线的电商交易场景为例，上游订单系统将用户下单支付这一业务事件封装成独立的普通消息并发送至 RocketMQ 服务端，下游按需从服务端订阅消息并按照本地消费逻辑处理下游任务。每个消息之间都是相互独立的，且不需要产生关联。另外还有日志系统，以离线的日志收集场景为例，通过埋点组件收集前端应用的相关操作日志，并转发到 RocketMQ。
2024年C C++最全linux nginx 注册服务_env etc init，百度、华为、京东、B站最新面试题汇集
2401_84976607的博客
05-12 114
【代码】2024年C C++最全linux nginx 注册服务_env etc init，百度、华为、京东、B站最新面试题汇集。
RocketMQ工作原理详解及开发实例
深圳市多克创新科技有限公司
10-16 1353
RocketMQ详解及开发用例
RocketMq-c++客户端在win下的示例
xinqingwuji的博客
01-13 2247
https://download.csdn.net/download/zhaoxiaozhao622/10146274
rocketMQ的安装以及示例代码-转载
weixin_41392674的博客
01-05 483
本篇文章转载至-点击这里 一、安装及启动 1、将zip文件上传到linux的~下，然后解压： 执行：unzip rocketmq-all-4.4.0-bin-release.zip，若unzip命令不存在，执行：yum install -y unzip zip 2、移动并重命名 执行：mv rocketmq-all-4.4.0-bin-release /usr/local/rocketmq 3、进入/usr/local/rocketmq/bin目录下 执行：cd /usr/local/rocketmq/bi
RocketMQ消息队列demo
01-09
- 消费者代码示例，展示如何订阅主题并处理接收到的消息。 - 可能还有配置文件，用于设置服务器连接信息和消费者/生产者参数。 通过这个demo，初学者可以快速了解和实践RocketMQ的基本操作，从而更好地理解和运用...
Tedu五阶段SpringBoot整合RocketMQ
02-26
本篇文章将详细介绍如何在Spring Boot项目中集成RocketMQ消息中间件，并通过具体的代码示例来展示两种消息类型：顺序消息与事务消息的处理方式。此外，还将介绍RocketMQ的一些核心概念，如Keys与Tags的作用，并给出...
spring boot的拦截器简单使用示例代码
08-30
Spring Boot拦截器的简单使用示例代码 Spring Boot框架提供了拦截器机制，允许开发者在请求处理过程中执行自定义逻辑。拦截器可以用来实现身份验证、权限控制、日志记录、性能监控等功能。在Spring Boot中，拦截器...
java -RocketMQ实战视频教程（上下全集）
01-25
- **发送与接收消息**：通过具体的代码示例，演示如何使用Java API发送普通消息、顺序消息以及事务消息，并展示消息的消费逻辑。 - **性能优化**：讲解如何通过合理的配置提高RocketMQ系统的吞吐量和降低延迟，比如...
Rocketmq实例以及详解
qq_33719894的博客
12-10 6269
一.为什么用Mq 服务之间通信的中间件。 可以让应用之间解耦，相互之间依赖减小，形成异步调用。还可以用来流量削峰。数据分发。 但是会有消息一致性问题，系统复杂性增加，如果Mq宕机，系统可用性会降低。 二.特点 灵活可扩展，支持海量消息单机10万级别，使用文件做持久化, 并支持分布式事务(虽然可能造成较多的写脏), 异步刷盘,内存预分配, 高可用采用了同步双写及异步复制的方式 三.介绍 RocketMQ 是阿里巴巴在2012年开源的分布式消息中间件，目前已经捐赠给 Apac...
分布式消息队列RocketMQ的应用（代码实例1）
weixin_45703155的博客
09-04 1388
分布式消息队列RocketMQ的应用（代码实例1）--普通消息，顺序消息，延时消息，事务消息
RabbitMq五种模式代码案例及使用详解
m0_58709145的博客
10-14 3920
RabbitMQ是一个实现了AMQP（Advanced Message Queuing Protocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。
MQ 之 RocketMQ 应用及代码实现
Andy-ZhangSir的博客
08-22 1723
看视频的时候，到这一章节，弹幕里全是**终于熬到这一章了**，哈哈，对于大家来说，看理论知识确实很枯燥，不过很多东西必须要有一定的理论知识为我们做支撑，否则就是墙上芦苇、山间竹笋。 那么，我们就开始RocketMQ的应用，使用代码来实现各项功能吧。
RocketMQ的消息发送样例
YHJ
05-23 517
导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析r 1.创建消息生产者producer，并制定生产者组名 2....
RocketMQ高级功能及代码示例
追求幸福，探索未知的博客
05-06 1695
文章目录1. 高级功能1.1 消息存储1.1.1 存储介质1.1.2 性能对比1.1.3 消息的存储和发送1）消息存储2）消息发送1.1.4 消息存储结构1.1.5 刷盘机制1）同步刷盘2）异步刷盘3）配置1.2 高可用性机制1.2.1 消息消费高可用1.2.2 消息发送高可用1.2.3 消息主从复制1）同步复制2）异步复制3）配置4）总结1.3 负载均衡1.3.1 Producer负载均衡1.3.2 Consumer负载均衡1）集群模式2）广播模式1.4 消息重试1.4.1 顺序消息的重试1.4.2 无序
Mq队列及交换机代码示例
凭感觉活着的博客
05-25 305
首先写一个RabbitMQ的配置类，可以点对点的形式注入Queue，也可以用交换机的形式 package com.moon.config; import org.springframework.amqp.core.*; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class R
qt接入阿里云物联网平台
01-24
为了将Qt应用程序接入阿里云物联网平台，首先需要在阿里云物联网平台上创建一个设备，获取设备的身份证书和密钥。然后，在Qt应用程序中使用阿里云物联网平台提供的SDK，根据设备的身份证书和密钥进行认证并连接到平台。 接入阿里云物联网平台后，Qt应用程序可以通过物联网平台提供的API进行设备的注册、数据的上报和下发、远程控制等操作。同时，可以利用阿里云物联网平台提供的数据存储、分析和可视化功能对设备数据进行管理和展示。 在接入阿里云物联网平台的过程中，需要注意安全性和稳定性，确保设备与平台的通信是可靠的。同时要考虑设备的网络环境和资源限制，合理设计数据传输和处理的方式，以确保设备能够高效地与物联网平台进行通信。 总之，Qt应用程序接入阿里云物联网平台需要充分了解平台的API和SDK，合理设计设备与平台之间的通信流程，确保设备能够稳定、安全地连接到物联网平台并进行各种操作。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值