rocketmq的使用及高级特性

最新推荐文章于 2023-07-15 23:35:36 发布

置顶背影漫湿了脸

最新推荐文章于 2023-07-15 23:35:36 发布

阅读量277

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_39702298/article/details/115447845

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

MQ的使用场景

1：跨系统的数据传递
2：高并发流量削峰
3：异步处理…

常用的消息中间件

ActiveMq、RabbitMq、Kafka、RockeMq，本文主要讲述RockeMq，个中区别，请自行百度

RockeMq是由阿里捐赠给Apache的一款分布式，队列模型的开源消息中间件，经历了淘宝双十一的考验，性能和功能完备性，同级最强，使用java语言开发。

RockeMq的基本概念

Producer：消息生产者，负责生产消息
Consumer：消息消费者，负责消费消息
ProducerGroup：生产者组，这类生产者通常发送一类消息，且发送逻辑一致
ConsumerGroup：消费者组，这类消费者通常消费一类消息，且消费逻辑一致
NameSrv：一个无状态的名称服务，可以部署集群，每一个Broker启动的时候都会向名称服务注册，接收客户端的请求并返回路由信息
Broker：消息中转角色，负责存储，发送和接收消息
Topic：消息的主题，生产者往主题上发送，消费者订阅该主题
Message：消息实例，在生产者和消费者之间传递，一个Message必须属于一个Topic
Offset：偏移量，记录了每一次的消费的位置
Tag：用于对消息进行过滤，一个Message可以有不同的Tag
Key：消息键，每条消息唯一

RockeMq的安装和启动，自行百度，这里不做过多介绍
官网地址：http://rocketmq.apache.org/ 自行下载

注意事项说明：

1：使用RockeMq，需启动NameSrv和Broker，这两者均是java程序，有顺序要求，需保证先启动NameSrv
2：如启动后本地连接不上，请先检查对应的端口是否开放，如使用阿里云服务器，需将对应端口添加至安全组，如使用虚拟机，直接关闭防火墙即可。

RockeMq的特性

1：原生分布式
2：两种消息拉取
3：特有的分布式协调器
4：亿级消息对接
5：组(GROUP)

学习内容

1：rocketMq发送同步消息
2：rocketMq发送异步消息
3：rocketMq发送定时消息
4：rocketMq发送批量消息
5：rocketMq发送顺序消息
6：rocketMq发送事务消息

RockeMq的使用

maven依赖

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

第一个入门示例

1：生产者发送同步消息：

public class SyncProducer {
    public static final String NAME_SERVER_ADDR = "127.0.0.1:9876";
    public static void main(String[] args) throws MQClientException, UnsupportedEncodingException, RemotingException, InterruptedException, MQBrokerException {
        // 1. 创建生产者对象
        DefaultMQProducer producer = new DefaultMQProducer("GROUP_TEST");

        // 2. 设置NameServer的地址
        producer.setNamesrvAddr(NAME_SERVER_ADDR);

        // 3. 启动生产者
        producer.start();

        // 4. 生产者发送消息
        for (int i = 0; i < 10; i++) {
            Message message = new Message("TopicTest", "TagA", ("Hello MQ:" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));

            SendResult result = producer.send(message);

            System.out.printf("发送结果：%s%n", result);
        }

        // 5. 停止生产者
        producer.shutdown();
    }

消费者消费消息

public class Consumer {

    public static final String NAME_SERVER_ADDR = "127.0.0.1:9876";

    public static void main(String[] args) throws MQClientException {
        // 1. 创建消费者（Push）对象
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("GROUP_TEST");

        // 2. 设置NameServer的地址
        consumer.setNamesrvAddr(NAME_SERVER_ADDR);
        consumer.setMaxReconsumeTimes(-1);// 消费重试次数 -1代表16次
        // 3. 订阅对应的主题和Tag
        consumer.subscribe("TopicTest", "*");

        // 4. 注册消息接收到Broker消息后的处理接口
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                try {
                    MessageExt messageExt = list.get(0);
                    System.out.printf("线程：%-25s 接收到新消息 %s --- %s %n", Thread.currentThread().getName(), messageExt.getTags(), new String(messageExt.getBody(), RemotingHelper.DEFAULT_CHARSET));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        });

