RocketMQ消息发送样例

最新推荐文章于 2024-05-03 11:44:49 发布
最新推荐文章于 2024-05-03 11:44:49 发布
阅读量1.1k 收藏 22
点赞数 12
文章标签： rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muriyue6/article/details/136804863
版权

RocketMQ消息发送样例

  • 导入MQ客户端依赖
<dependency>
	<groupId>org.apache.rocketmq</groupId>
	<artifactId>rocketmq-client</artifactId>
	<version>4.4.0</version>
</dependency>
  • 消息发送者步骤分析
1.创建消息生产者producer，并指定生产者组名
2.指定NameServer地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者producer
  • 消息消费者步骤分析
1.创建消费者Consumer，指定消费者组名
2.指定NameServer地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer

基本样例

消息发送

1) 发送同步消息

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

package com.mry.rocketmqdemo.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 org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

/**
 * 发送同步消息
 */
public class SyncProducer {
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag1", ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息接收队列ID
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送结果：" + result + ",消息ID："+ msgId + ",队列ID：" + queueId);

            TimeUnit.SECONDS.sleep(1);
        }


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

    }
}

执行结果：

发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF68E20000, offsetMsgId=C0A84B8000002A9F0000000000001234, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=7],消息ID：0200000173A418B4AAC284BF68E20000,队列ID：0
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF6CDE0001, offsetMsgId=C0A84B8000002A9F000000000000131D, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=1], queueOffset=5],消息ID：0200000173A418B4AAC284BF6CDE0001,队列ID：1
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF70C90002, offsetMsgId=C0A84B8000002A9F0000000000001406, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=4],消息ID：0200000173A418B4AAC284BF70C90002,队列ID：2
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF74B50003, offsetMsgId=C0A84B8000002A9F00000000000014EF, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=4],消息ID：0200000173A418B4AAC284BF74B50003,队列ID：3
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF78A00004, offsetMsgId=C0A84B8000002A9F00000000000015D8, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=8],消息ID：0200000173A418B4AAC284BF78A00004,队列ID：0
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF7C8C0005, offsetMsgId=C0A84B8000002A9F00000000000016C1, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=1], queueOffset=6],消息ID：0200000173A418B4AAC284BF7C8C0005,队列ID：1
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF80770006, offsetMsgId=C0A84B8000002A9F00000000000017AA, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=5],消息ID：0200000173A418B4AAC284BF80770006,队列ID：2
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF84640007, offsetMsgId=C0A84B8000002A9F0000000000001893, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=5],消息ID：0200000173A418B4AAC284BF84640007,队列ID：3
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF88500008, offsetMsgId=C0A84B8000002A9F000000000000197C, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=9],消息ID：0200000173A418B4AAC284BF88500008,队列ID：0
发送结果：SendResult [sendStatus=SEND_OK, msgId=0200000173A418B4AAC284BF8C3B0009, offsetMsgId=C0A84B8000002A9F0000000000001A65, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=1], queueOffset=7],消息ID：0200000173A418B4AAC284BF8C3B0009,队列ID：1
2) 发送异步消息

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

package com.mry.rocketmqdemo.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.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

/**
 * 发送异步消息
 */
public class AsyncProducer {
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag2", ("Hello World" + i).getBytes());
            //5.发送异步消息
            producer.send(msg, new SendCallback() {
                /**
                 * 发送成功的回调函数
                 * @param sendResult
                 */
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送结果：" + sendResult);
                }

                /**
                 * 发送失败的回调函数
                 * @param throwable
                 */
                @Override
                public void onException(Throwable throwable) {
                    System.out.println("发送异常：" + throwable);
                }
                
            });

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

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

    }
}

执行结果：

发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C228090000, offsetMsgId=C0A84B8000002A9F0000000000001B4E, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=6]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C228090001, offsetMsgId=C0A84B8000002A9F0000000000001C37, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=6]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C228260002, offsetMsgId=C0A84B8000002A9F0000000000001D20, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=1], queueOffset=8]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C22C0E0003, offsetMsgId=C0A84B8000002A9F0000000000001E09, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=7]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C22FF70004, offsetMsgId=C0A84B8000002A9F0000000000001EF2, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=10]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C233DF0005, offsetMsgId=C0A84B8000002A9F0000000000001FDB, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=11]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C237C80006, offsetMsgId=C0A84B8000002A9F00000000000020C4, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=7]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C23BB00007, offsetMsgId=C0A84B8000002A9F00000000000021AD, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=1], queueOffset=9]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C23F990008, offsetMsgId=C0A84B8000002A9F0000000000002296, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=8]
发送结果：SendResult [sendStatus=SEND_OK, msgId=02000001874C18B4AAC284C243810009, offsetMsgId=C0A84B8000002A9F000000000000237F, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=0], queueOffset=12]
3) 单向发送消息

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

