RocketMQ实战

最新推荐文章于 2024-08-21 17:32:49 发布
最新推荐文章于 2024-08-21 17:32:49 发布
阅读量300 收藏 2
点赞数
分类专栏： 消息队列 文章标签： activemq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38900306/article/details/113096960
版权

1.新建开发环境

新建一个maven工程,在pom.xml文件中加入如下依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>RocketMQ_Demo</artifactId>
        <groupId>com.kebo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rocketmq_demo</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.4.0</version>
        </dependency>
    </dependencies>


</project>

2.思想分析

2.1生产者

1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者producer

2.2消费者

1.创建消费者Consumer，制定消费者组名
2.指定Nameserver地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer

3.基本样例

3.1发送消息

3.1.1发送同步消息

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

package com.kebo.base.producer;

import org.apache.rocketmq.client.exception.MQBrokerException;
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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

/**
 * @description: 发送同步消息
 * @author: kb
 * @create: 2021-01-24 20:54
 **/
public class SyncProducer {
    public static void main(String[] args) {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        try {
            defaultMQProducer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
//        4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message();
            message.setTopic("base");
            message.setTags("baseTag");
            message.setBody(("Hello World"+i).getBytes());
//        5.发送消息
            try {
                SendResult result = defaultMQProducer.send(message);
                SendStatus sendStatus = result.getSendStatus();
                String msgId = result.getMsgId();
                int queueId = result.getMessageQueue().getQueueId();
                System.out.println(sendStatus);
                System.out.println(msgId);
                System.out.println(queueId);
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        6.关闭生产者producer
        defaultMQProducer.shutdown();
    }
}

3.1.2发送异步消息

异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。

package com.kebo.base.producer;

import org.apache.rocketmq.client.exception.MQClientException;
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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

/**
 * @description: 发送异步消息
 * @author: kb
 * @create: 2021-01-24 22:11
 **/
public class AsyncProducer {
    public static void main(String[] args) {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        try {
            defaultMQProducer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
//        4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message();
            message.setTopic("base");
            message.setTags("asyncTag");
            message.setBody(("Hello World" + i).getBytes());
//        5.发送异步消息
            try {
                defaultMQProducer.send(message, new SendCallback() {
                    /** 
                    * @Description: 发送成功的回调函数 
                    * @Param: [sendResult] 
                    * @return: void
                    * @Author: kb
                    * @Date: 2021/1/24
                    * @Time: 22:13
                            
                    */ 
                    public void onSuccess(SendResult sendResult) {
                        System.out.println("发送成功"+sendResult);
                    }

                    /** 
                    * @Description: 发送失败的回调函数
                    * @Param: [throwable] 
                    * @return: void
                    * @Author: kb
                    * @Date: 2021/1/24
                    * @Time: 22:14
                            
                    */ 
                    public void onException(Throwable throwable) {
                        System.out.println("发送异常"+throwable);
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        6.关闭生产者producer
        defaultMQProducer.shutdown();
    }
}

3.1.3发送单向消息

这种方式主要用在不特别关心发送结果的场景，例如日志发送。

package com.kebo.base.producer;

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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

/**
 * @description: 发送单向消息
 * @author: kb
 * @create: 2021-01-25 18:44
 **/
public class OneWayProducer {
    public static void main(String[] args) {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        try {
            defaultMQProducer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
//        4.创建消息对象，指定主题Topic、Tag和消息体
        for (int i = 0; i < 10; i++) {
            Message message = new Message();
            message.setTopic("base");
            message.setTags("oneWayTag");
            message.setBody(("Hello World" + i).getBytes());
//        5.发送消息
            try {
                //发送单向消息
                defaultMQProducer.sendOneway(message);
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        6.关闭生产者producer
        defaultMQProducer.shutdown();
    }
}

3.2消费消息

package com.kebo.base.consumer;

import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer;
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.message.MessageExt;

import java.util.List;

/**
 * @description: 消息接收者
 * @author: kb
 * @create: 2021-01-25 19:09
 **/
public class Consumer {
    public static void main(String[] args) {
//        1. 创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("defaultGroup");
//        2. 指定Nameserver地址
        defaultMQPushConsumer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3. 订阅主题Topic和Tag
        try {
            defaultMQPushConsumer.subscribe("base", "baseTag");
            //        4. 设置回调函数，处理消息
            defaultMQPushConsumer.registerMessageListener(new MessageListenerConcurrently() {
                //接受消息内容
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                    for (int i = 0; i <list.size() ; i++) {
                        System.out.println(new String(list.get(i).getBody()));
                    }
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                }
            });
        } catch (MQClientException e) {
            e.printStackTrace();
        }

//        5. 启动消费者consumer
        try {
            defaultMQPushConsumer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }
}

消费消息有两种模式,一种是负载均衡模式,另一种是广播模式,可以通过代码修改

 //设置消费模式为广播模式,默认为负载均衡
defaultMQPushConsumer.setMessageModel(MessageModel.BROADCASTING);

3.3顺序消息

消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。

顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。

下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。

package com.kebo.order;

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

/**
 * @description:
 * @author: kb
 * @create: 2021-01-25 19:43
 **/
public class OrderStep {
    private long orderId;
    private String describe;

    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(long orderId) {
        this.orderId = orderId;
    }

    public String getDescribe() {
        return describe;
    }

    public void setDescribe(String describe) {
        this.describe = describe;
    }

    @Override
    public String toString() {
        return "OrderStep{" +
                "orderId=" + orderId +
                ", describe='" + describe + '\'' +
                '}';
    }

    public static List<OrderStep> buildOrders() {
        List<OrderStep> orderStepList = new ArrayList<OrderStep>();

        OrderStep orderDemo01 = new OrderStep();
        orderDemo01.setOrderId(1039L);
        orderDemo01.setDescribe("创建");
        orderStepList.add(orderDemo01);

        OrderStep orderDemo02 = new OrderStep();
        orderDemo02.setOrderId(1065L);
        orderDemo02.setDescribe("创建");
        orderStepList.add(orderDemo02);

        OrderStep orderDemo03 = new OrderStep();
        orderDemo03.setOrderId(7235L);
        orderDemo03.setDescribe("创建");
        orderStepList.add(orderDemo03);


        OrderStep orderDemo04 = new OrderStep();
        orderDemo04.setDescribe("完成");
        orderDemo04.setOrderId(1039L);
        orderStepList.add(orderDemo04);

        OrderStep orderDemo05 = new OrderStep();
        orderDemo05.setOrderId(1065L);
        orderDemo05.setDescribe("完成");
        orderStepList.add(orderDemo05);

        OrderStep orderDemo06 = new OrderStep();
        orderDemo06.setOrderId(7235L);
        orderDemo06.setDescribe("完成");
        orderStepList.add(orderDemo06);
        return orderStepList;
    }
}


package com.kebo.order;

import org.apache.rocketmq.client.exception.MQClientException;
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 java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 * @author: kb
 * @create: 2021-01-25 19:50
 **/
public class Producer {
    public static void main(String[] args) {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        try {
            defaultMQProducer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
//        4.创建消息对象，指定主题Topic、Tag和消息体
        List<OrderStep> orderStepList = OrderStep.buildOrders();
        for (int i = 0; i < orderStepList.size(); i++) {
            Message message = new Message();
            message.setTopic("base");
            message.setTags("baseTag");
            //message.setKeys("i+" + i);
            message.setBody(orderStepList.get(i).toString().getBytes());
//        5.发送消息
            try {
                /*
                参数一:消息对象
                参数二:消息队列的选择器
                参数三:选择队列的业务标识 (订单ID)
                 */
                SendResult result = defaultMQProducer.send(message, new MessageQueueSelector() {
                    /**
                     * @Description:
                     * @Param: [list消息队列, message消息对象, 业务表示的参数]
                     * @return: org.apache.rocketmq.common.message.MessageQueue
                     * @Author: kb
                     * @Date: 2021/1/25
                     * @Time: 19:58

                     */
                    public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                        long orderId = Long.valueOf(String.valueOf(o)).longValue();
                        long index = orderId % list.size();
                        return list.get((int) index);
                    }

                }, orderStepList.get(i).getOrderId());
                System.out.println(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        6.关闭生产者producer
        defaultMQProducer.shutdown();
    }
}



package com.kebo.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.message.MessageExt;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 * @author: kb
 * @create: 2021-01-25 20:10
 **/
public class Consumer {
    public static void main(String[] args) {
        //        1. 创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("defaultGroup");
//        2. 指定Nameserver地址
        defaultMQPushConsumer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3. 订阅主题Topic和Tag
        try {
            defaultMQPushConsumer.subscribe("base", "baseTag");
            //        4. 设置回调函数，处理消息
            defaultMQPushConsumer.registerMessageListener(new MessageListenerOrderly() {
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                    for (int i = 0; i < list.size(); i++) {
                        System.out.println(Thread.currentThread().getName()+"->"+new String(list.get(i).getBody()));
                    }
                    /*try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                    return ConsumeOrderlyStatus.SUCCESS;
                }
            });
        } catch (MQClientException e) {
            e.printStackTrace();
        }

//        5. 启动消费者consumer
        try {
            defaultMQPushConsumer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }
}

3.4延迟消息

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

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

private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
package com.kebo.delay;

import com.kebo.order.OrderStep;
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.message.Message;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 * @author: kb
 * @create: 2021-01-25 21:15
 **/
public class Producer {
    public static void main(String[] args) throws Exception {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        try {
            defaultMQProducer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
//        4.创建消息对象，指定主题Topic、Tag和消息体
        List<OrderStep> orderStepList = OrderStep.buildOrders();
        for (int i = 0; i < orderStepList.size(); i++) {
            Message message = new Message();
            message.setTopic("delayBase");
            message.setTags("baseTag");
            message.setBody(orderStepList.get(i).toString().getBytes());
            //设定延迟时间
            message.setDelayTimeLevel(3);
//        5.发送消息
            SendResult result = defaultMQProducer.send(message);
            System.out.println(result);
        }

        TimeUnit.SECONDS.sleep(1);

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



package com.kebo.delay;

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.common.message.MessageExt;

import java.util.List;

/**
 * @description:
 * @author: kb
 * @create: 2021-01-25 21:15
 **/
public class Consumer {
    public static void main(String[] args) throws Exception {
        // 实例化消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("defaultGroup");
        //        2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
        // 订阅Topics
        consumer.subscribe("delayBase", "baseTag");
        // 注册消息监听者
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> messages, ConsumeConcurrentlyContext context) {
                for (MessageExt message : messages) {
                    System.out.println("Receive message[msgId=" + message.getMsgId() + "] " + (System.currentTimeMillis() - message.getBornTimestamp()) + "ms later");
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 启动消费者
        consumer.start();
    }
}

3.5批量消息

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

package com.kebo.batch;

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.message.MessageExt;

import java.util.List;

/**
 * @description: 消息接收者
 * @author: kb
 * @create: 2021-01-25 19:09
 **/
public class Consumer {
    public static void main(String[] args) throws Exception {
//        1. 创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("defaultGroup");
//        2. 指定Nameserver地址
        defaultMQPushConsumer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3. 订阅主题Topic和Tag

        defaultMQPushConsumer.subscribe("base", "Tag1");
        //        4. 设置回调函数，处理消息
        defaultMQPushConsumer.registerMessageListener(new MessageListenerConcurrently() {
            //接受消息内容
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (int i = 0; i < list.size(); i++) {
                    System.out.println(new String(list.get(i).getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
//        5. 启动消费者consumer

        defaultMQPushConsumer.start();

    }
}



package com.kebo.batch;

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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @description: 发送批量消息
 * @author: kb
 * @create: 2021-01-24 20:54
 **/
public class SyncProducer {
    public static void main(String[] args) throws Exception {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        defaultMQProducer.start();

        List<Message> messageList = new ArrayList<Message>();
//        4.创建消息对象，指定主题Topic、Tag和消息体
        Message message1 = new Message("base","Tag1",("Hello World"+1).getBytes());
        Message message2 = new Message("base","Tag1",("Hello World"+2).getBytes());
        Message message3 = new Message("base","Tag1",("Hello World"+3).getBytes());
        messageList.add(message1);
        messageList.add(message2);
        messageList.add(message3);
//        5.发送批量消息
        SendResult result = defaultMQProducer.send(messageList);
        System.out.println(result);
//        6.关闭生产者producer
        defaultMQProducer.shutdown();
    }
}

如果消息大于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;
   }
}
//把大的消息分裂成若干个小的消息
ListSplitter splitter = new ListSplitter(messages);
while (splitter.hasNext()) {
  try {
      List<Message>  listItem = splitter.next();
      producer.send(listItem);
  } catch (Exception e) {
      e.printStackTrace();
      //处理error
  }
}

3.6过滤消息

在大多数情况下，TAG是一个简单而有用的设计，其可以来选择您想要的消息。例如：
 


DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_EXAMPLE");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");

消费者将接收包含TAGA或TAGB或TAGC的消息。但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。在这种情况下，可以使用SQL表达式筛选消息。SQL特性可以通过发送消息时的属性来进行计算。在RocketMQ定义的语法下，可以实现一些简单的逻辑.

package com.kebo.filter.sql;

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.common.message.MessageExt;

import java.util.List;

/**
 * @description: 消息接收者
 * @author: kb
 * @create: 2021-01-25 19:09
 **/
public class Consumer {
    public static void main(String[] args) throws Exception{
//        1. 创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("defaultGroup");
//        2. 指定Nameserver地址
        defaultMQPushConsumer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3. 订阅主题Topic和Tag

        //defaultMQPushConsumer.subscribe("base", "Tag1||Tag2");
        defaultMQPushConsumer.subscribe("base", MessageSelector.bySql("i>5"));
        //        4. 设置回调函数，处理消息
        defaultMQPushConsumer.registerMessageListener(new MessageListenerConcurrently() {
            //接受消息内容
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (int i = 0; i < list.size(); i++) {
                    System.out.println(new String(list.get(i).getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
//        5. 启动消费者consumer

        defaultMQPushConsumer.start();

    }
}


package com.kebo.filter.sql;

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

/**
 * @description: 发送批量消息
 * @author: kb
 * @create: 2021-01-24 20:54
 **/
public class SyncProducer {
    public static void main(String[] args) throws Exception {
//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer("defaultGroup");
//        2.指定Nameserver地址
        defaultMQProducer.setNamesrvAddr("192.168.31.205:9876;192.168.31.222:9876");
//        3.启动producer
        defaultMQProducer.start();

        for (int i = 0; i < 10; i++) {
//        4.创建消息对象，指定主题Topic、Tag和消息体
            Message message = new Message("base", "Tag2", ("Hello World" + i).getBytes());
            message.putUserProperty("i", String.valueOf(i));
//        5.发送批量消息
            SendResult result = defaultMQProducer.send(message);
            System.out.println(result);
        }
//        6.关闭生产者producer
        defaultMQProducer.shutdown();
    }
}

3.7事务消息

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

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: 中间状态，它代表需要检查消息队列来确定状态。
helloworld_kb
关注
专栏目录
RocketMQ（一）：Linux安装RocketMQ和常用命令
qq_28834355的博客
01-30 1171
下载安装 版本：4.8.0 下载地址：https://www.apache.org/dyn/closer.cgi?path=rocketmq/4.8.0/rocketmq-all-4.8.0-source-release.zip 下载成功后，上传到 /opt 目录，并解压
Springboot 整合RocketMQ
lisaihang96的博客
10-24 3690
因为已经保存用户的基本信息，保存上状态标志位（0），消费者计算完后，根据id更新该数据标志位（1），计算异常问题更新标志位（2），每日定时任务对异常数据进行批量推送重新计算。根据用户提交的手机号计算用户数据，计算用户实时数据比较长数据量大的3-5分钟，数据小的1分钟上下，移动端不需要实时放回用户计算数据，所以接口保存完用户基本信息。此机制只能针对 消息队列宕机 网络异常或队列数据丢失问题。业务场景：该接口为H5、小程序提供，收集用户信息姓名、手机号、身份证号、地区等信息。4. 监听器事务配置。
Springboot整合RocketMQ
GSON的博客
04-17 3362
顺序消息是 Apache RocketMQ 提供的一种高级消息类型，支持消费者按照发送消息的先后顺序获取消息，从而实现业务场景中的顺序处理。普通消息为 Apache RocketMQ 中最基础的消息 ， 普通消息一般应用于微服务解耦、事件驱动、数据集成等场景，这些场景大多数要求数据传输通道具有可靠传输的能力，且对消息的处理时机、处理顺序没有特别要求。封装了RocketMQ的生产者API，提供了一系列简单易用的方法，用于发送不同类型的消息， 后面的例子都会用到它。
RocketMQ
最新发布
qq_53793319的博客
08-21 996
RocketMQ 是一款功能强大、灵活的分布式消息队列系统，支持高性能、高可靠性和高可用性。它在处理大规模消息传递和分布式系统集成中表现出色，适用于各种应用场景。
Springboot 整合 RocketMQ
原名：@程序员大禹
06-25 1657
pull方式里，取消息的过程需要用户自己写，首先通过打算消费的Topic拿到MessageQueue的集合，遍历MessageQueue集合，然后针对每个MessageQueue批量取消息，一次取完后，记录该队列下一次要取的开始offset，直到取完了，再换另一个MessageQueue。缺点：消费者从server端拉消息，主动权在消费端，可控性好，但是时间间隔不好设置，间隔太短，则空请求会多，浪费资源，间隔太长，则消息不能及时处理。推荐使用PushConsumer，直接上代码！
SpringBoot整合RocketMQ
上善若泪
05-08 5957
先看看每次发送消息或者消费消息消息发送成功或者失败要打印消息日志，用于业务排查问题。如果消息量较少，建议在消费入口方法打印消息，消费耗时等，方便后续排查问题。RocketMQ无法避免消息重复（），所以如果业务对消费重复非常敏感，务必要在业务层面进行去重处理。可以借助关系数据库进行去重。首先需要确定消息的唯一键，可以是msgId，也可以是消息内容中的唯一标识字段，例如订单Id等。接下来讨论的是在RocketMQ中发送消息时选择何种消息类型最为合适。在RocketMQ发送Json对象。
RocketMQ实战与原理
10-17
Producer: 生产者，负责生产消息并发送到消息引擎。测评开始时，测评程序会启动10~20个Producer，每个Producer在一条线程中，然后每个Producer随机生产某个Topic或者附属于Queue的消息并发送到消息引擎；...
rocketmq实战与源码分析.zip
03-13
由阿里巴巴根据[中间件兴趣圈]RocketMQ专栏文章，整理的两本电子书，总的来看主要从如下三部分进行展开： １线上故障分析结合笔者日均消息流转千亿级别的消息集群的运维经验、网友的问题提问整理提取的精华。 2 源码...
RocketMQ实战 源码解析
04-06
消息队列（Message Queue，简称MQ）是企业级互联网架构的核心产品，服务于整个阿里巴巴集团已超过 10 年，经过阿里巴巴交易核心链路反复打磨与历年双十一购物狂欢节的严苛考验，是一个真正具备低延迟、高并发、高...
java -RocketMQ实战视频教程（上下全集）
01-25
根据提供的文件信息，我们可以从以下几个方面来探讨与“java -RocketMQ实战视频教程（上下全集）”相关的知识点： ### RocketMQ简介 RocketMQ是由阿里巴巴开源的一款分布式消息中间件，它具有高性能、低延迟的特点...
SpringBoot整合RocketMq，rocketMq
08-24
SpringBoot整合RocketMq
SpringBoot集成RocketMQ
Ahjbvj的博客
07-14 6695
MQ（Message Queue）是一种跨进程的通信机制，用于传递消息。使用MQ之后可以实现异步解耦和流量消峰的功能。在微服务项目中是一个常用的组件。RocketMQ的使用需要先启动RocketMQ的服务，这样才可以在后端连接RocketMQ并使用RocketMQ传递消息。
Springboot整合RocketMq
xdscode的博客
07-30 1129
如果业务需要高性能、灵活的路由配置和对在线业务的响应时延有较高要求，可以考虑使用RocketMQ；如果业务需要高并发、高吞吐量、健壮稳定且易于使用和管理的消息队列产品，可以考虑使用RabbitMQ。@RocketMQMessageListener表示这是一个rocketmq的消费者，该注解只能用在类上面 topic：指定需要消费的队列。解决办法：https://blog.csdn.net/LLittleF/article/details/130689449。解释一下消费者中的代码。
SpringBoot 集成 RocketMQ
魂-淡
03-20 7794
RocketMQ 主要由 Producer、Broker、Consumer 三部分组成，其中 Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。Broker 在实际部署过程中对应一台服务器，每个 Broker 可以存储多个 Topic 的消息，每个Topic 的消息也可以分片存储于不同的 Broker。消息中转角色，负责存储消息、转发消息。表示一类消息的集合，每个主题包含若干条消息，每条消息只能属于一个主题，是RocketMQ 进行消息订阅的基本单位。
rocketmq实战
07-27
RocketMQ是一个开源的分布式消息中间件，具有高吞吐量、高可用性和可伸缩性的特点。它是由阿里巴巴集团开发和维护的，被广泛应用于大规模分布式系统中。 在实战中，使用RocketMQ可以实现消息的可靠传输和异步通信，适用于各种场景，如订单处理、日志收集、实时数据同步等。以下是一些RocketMQ的实战应用场景和操作步骤： 1. 安装和配置RocketMQ：首先需要下载和安装RocketMQ，然后进行相关的配置，包括名称服务器（NameServer）和消息代理（Broker）的配置。 2. 创建Topic和Producer：在RocketMQ中，消息通过Topic进行分类，Producer负责发送消息到指定的Topic。可以使用命令行工具或者编程方式创建Topic和Producer。 3. 创建Consumer和订阅Topic：Consumer负责订阅指定的Topic，并处理接收到的消息。可以使用命令行工具或者编程方式创建Consumer，并订阅感兴趣的Topic。 4. 发送和接收消息：通过Producer发送消息到指定的Topic，Consumer订阅该Topic并接收消息进行处理。可以使用RocketMQ提供的API进行消息的发送和接收操作。 5. 实现消息的可靠性传输：RocketMQ可以保证消息的可靠性传输，即使在发送或接收过程中出现异常，也能够保证消息不丢失。可以通过配置参数和使用事务消息等方式来实现可靠性传输。 6. 监控和管理RocketMQ：RocketMQ提供了一系列的监控和管理工具，可以对消息的发送和接收进行监控，以及管理Topic和Consumer等。 以上是RocketMQ的简单实战应用场景和操作步骤，希望对你有所帮助。详细的使用方法和更多高级功能可以参考RocketMQ的官方文档和示例代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值