        // 5. 启动消费者(必须在注册完消息监听器后启动，否则会报错)
        consumer.start();

        System.out.println("已启动消费者");
    }
}

2：生产者发送异步消息，传递SendCallback参数，成功或失败则会回调对应的方法

public class AsyncProducer {
    public static final String NAME_SERVER_ADDR = "192.168.100.242:9876";
    public static void main(String[] args) throws MQClientException, UnsupportedEncodingException, RemotingException, InterruptedException {
        // 1：创建生产者对象，并指定组名
        DefaultMQProducer producer = new DefaultMQProducer("GROUP_TEST");

        // 2：指定NameServer地址
        producer.setNamesrvAddr(NAME_SERVER_ADDR);

        // 3：启动生产者
        producer.start();
        producer.setRetryTimesWhenSendAsyncFailed(0); // 设置异步发送失败重试次数，默认为2

        int count = 10;
        CountDownLatch cd = new CountDownLatch(count);
        // 4：循环发送消息
        for (int i = 0; i < count; i++) {
            final int index = i;

            // ID110：业务数据的ID，比如用户ID、订单编号等等
            Message msg = new Message("TopicTest", "TagB", "ID110", ("Hello World " + index).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 发送异步消息
            producer.send(msg, new SendCallback() {
                /**
                 * 发送成功的回调函数
                 * 但会结果有多种状态，在SendStatus枚举中定义
                 * @param sendResult
                 */
                public void onSuccess(SendResult sendResult) {
                    System.out.printf("%-10d OK MSG_ID:%s %n", index, sendResult.getMsgId());
                    cd.countDown();
                }

                /**
                 * 发送失败的回调函数
                 * @param e
                 */
                public void onException(Throwable e) {
                    System.out.printf("%-10d Exception %s %n", index, e);
                    e.printStackTrace();
                    cd.countDown();
                }
            });
        }

        // 确保消息都发送出去了
        cd.await();
        // 5：关闭生产者
        producer.shutdown();
    }
}

3：生产者发送定时消息

public class ScheduledMessageProducer {

    public static final String NAME_SERVER_ADDR = "192.168.100.242:9876";
    public static void main(String[] args) throws MQClientException, InterruptedException, RemotingException, MQBrokerException, UnsupportedEncodingException {
        // 1. 创建生产者对象
        DefaultMQProducer producer = new DefaultMQProducer("GROUP_TEST");

        // 2. 设置NameServer的地址，如果设置了环境变量NAMESRV_ADDR，可以省略此步
        producer.setNamesrvAddr(NAME_SERVER_ADDR);

        // 3. 启动生产者
        producer.start();

        for (int i = 0; i < 10; i++) {
            String content = "Hello scheduled message " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS").format(new Date());
            Message message = new Message("TopicTest", content.getBytes(RemotingHelper.DEFAULT_CHARSET));

            // 4. 设置延时等级，此消息将在10秒后传递给消费者
            // 可以在broker服务器端自行配置messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
            message.setDelayTimeLevel(3);

            // 5. 发送消息
            SendResult result = producer.send(message);

            System.out.printf("发送结果：%s%n", result);
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(300, 800));
        }

        // 6. 停止生产者
        producer.shutdown();
    }
}

发送定时消息时，须设置setDelayTimeLevel参数，setDelayTimeLevel可选值范围为1-18之间，rocketMq底层维护了一个数组，其值为1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h，假设setDelayTimeLevel设置为3，则该消息会在10秒后进行推送。

4：生产者发送批量消息