package com.mry.rocketmqdemo.base.producer;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

/**
 * 发送单向消息
 */
public class OneWayProducer {
    public static void main(String[] args) throws MQClientException, InterruptedException, RemotingException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 3; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag3", ("Hello World" + i).getBytes());
            //5.发送单向消息
            producer.sendOneway(msg);
            //线程睡1秒
            TimeUnit.SECONDS.sleep(10000);
        }

        producer.shutdown();
    }
}

执行结果：

无返回结果输出
Process finished with exit code -1

消费消息

1) 负载均衡模式

消费者采用负载均衡方式消费消息，多个消费者共同消费队列消息，每个消费者处理的消息不同

package com.mry.rocketmqdemo.base.consumer;

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;

/**
 * 消息的接收者
 */
public class Consumer {
    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("base", "Tag1");

		//设定消费模式：负载均衡(默认)|广播模式
        consumer.setMessageModel(MessageModel.CLUSTERING);

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.println(list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

    }
    
}
2) 广播模式

消费者采用广播的方式消费消息，每个消费者消费的消息都是相同的。

package com.mry.rocketmqdemo.base.consumer;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

/**
 * 消息的接收者
 */
public class Consumer {
    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("base", "Tag1");

        //设定消费模式：负载均衡(默认)|广播模式
        consumer.setMessageModel(MessageModel.BROADCASTING);

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.println(list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

    }

}

顺序消息

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

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

顺序实体类

package com.mry.rocketmqdemo.order;

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

/**
 * 订单实体类
 */
public class OrderStep {
    private long orderId;
    private String desc;

    public long getOrderId() {
        return orderId;
    }

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

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

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

    public static List<OrderStep> buildOrders() {
        //  1039L   : 创建    付款 推送 完成
        //  1065L   ： 创建   付款
        //  7235L   ：创建    付款
        List<OrderStep> orderList = new ArrayList<OrderStep>();

        OrderStep orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1065L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(7235L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1065L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(7235L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1065L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("推送");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(7235L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        return orderList;
    }

}

顺序消息生产

package com.mry.rocketmqdemo.order;

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.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.exception.RemotingException;
import java.util.List;

/**
 * Producer，发送顺序消息
 */
public class Producer {
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();
        //构建消息集合
        List<OrderStep> orderSteps = OrderStep.buildOrders();
        //发送消息
        for (int i = 0; i < orderSteps.size(); i++) {
            Message msg = new Message("OrderTopic", "Order", "i" + i, orderSteps.get(i).toString().getBytes());

            /**
             * 参数一：消息对象
             * 参数二：消息队列的选择器
             * 参数三：选择队列的业务标识（订单ID）
             */
            SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                /**
                 *
                 * @param list: 队列集合
                 * @param message：消息对象
                 * @param o: 业务标识的参数
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    long orderId = (long) o;
                    long index = orderId % list.size();
                    return list.get((int) index);
                }
            }, orderSteps.get(i).getOrderId());

            System.out.println("发送结果：" + sendResult);
        }

        producer.shutdown();
    }
}

顺序消息消费

package com.mry.rocketmqdemo.order;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.List;

public class Consumer {
    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指的Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic
        consumer.subscribe("OrderTopic", "*");

        //4.注册消息监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {
            /**
             *
             * @param list
             * @param consumeOrderlyContext
             * @return
             */
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                for (MessageExt msg : list) {
                    System.out.println("线程名称：" + Thread.currentThread().getName() + "；消费消息：" + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }

        });

        //5.启动消费者
        consumer.start();

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

延时消息

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

启动消息消费者

package com.mry.rocketmqdemo.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.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("DelayTopic", "*");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list) {
                    System.out.println("消息ID：" + msg.getMsgId() + "，延迟时间：" + (System.currentTimeMillis() - msg.getStoreTimestamp()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

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

    }

}

发送延时消息

package com.mry.rocketmqdemo.delay;

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 org.apache.rocketmq.remoting.exception.RemotingException;
import java.util.concurrent.TimeUnit;

public class Producer {
    public static void main(String[] args) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("DelayTopic", "Tag1", ("Hello World" + i).getBytes());
            //设置延迟时间等级3，这个消息将在10s之后发送(现在只支持固定的几个时间，详看delayTimeLevel)
            msg.setDelayTimeLevel(3);
            //5.发送消息
            SendResult result = producer.send(msg, 100000);
            //发送状态
            SendStatus status = result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息接收队列ID
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送结果：" + result + ",消息ID："+ msgId + ",队列ID：" + queueId);

            TimeUnit.SECONDS.sleep(1);
        }


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

    }
}

验证

您将会看到消息的消费比存储时间晚10秒

使用限制

// org/apache/rocketmq/store/config/MessageStoreConfig.java
private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";

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

批量消息

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

发送批量消息

如果您每次只发送不超过4MB的消息，则很容易使用批处理，样例如下：

package com.mry.rocketmqdemo.batch;

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 org.apache.rocketmq.remoting.exception.RemotingException;

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

public class Producer {
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        List<Message> msgs = new ArrayList<>();

        //4.创建消息对象，指定主题Topic、Tag和消息体
        /**
         * 参数一：消息主题Topic
         * 参数二：消息Tag
         * 参数三：消息内容
         */
        Message msg1 = new Message("BatchTopic", "Tag1", ("Hello World" + 1).getBytes());
        Message msg2 = new Message("BatchTopic", "Tag1", ("Hello World" + 2).getBytes());
        Message msg3 = new Message("BatchTopic", "Tag1", ("Hello World" + 3).getBytes());
        msgs.add(msg1);
        msgs.add(msg2);
        msgs.add(msg3);

        //5.发送消息
        SendResult result = producer.send(msgs, 100000);
        //发送状态
        SendStatus status = result.getSendStatus();
        //消息ID
        String msgId = result.getMsgId();
        //消息接收队列ID
        int queueId = result.getMessageQueue().getQueueId();
        System.out.println("发送结果：" + result + ",消息ID："+ msgId + ",队列ID：" + queueId);

        TimeUnit.SECONDS.sleep(1);


        //6.关闭生产者producer
        producer.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
  }
}

消息消费者

package com.mry.rocketmqdemo.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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("BatchTopic", "Tag1");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.println(list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

    }

}

过滤消息

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

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

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

------------
| message  |
|----------|  a > 5 AND b = 'abc'
| a = 10   |  --------------------> Gotten
| b = 'abc'|
| c = true |
------------
------------
| message  |
|----------|   a > 5 AND b = 'abc'
| a = 1    |  --------------------> Missed
| b = 'abc'|
| c = true |
------------

SQL基本语法

RocketMQ只定义了一些基本语法来支持这个特性。你也可以很容易地扩展它。

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

常量支持类型为：

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

只有使用push模式的消费者才能用使用SQL92标准的sql语句，接口如下：

public void subscribe(finalString topic, final MessageSelector messageSelector)

tag过滤消息生产者

package com.mry.rocketmqdemo.filter.tag;

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 org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("FilterTagTopic", "Tag1", ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.send(msg, 100000);
            //发送状态
            SendStatus status = result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息接收队列ID
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送结果：" + result + ",消息ID："+ msgId + ",队列ID：" + queueId);

            TimeUnit.SECONDS.sleep(1);
        }


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

    }

}

tag过滤消息消费者

package com.mry.rocketmqdemo.filter.tag;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("FilterTagTopic", "Tag1");

        //设定消费模式：负载均衡(默认)|广播模式
        设定消费模式：负载均衡(默认)|广播模式
        //consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.setMessageModel(MessageModel.BROADCASTING);

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.println(list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

    }

}

sql过滤消息生产者

package com.mry.rocketmqdemo.filter.sql;

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 org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("FilterSQLTopic", "Tag1", ("Hello World" + i).getBytes());

            msg.putUserProperty("i", String.valueOf(i));

            //5.发送消息
            SendResult result = producer.send(msg, 100000);
            //发送状态
            SendStatus status = result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息接收队列ID
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送结果：" + result + ",消息ID："+ msgId + ",队列ID：" + queueId);

            TimeUnit.SECONDS.sleep(1);
        }


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

    }

}

sql过滤消息消费者

package com.mry.rocketmqdemo.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.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("FilterSQLTopic", MessageSelector.bySql("i>5"));

        //设定消费模式：负载均衡(默认)|广播模式
        设定消费模式：负载均衡(默认)|广播模式
        //consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.setMessageModel(MessageModel.BROADCASTING);

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.println(list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

    }

}

事务消息

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

事务消息发送及提交

(1) 发送消息（half消息）。
(2) 服务端响应消息写入结果。
(3) 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。
(4) 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）。

事务补偿

(1) 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”
(2) Producer收到回查消息，检查回查消息对应的本地事务的状态
(3) 根据本地事务状态，重新Commit或者Rollback
其中，补偿阶段用于解决消息Commit或者Rollback发生超时或者失败的情况。