public class BatchMessageProducer {
    public static void main(String[] args) throws MQClientException, InterruptedException, RemotingException, MQBrokerException, UnsupportedEncodingException {
        // 1. 创建生产者对象
        DefaultMQProducer producer = new DefaultMQProducer("GROUP_TEST");

        // 2. 设置NameServer的地址，如果设置了环境变量NAMESRV_ADDR
        producer.setNamesrvAddr("192.168.100.242:9876");

        // 3. 启动生产者
        producer.start();

        List<Message> messages = new ArrayList<>();
        for (int i = 0; i < 32; i++) {
            String content = "Hello batch message " + i;
            Message message = new Message("TopicTest", content.getBytes(RemotingHelper.DEFAULT_CHARSET));

            messages.add(message);
        }
        // 5. 发送消息
        SendResult result = producer.send(messages);
        System.out.println("消息已发送：" + result);

        // 6. 停止生产者
        producer.shutdown();
    }
}

注意：批量消息，调用发送接口时，传递消息集合即可，在实际业务下，可提升效率

批量消费示例

public class BatchMessageConsumer {

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

        // 1. 创建消费者（Push）对象
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("GROUP_TEST");

        // 2. 设置NameServer的地址，如果设置了环境变量NAMESRV_ADDR，可以省略此步
        consumer.setNamesrvAddr("192.168.100.242:9876");

        // 3. 订阅对应的主题和Tag
        consumer.subscribe("TopicTest", "*");

        // 4. 设置消息批处理数量，即每次最多获取多少消息，默认是1
        consumer.setConsumeMessageBatchMaxSize(10);

        // 5. 注册接收到Broker消息后的处理接口
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                try {
                    // 设置消息批处理数量后，list中才会有多条，否则每次只会有一条
                    for (MessageExt messageExt : list) {
                        System.out.printf("线程：%-25s 接收到新消息 --- %s %n", Thread.currentThread().getName(), new String(messageExt.getBody(), RemotingHelper.DEFAULT_CHARSET));
                    }
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        // 6. 启动消费者(必须在注册完消息监听器后启动，否则会报错)
        consumer.start();

        System.out.println("已启动消费者");
    }
}

注意：批量消费时，需设置setConsumeMessageBatchMaxSize参数，代表每次批量消费的条数，如不设置，默认值为一，将没有批量的效果

5：生产者发送顺序消息：
在一些特殊场景下，要求需要保证消息的消费顺序，假设用户在ATM上取钱，正常流程为取钱成功后先扣款，再发短信通知，此处顺序不能颠倒
学习顺序消息之前，需要先了解rocketMq中队列（queue）的概念，rocketMq默认为每个topic创建4个队列(queue)，此项可根据配置文件进行修改，发送至topic中的消息，会被均匀的分配至topic的队列下，假设用户取完钱之后，扣款的消息推送到了队列一上，发送短信的消息推送至队列二中，由于不是一个队列，无法保证先进先出，即mq不能保证队列一优先于队列二被推送，此时如果想要满足顺序推送，仅需要将两条消息发送至一个队列中即可，rocketMq在发送消息时，可指定将消息发送到对应的队列中，代码演示如下

public class OrderedProducer {
    public static final String NAME_SERVER_ADDR = "192.168.100.242:9876";

    public static void main(String[] args) throws MQClientException, InterruptedException, RemotingException, MQBrokerException, UnsupportedEncodingException {
        // 1：创建生产者对象，并指定组名
        DefaultMQProducer producer = new DefaultMQProducer("GROUP_TEST");

        // 2：指定NameServer地址
        producer.setNamesrvAddr(NAME_SERVER_ADDR);

        // 3：启动生产者
        producer.start();
        producer.setRetryTimesWhenSendAsyncFailed(0); // 设置异步发送失败重试次数，默认为2

        // 4：定义消息队列选择器
        MessageQueueSelector messageQueueSelector = new MessageQueueSelector() {

            /**
             * 消息队列选择器，保证同一条业务数据的消息在同一个队列
             * @param mqs topic中所有队列的集合
             */
            public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                
                return mqs.get(0);

            }
        };

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