事务消息状态

事务消息共有三种状态，提交状态、回滚状态、中间状态：

  • TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
  • TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。
  • TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。

###创建事务性生产者

package com.mry.rocketmqdemo.transaction;

import org.apache.commons.lang3.StringUtils;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.*;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //1.创建消息生产者producer，并指定生产者组名
        TransactionMQProducer producer = new TransactionMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");

        //添加事务的监听器
        producer.setTransactionListener(new TransactionListener() {
            /**
             * 在该方法中执行本地事务
             * @param message
             * @param o
             * @return
             */
            @Override
            public LocalTransactionState executeLocalTransaction(Message message, Object o) {
                if(StringUtils.equals("TAGA", message.getTags())){
                    return LocalTransactionState.COMMIT_MESSAGE;
                }else if (StringUtils.equals("TAGB", message.getTags())){
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }else if (StringUtils.equals("TAGC", message.getTags())){
                    return LocalTransactionState.UNKNOW;
                }
                return LocalTransactionState.UNKNOW;
            }

            /**
             * 该方法是MQ进行消息事务状态回查
             * @param messageExt
             * @return
             */
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
                System.out.println("消息的Tag：" + messageExt.getTags());
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });

        //3.启动producer
        producer.start();

        String[] tags = {"TAGA", "TAGB", "TAGC"};
        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("TransactionTopic", tags[i], ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.sendMessageInTransaction(msg, null);
            //发送状态
            SendStatus status = result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息接收队列ID
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送结果：" + result + ",消息ID："+ msgId + ",队列ID：" + queueId);

            TimeUnit.SECONDS.sleep(1);
        }


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

    }

}

创建事务性消费者

package com.mry.rocketmqdemo.transaction;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，指定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.75.126:9876;192.168.75.128:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("TransactionTopic", "*");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                System.out.println(list);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.启动消费者consumer
        consumer.start();

    }

}

使用限制

  1. 事务消息不支持延时消息和批量消息。
  2. 为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的 transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N = transactionCheckMax ） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写 AbstractTransactionCheckListener 类来修改这个行为。
  3. 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于 transactionMsgTimeout 参数。
  4. 事务性消息可能不止一次被检查或消费。
  5. 提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
  6. 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。

demo资源

csdn的下载地址：https://download.csdn.net/download/muriyue6/89061803