        List<Map> bizDatas = getBizDatas();//此方法会返回多条数据 

        // 5：循环发送消息
        for (int i = 0; i < bizDatas.size(); i++) {
            Map bizData = bizDatas.get(i);
            // keys：业务数据的ID，比如用户ID、订单编号等等
            Message msg = new Message("TopicTest", tags[i % tags.length], "" + bizData.get("msgType"), bizData.toString().getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 发送有序消息
            SendResult sendResult = producer.send(msg, messageQueueSelector, bizData.get("msgType"));

            System.out.printf("%s， body:%s%n", sendResult, bizData);
        }

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

rocketMq通过队列选择器MessageQueueSelector ，来将消息推送至指定的队列中，本示例为将消息推送至第一个队列。

顺序消费消息：

public class OrderedConsumer {
    public static final String NAME_SERVER_ADDR = "192.168.100.242:9876";
    public static void main(String[] args) throws Exception {
        // 1. 创建消费者（Push）对象
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("GROUP_TEST");

        // 2. 设置NameServer的地址，如果设置了环境变量NAMESRV_ADDR，可以省略此步
        consumer.setNamesrvAddr(NAME_SERVER_ADDR);

        /**
         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
         * 如果非第一次启动，那么按照上次消费的位置继续消费
         */
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

        // 3. 订阅对应的主题和Tag
        consumer.subscribe("TopicTest", "TagA || TagB || TagC");

        // 4. 注册消息接收到Broker消息后的处理接口
        // 注1：普通消息消费 [[
//        consumer.registerMessageListener(new MessageListenerConcurrently() {
//            AtomicInteger count = new AtomicInteger(0);
//
//            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
//                doBiz(list.get(0));
//                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
//            }
//        });
        // ]] 注1：普通消息消费

        // consumer
        consumer.setMaxReconsumeTimes(-1);
        // 延时  level  3

        // 注2：顺序消息消费 [[
        consumer.registerMessageListener(new MessageListenerOrderly() {

            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs,
                                                       ConsumeOrderlyContext context) {
                context.setAutoCommit(true);
                doBiz(msgs.get(0));

                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        // ]] 注2：顺序消息消费

        // 5. 启动消费者(必须在注册完消息监听器后启动，否则会报错)
        consumer.start();

        System.out.println("已启动消费者");
    }

要满足顺序消息，不仅在发送时需要保证顺序，消费时也需要做相应处理，要实现顺序消息，消费时不能使用MessageListenerConcurrently类进行监听，该类为并发消费，必须使用MessageListenerOrderly才能保证消息消费时是有顺序的。

6：生产者发送事务消息
在有些场景下，必须保证业务代码没有异常，提交消息，代码发生异常，不能发送消息，这时将会用到事务消息，代码示例如下：

public class TransactionMessageProducer {
    /**
     * 事务消息监听实现
     */
    private final static TransactionListener transactionListenerImpl = new TransactionListener() {

        /**
         * 在发送消息成功时执行本地事务
         * @param msg
         * @param arg producer.sendMessageInTransaction的第二个参数
         * @return 返回事务状态
         * LocalTransactionState.COMMIT_MESSAGE：提交事务，提交后broker才允许消费者使用
         * LocalTransactionState.RollbackTransaction：回滚事务，回滚后消息将被删除，并且不允许别消费
         * LocalTransactionState.Unknown：中间状态，表示MQ需要核对，以确定状态
         */
        @Override
        public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
            // TODO 开启本地事务（实际就是我们的jdbc操作）

            // TODO 执行业务代码（插入订单数据库表）
            // int i = orderDatabaseService.insert(....)
            // TODO 提交或回滚本地事务(如果用spring事务注解，这些都不需要我们手工去操作)

            // 模拟一个处理结果
            int index = 8;
            /**
             * 模拟返回事务状态
             */
            switch (index) {
                case 3:
                    System.out.printf("本地事务回滚，回滚消息，id:%s%n", msg.getKeys());
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                case 5:
                case 8:
                    return LocalTransactionState.UNKNOW;
                default:
                    System.out.println("事务提交，消息正常处理");
                    return LocalTransactionState.COMMIT_MESSAGE;
            }
        }

        /**
         * Broker端对未确定状态的消息发起回查，将消息发送到对应的Producer端（同一个Group的Producer），
         * 由Producer根据消息来检查本地事务的状态，进而执行Commit或者Rollback
         * @param msg
         * @return 返回事务状态
         */
        @Override
        public LocalTransactionState checkLocalTransaction(MessageExt msg) {
            // 根据业务，正确处理： 订单场景，只要数据库有了这条记录，消息应该被commit
            String transactionId = msg.getTransactionId();
            String key = msg.getKeys();
            System.out.printf("回查事务状态 key:%-5s msgId:%-10s transactionId:%-10s %n", key, msg.getMsgId(), transactionId);

            if ("id_5".equals(key)) { // 刚刚测试的10条消息， 把id_5这条消息提交，其他的全部回滚。
                System.out.printf("回查到本地事务已提交，提交消息，id:%s%n", msg.getKeys());
                return LocalTransactionState.COMMIT_MESSAGE;
            } else {
                System.out.printf("未查到本地事务状态，回滚消息，id:%s%n", msg.getKeys());
                return LocalTransactionState.ROLLBACK_MESSAGE;
            }
        }
    };

    public static void main(String[] args) throws MQClientException, IOException {
        // 1. 创建事务生产者对象
        // 和普通消息生产者有所区别，这里使用的是TransactionMQProducer
        TransactionMQProducer producer = new TransactionMQProducer("GROUP_TEST");

        // 2. 设置NameServer的地址，如果设置了环境变量NAMESRV_ADDR，可以省略此步
        producer.setNamesrvAddr("192.168.100.242:9876");

        // 3. 设置事务监听器
        producer.setTransactionListener(transactionListenerImpl);

        // 4. 启动生产者
        producer.start();

        for (int i = 0; i < 10; i++) {
            String content = "Hello transaction message " + i;
            Message message = new Message("TopicTest", "TagA", "id_" + i, content.getBytes(RemotingHelper.DEFAULT_CHARSET));

            // 5. 发送消息(发送一条新订单生成的通知)
            SendResult result = producer.sendMessageInTransaction(message, i);

            System.out.printf("发送结果：%s%n", result);
        }

        System.in.read();
        // 6. 停止生产者
        producer.shutdown();
    }
}

发送事务消息时，需指定事务监听器，在监听器中实现对应的方法，实现
LocalTransactionState方法，在该方法中定义具体的业务代码，当代码异常时，可返回ROLLBACK_MESSAGE，MQ会自动取消该条消息的发送，当无异常时，返回COMMIT_MESSAGE则会提交本地事务，消息会真正的被投递至broker中，Broker端对未确定状态的消息会发起回查，将会调用LocalTransactionState方法，该方法中可根据业务情况返回对应的事务状态，进行事务的提交，~完

创作不易，如对您有所帮助，欢迎点赞关注，谢谢！

背影漫湿了脸

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
rocketmq的使用及高级特性

MQ的使用场景1：跨系统的数据传递2：高并发流量削峰3：异步处理…常用的消息中间件ActiveMq、RabbitMq、Kafka、RockeMq，本文主要讲述RockeMq，个中区别，请自行百度RockeMq是由阿里捐赠给Apache的一款分布式，队列模型的开源消息中间件，经历了淘宝双十一的考验，性能和功能完备性，同级最强，使用java语言开发。RockeMq的基本概念Producer：消息生产者，负责生产消息Consumer：消息消费者，负责消费消息ProducerGroup：生产者组
复制链接

扫一扫