mry6
关注
RocketMQ生产消费消息的样例
qq_57756904的博客
09-03 283
使用RocketMQ发送三种类型的消息：同步消息、异步消息和单向消息。其中前两种消息是可靠的，因为会有发送是否成功的应答。 使用RocketMQ来消费接收到的消息。
快速学习-RocketMQ样例
逍遥云恋
09-20 435
样例 1 基本样例 在基本样例中我们提供如下的功能场景： 使用RocketMQ发送三种类型的消息：同步消息、异步消息和单向消息。其中前两种消息是可靠的，因为会有发送是否成功的应答。 使用RocketMQ来消费接收到的消息。 1.1 加入依赖： maven: <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifact
RocketMQ 发送消息的基本案例
zhangsuhua0702的博客
12-28 878
RocketMQ 消息发送的基本样例 “一发、一存、一消费” 是消息中间件的本质，本文简单的记录来RocketMQ消息的基本样例，包含消息的发送（同步消息/异步消息/单向消息）、消息消费（负载均衡模式/广播模式）、顺序消息、延时消息、批量消息以及事务消息。 首先在测试项目中引入依赖 <dependency> <groupId>org.apache.rocketmq&l...
RocketMQ简介及发送消息样例
yanyf的博客
12-31 362
一、优缺点 二、产品比较 三、发送消息 1.基本样例：https://blog.csdn.net/yanyf2016/article/details/103786124 2.顺序消息：https://blog.csdn.net/yanyf2016/article/details/103786302 3.延时消息：https://blog.csdn.net/yanyf2016/...
RocketMQ介绍（三）——RocketMQ编程示例
liitdar的博客
02-27 9072
本系列文章主要介绍RocketMQ的相关知识，并通过示例代码介绍RocketMQ的使用方法。本文为系列文章的第三篇，主要介绍RocketMQ的C++客户端（即RocketMQ-Client-CPP），并通过简单的示例代码介绍RocketMQ编程技术。引用GitHub上对于RocketMQ-Client-CPP的介绍，内容如下：当前，RocketMQ-Client-CPP支持如下特性：RocketMQ-Client-CPP的安装是通过脚本build.sh实现的，不过在安装之前，需要确保开发环境中已经安装了下表
2024年阿里首次分享：内部（珠峰版)Java笔记，看完直接斩获12家offer
最新发布
m0_72758098的博客
05-03 524
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
RocketMQ (五) Springboot 整合 RocketMQ 收发消息样例
10-26 615
pom文件 创建 springboot 项目，添加rocketmq-spring-boot-starter依赖。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/...
消息中间件—RocketMQ消息发送
m0_62714732的博客
10-26 619
大道至简，消息队列可以简单概括为：“一发一存一收”，在这三个过程中消息发送最为简单，也比较容易入手，适合初中阶童鞋作为MQ研究和学习的切入点。因此，本篇主要从一条消息发送为切入点，详细阐述在RocketMQ这款分布式消息队列中发送一条普通消息的大致流程和细节。 一、RocketMQ网络架构图 RocketMQ分布式消息队列的网络部署架构图如下图所示（其中，包含了生产者Producer发送普通消息至集群的两条主线） RocketMQ部署架构.jpg 对于上图中几个角色的说明： （1）Na
springboot RocketMQ 批量消费 样例代码
06-08
在需要发送批量消息的地方，可以使用RocketMQ的批量消息发送器（DefaultMQProducer）来发送消息。例如： ``` @Autowired private DefaultMQProducer producer; public void sendBatchMessage() throws Exception {...
RocketMq几种消息发送
weixin_43828846的博客
03-17 541
1 基本样例 1.1 消息发送 1）发送同步消息 这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。 public class SyncProducer { public static void main(String[] args) throws Exception { // 1.创建消息生产者producer，并制定生产者组名 DefaultMQProducer producer = new DefaultMQProducer("group1
RcoketMQ 全部配置表
Xx__WangQi的博客
04-15 493
1、Broker配置 参数名 默认值 说明 listenPort 10911 接受客户端连接的监听端口 namesrvAddr null nameServer 地址 brokerIP1 网卡的 InetAddress 当前 broker 监听的 IP brokerIP2 跟 brokerIP1 一样 存在主从 bro..
rocket MQ 实战应用
拒绝躺平，适当内卷
10-14 3204
rocketmq 开发实例，springboot 集成
CentOS 8通过Docker-Compose部署RocketMQ 4.8.0(解决Broker启动的Exit 253问题)
HellHellNo的博客
07-27 3272
1、docker-compose.yml 该文件创建在自己想要的目录中 version: "3.9" #我的Docker是20.0.+的，因此用最高的3.9 services: rmqnamesrv: image: foxiswho/rocketmq:4.8.0 #4.8.0没有区分namesrv和broker container_name: rmqnamesrv restart: always ports: - 9876:9876 volumes:
RocketMQ的消息发送样例
YHJ
05-23 542
导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析r 1.创建消息生产者producer，并制定生产者组名 2....
RocketMq案例，生产者，消费者，消息订阅
热门推荐
涂作权的博客
10-24 1万+
1、RocketMq集群配置参考：http://blog.csdn.net/tototuzuoquan/article/details/78314572使用的rocketmq的ip等是上面博文提及的ip等内容2、创建RocketMq工程工程目录结构如下： 3、编写pom.xml文件<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http
RocketMQ消息发送和消费之基本样例
HX_2021
07-22 443
1、整体步骤 导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析 1.创建消息生产者producer，并制定生产者组名 2.指定N.
ROCKETMQ——简单消息发送、接收示例
weixin_34203426的博客
01-31 2327
2019独角兽企业重金招聘Python工程师标准>>> ...
RocketMQ简单入门实例
格子的博客
03-25 3218
消息队列优势专业&amp;验证MQ是消息领域业内专业的消息中间件，多次在国内外获奖经过双11阿里交易、商品、营销等核心链路真实场景验证阿里集团内部1000+核心应用使用，每天流转几千亿条消息，稳定可靠3种消息发送方式，消息场景全覆盖：可靠同步、可靠异步、oneway方式技术体系产品历史超过7年，消息保证不丢，技术体系丰富成熟阿里内部产品名：MetaQ、Notify开源社区产品名：RocketMQ，...
RocketMQ的常见应用样例及其实现
weixin_45974176的博客
08-17 739
RocketMQ的常见应用样例及其实现
RocketMQ消息发送详解：从客户端到集群
"RocketMQ消息发送流程与网络架构详解" RocketMQ是一款高性能、高可用的分布式消息中间件，常被用于大型分布式系统中的消息传递。在本文中，我们将深入理解RocketMQ的消息发送流程及其网络架构。 首先，让我们了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值