消息中间件RocketMQ的简单消息（同步、异步和单向）发送与消费

最新推荐文章于 2024-07-31 21:32:24 发布
最新推荐文章于 2024-07-31 21:32:24 发布
阅读量2.2k 收藏 9
点赞数 1
分类专栏： RocketMQ 文章标签： rocketmq java 消息发送 消息队列
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_28082757/article/details/109581688
版权

文章目录

1. 准备工作

导入MQ客户端依赖

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

2. 发送和消费的步骤简述

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

注意：消费者的 Topic 和 Tag 需要和生产者保持一致

3. 发送和消费同步消息

同步消息是最基础也是最简单的一个样例。这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。

3.1 消息发送者

public static void main(String[] args) throws Exception {
        // 实例化消息生产者 Producer
        DefaultMQProducer producer = new DefaultMQProducer("defaultGroup");
        // 设置 NameServer 的地址
        producer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 启动 Producer 实例
        producer.start();
        // 发送5条消息
        for (int i = 0; i < 5; i++) {
            // 创建消息，并指定Topic，Tag和消息体并设置默认编码 UTF-8
            Message message = new Message("TopicA", "TagA", ("Hello RocketMQ"+i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 发送消息到一个Broker
            SendResult sendResult = producer.send(message);
            // 通过sendResult返回消息是否成功送达
            System.out.println(sendResult);
        }

        // 如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }

执行并打印结果

SendResult [sendStatus=SEND_OK, msgId=0A4A2816026C18B4AAC22CEE54360000, offsetMsgId=0A4A280C00002A9F0000000000005991, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=1], queueOffset=28]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816026C18B4AAC22CEE54410001, offsetMsgId=0A4A280C00002A9F0000000000005A58, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=2], queueOffset=30]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816026C18B4AAC22CEE54430002, offsetMsgId=0A4A280C00002A9F0000000000005B1F, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=3], queueOffset=28]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816026C18B4AAC22CEE54460003, offsetMsgId=0A4A283300002A9F0000000000005FCB, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-b, queueId=0], queueOffset=30]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816026C18B4AAC22CEE544A0004, offsetMsgId=0A4A283300002A9F0000000000006092, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-b, queueId=1], queueOffset=30]

3.2 消息消费者

public static void main(String[] args) throws MQClientException {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("defaultGroup");
        // 指定NameServer地址信息
        consumer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 订阅Topic，需要和发送者对上
        consumer.subscribe("TopicA", "TagA");
        // 注册回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt message : list) {
                    System.out.println("Message Received: " + new String(message.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //启动消息者
        consumer.start();
        System.out.println("消费者启动");
    }

执行并打印结果

消费者启动
Message Received: Hello RocketMQ0
Message Received: Hello RocketMQ1
Message Received: Hello RocketMQ2
Message Received: Hello RocketMQ3
Message Received: Hello RocketMQ4

4. 发送和消费异步消息

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

4.1 消息发送者

public static void main(String[] args) throws Exception {
        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("defaultGroup");
        // 设置NameServer的地址
        producer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 启动Producer实例
        producer.start();

        for (int i = 0; i < 5; i++) {
            // 创建消息，并指定Topic，Tag和消息体并设置默认编码UTF-8
            Message message = new Message("TopicA", "TagA", ("Hello RocketMQ"+i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 发送消息到一个Broker，异步发送没有返回值，需要使用 SendCallback 接收异步返回结果的回调
            producer.send(message, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送成功："+sendResult);
                }

                @Override
                public void onException(Throwable throwable) {
                    System.out.println("发送异常："+ throwable.getMessage());
                }
            });
        }
        Thread.sleep(1000);
        // 如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }

执行并打印结果

发送成功：SendResult [sendStatus=SEND_OK, msgId=0A4A28163B3018B4AAC22CF96CF90000, offsetMsgId=0A4A283300002A9F00000000000063AE, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-b, queueId=2], queueOffset=35]
发送成功：SendResult [sendStatus=SEND_OK, msgId=0A4A28163B3018B4AAC22CF96CF90003, offsetMsgId=0A4A280C00002A9F0000000000005D74, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=2], queueOffset=31]
发送成功：SendResult [sendStatus=SEND_OK, msgId=0A4A28163B3018B4AAC22CF96CF90001, offsetMsgId=0A4A283300002A9F0000000000006475, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-b, queueId=0], queueOffset=31]
发送成功：SendResult [sendStatus=SEND_OK, msgId=0A4A28163B3018B4AAC22CF96CF90002, offsetMsgId=0A4A280C00002A9F0000000000005E3B, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=0], queueOffset=30]
发送成功：SendResult [sendStatus=SEND_OK, msgId=0A4A28163B3018B4AAC22CF96D120004, offsetMsgId=0A4A280C00002A9F0000000000005F02, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=3], queueOffset=29]

特别注意：在异步消息的发送者执行 shutdown 操作之前，一定记得要休眠一下，否则就会出现如下错误

java.lang.IllegalStateException: org.apache.rocketmq.remoting.exception.RemotingConnectException: connect to [NameServer的IP:9876] failed
at org.apache.rocketmq.client.impl.factory.MQClientInstance.updateTopicRouteInfoFromNameServer(MQClientInstance.java:681)
at org.apache.rocketmq.client.impl.factory.MQClientInstance.updateTopicRouteInfoFromNameServer(MQClientInstance.java:511)
at org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl.tryToFindTopicPublishInfo(DefaultMQProducerImpl.java:692)
at org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl.sendDefaultImpl(DefaultMQProducerImpl.java:556)
at org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl.access$300(DefaultMQProducerImpl.java:97)
at org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl$4.run(DefaultMQProducerImpl.java:510)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)

我猜测原因是由于是异步发送，如果不休眠的话，消息还没发送出去就被 shutdown 了，这和堆栈信息也符合。如果性能在极差的情况下，像我这样休眠 1 秒很有可能是不够的。

4.2 消息消费者

public static void main(String[] args) throws MQClientException {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("defaultGroup");
        // 指定NameServer地址信息
        consumer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 订阅Topic，需要和发送者对上
        consumer.subscribe("TopicA", "TagA");
        // 注册回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt message : list) {
                    System.out.println("Message Received: " + new String(message.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //启动消息者
        consumer.start();
        System.out.println("消费者启动");
    }

执行并打印结果

消费者启动
Message Received: Hello RocketMQ0
Message Received: Hello RocketMQ3
Message Received: Hello RocketMQ4
Message Received: Hello RocketMQ1
Message Received: Hello RocketMQ2

从消费者代码中可以看出：异步消费者的实现方式和同步消费者实现方式并无区别。
从消费者的结果来看：可以看出异步消费者接收的结果是无序的。

5. 发送和消费单向消息

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

5.1 消息发送者

public static void main(String[] args) throws Exception {
        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("defaultGroup");
        // 设置NameServer的地址
        producer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 启动Producer实例
        producer.start();
        for (int i = 0; i < 5; i++) {
            // 创建消息，并指定Topic，Tag和消息体并设置默认编码UTF-8
            Message message = new Message("TopicA", "TagA", ("Hello RocketMQ"+i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 发送单向消息，没有任何返回结果
            producer.sendOneway(message);
        }

        // 如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }

5.2 消息消费者

消息的消费者还是选择同步消息消费者的实现方式，现原封不动的 Cpoy 过来。

public static void main(String[] args) throws MQClientException {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("defaultGroup");
        // 指定NameServer地址信息
        consumer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 订阅Topic，需要和发送者对上
        consumer.subscribe("TopicA", "TagA");
        // 注册回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt message : list) {
                    System.out.println("Message Received: " + new String(message.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //启动消息者
        consumer.start();
        System.out.println("消费者启动");
    }

执行并打印结果

消费者启动
Message Received: Hello RocketMQ2
Message Received: Hello RocketMQ1
Message Received: Hello RocketMQ4
Message Received: Hello RocketMQ0
Message Received: Hello RocketMQ3

从消费结果来看，消费的顺序是无序的

6. 总结

  1. 同步消息、异步消息和单向消息的消费者实现方式是一样的。
  2. 同步消息、异步消息和单向消息的区别在于消息的发送方。
  3. 异步消息发送者没有返回值，需要使用 SendCallback 接收异步返回结果的回调。
  4. 异步消息发送者，在关闭实例之前，建议进行休眠。
  5. 单向消息也是没有返回值的，并且它的消费者也是无序消费。
  6. 单向消息和异步消息的区别是单向消息不需要 SendCallback 来接收异步返回结果的回调。

7. 消费者的消费模式

消费者的消费模式分为两种

  1. 负载均衡模式：消费者采用负载均衡方式消费消息，多个消费者共同消费队列消息，每个消费者处理的消息不同
  2. 广播模式：消费者采用广播的方式消费消息，每个消费者消费的消息都是相同的

7.1 负载均衡模式（默认）

我们使用最基础的同步消息的进行测试，我们先启动两个消费者（多次启动 Main 函数的方法在文章末尾有教程）：

public static void main(String[] args) throws MQClientException {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("defaultGroup");
        // 指定NameServer地址信息
        consumer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 订阅Topic，需要和发送者对上
        consumer.subscribe("TopicA", "TagA");
        // 注册回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt message : list) {
                    System.out.println("Message Received: " + new String(message.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //启动消息者
        consumer.start();
        System.out.println("消费者启动");
    }

在这里插入图片描述
然后，执行同步消息发送者发送五条消息（就不贴代码了，代码和上面一样）：

SendResult [sendStatus=SEND_OK, msgId=0A4A2816309418B4AAC22D126C540000, offsetMsgId=0A4A283300002A9F0000000000006C3B, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-b, queueId=3], queueOffset=32]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816309418B4AAC22D126CA20001, offsetMsgId=0A4A280C00002A9F0000000000006473, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=0], queueOffset=33]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816309418B4AAC22D126CC40002, offsetMsgId=0A4A280C00002A9F000000000000653A, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=1], queueOffset=32]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816309418B4AAC22D126CC80003, offsetMsgId=0A4A280C00002A9F0000000000006601, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=2], queueOffset=33]
SendResult [sendStatus=SEND_OK, msgId=0A4A2816309418B4AAC22D126CD60004, offsetMsgId=0A4A280C00002A9F00000000000066C8, messageQueue=MessageQueue [topic=TopicA, brokerName=broker-a, queueId=3], queueOffset=31]

最后，我们再来看看两个消费者消费的消息状况：

  • 消费者-1
    在这里插入图片描述
  • 消费者-2
    在这里插入图片描述
    从结果可以看出，两个消费者共同消费队列消息，每个消费者处理的消息不同，它符合上述负载均衡模式。

7.2 广播模式

广播模式的消息发送者不变，这里同样使用同步消息的发送者。而广播模式的消费者需要在同步消费者上加上一句话：

// 设置为广播模式
consumer.setMessageModel(MessageModel.BROADCASTING);

完整代码如下：

public static void main(String[] args) throws MQClientException {
        // 实例化消息生产者,指定组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("defaultGroup");
        // 指定NameServer地址信息
        consumer.setNamesrvAddr("任何一个NameServer的IP:9876");
        // 订阅Topic，需要和发送者对上
        consumer.subscribe("TopicA", "TagA");

        // 设置为广播模式
        consumer.setMessageModel(MessageModel.BROADCASTING);

        // 注册回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt message : list) {
                    System.out.println("Message Received: " + new String(message.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //启动消息者
        consumer.start();
        System.out.println("消费者启动");
    }

我们还是按照上面的步骤，启动两个消费者，然后发送5条消息。最后来看看结果。

  • 消费者-1
    在这里插入图片描述
  • 消费者-2
    在这里插入图片描述
    从结果可以看出，两个消费者共同消费队列消息，每个消费者消费的消息都是相同的，它符合上述广播模式模式。

8. 消费模式总结

  1. 消费模式默认为负载均衡模式
  2. 修改消费模式的方法是： consumer.setMessageModel();
  3. 设置为广播模式：consumer.setMessageModel(MessageModel.BROADCASTING);
  4. 设置负载均衡模式：consumer.setMessageModel(MessageModel.CLUSTERING);

9. 拓展 - 关于如何启动 main 方法多次

  • 首先在右上角启动按钮旁边点击：Edit Configurations
    在这里插入图片描述
  • 然后选择需要多次启动 Main 方法的类，在窗口右上角勾选：Allow parallel run
    在这里插入图片描述

技 术 无 他， 唯 有 熟 尔。
知 其 然， 也 知 其 所 以 然。
踏 实 一 些， 不 要 着 急， 你 想 要 的 岁 月 都 会 给 你。

江湖人称小程
关注
专栏目录
RocketMQ【RocketMQ应用实战、发送异步消息、单向发送消息、顺序发送消息、顺序消费消息、发送全局顺序消息、全局顺序消息消费者、发送延迟消息】(四)-全面详解（学习总结---从入门到深化）
04-21 754
RocketMQ【RocketMQ应用实战、发送异步消息、单向发送消息、顺序发送消息、顺序消费消息、发送全局顺序消息、全局顺序消息消费者、发送延迟消息】(四)-全面详解（学习总结---从入门到深化）
RocketMq发送消息
wanli4717的博客
02-28 5537
发送类型 Rocketmq提供三种方式可以发送普通消息：同步、异步、和单向发送。 同步：发送方发送消息后，收到服务端响应后才发送下一条消息 异步：发送一条消息后，不等服务端返回就可以继续发送消息或者后续任务处理。发送方通过回调接口接收服务端响应，并处理响应结果。 OneWay：发送方发送消息，不等待服务端返回响应且没有回调函数触发，即只发送请求不需要应答。 发送方式对比：发送吞吐量,单向>异步>同步。但单向发送可靠性差存在丢失消息可能，选型根据实际需求确定。 Demo演示 ..
RocketMQ〖三〗消息发送,同步消息,异步消息,单向消息,消息消费
kingtok的博客
02-11 1909
RocketMQ〖三〗一. 开始步骤,创建springboot项目二. 消息发送1）发送同步消息2）发送异步消息3）单向发送消息4）发送状态为sendStatus=SLAVE_NOT_AVAILABLE,但集群都好着呢,什么原因造成的有待考察,评论区的大神帮帮我~三. 消息消费1) 负载均衡模式(默认)2) 广播模式 一. 开始步骤,创建springboot项目 导入MQ客户端依赖 <d...
rocketMq的使用和消费模式（异步消息，单项消息（使用mq处理日志），推迟任务（占座买票），批量消息）
最新发布
f552126506的博客
07-31 705
rocketMq的使用和消费模式（异步消息，单项消息（使用mq处理日志），推迟任务（占座买票），批量消息）
【RocketMQ】4.消息发送，同步消息，异步消息，单向消息，消息消费
qmqm33的博客
05-10 451
开始步骤，创建springboot项目 导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析 创建消息生产者producer，并制
消息中间件的消费模式
晨猫
06-09 310
消息中间件的消费模式 Push 模式： 优势 可以尽可能快的将消息发送给消费者（在 Pull 模式下需要不断的拉取消息，因为并不知道消息队列中是否有新消息） 劣势 服务端并不知道消费端的消费能力，不停的发送消息可能在导致消费端缓存区溢出 ActiveMQ 中使用 prefetch limit 解决上述劣势 当推送消息的数量到达了perfetch limit规定的数值时，消费者还没有向消息中间件返回ACK，消息中间件将不再继续向消费者推送消息 如果消息的数量很少(生产者生产消息的速率不快)，但是每条消息 消费
RocketMQ(十三)——实战-普通消息的发送与消费
稷下学员的笔记博客
01-12 508
文章目录普通消息消息发送同步发送消息异步发送消息单向发送消息代码示例导入RocketMQ的依赖定义同步消息的发送者定义异步消息的发送者定义消费者 普通消息 消息发送 同步发送消息 同步发送消息是指：Producer发出一条消息后，会在收到MQ返回的ACK后才发送下一条消息。该方式的消息可靠性最高，但是消息发送效率太低。 异步发送消息 异步发送消息是指：Producer发出消息后无须等待MQ返回ACK，直接发送下一条消息。该方式有一定可靠性，发送效率相对同步较高 单向发送消息 单向发送消息是指：Produ
消息中间件 rocketmq原理解析
03-08
这一部分涉及到底层通信的实现，包括同步、异步以及单向调用的实现。 #### ***tyRemotingServerRemoting服务端实现 服务端需要处理各种网络通信请求和响应。 #### ***tyRemotingClient 客户端需要与服务端进行通信...
RocketMQ：发送消息与接收实例
08-28
本资料包包含了 RocketMQ 服务器的安装包，以及相关的控制台代码和消息发送接收的示例代码，涵盖了同步发送、异步发送、单向发送和顺序发送四种主要的发送方式。 1. **同步发送**：在同步发送模式下，生产者在发送...
RocketMQ高级原理：深入剖析消息系统的核心机制
12-22
RocketMQ支持同步、异步、顺序和单向四种发送方式。同步和异步发送需要Broker的确认，单向发送无需响应。Producer组内的实例共享消息发送逻辑，若发送事务消息时原Producer崩溃，其他实例可接管提交或回滚操作。 3....
同步异步调用，并谈谈消息队列mq；RocketMQ发送消息和消费消息测试类
越努力越幸运~~ Java领域从业者；CSDN新兴创新博主；Java领域优质创作者；书写奋斗者故事;欢迎交流学习进步；
09-20 1212
库存系统：订阅订单的消息，获取下单信息，进行库操作。就算库存系统出现故障，消息列队也能保证消息的可靠投递，不会导致消息丢失。场景：秒杀活动，一般会因为流量过大，导致应用挂掉，为了解决这个问题，一般在应用前端加入消息队列。双11是购物狂节，用户下单后，订单系统需要通知库存系统，传统的做法就是订单系统调用库存系统的接口。订单系统：用户下单后，订单系统完成持久化处理，将消息写入消息队列，返回用户订单下但成功。2，可以缓解短时间的高流量压垮应用（应用程序安自己的最大处理能力获取订单）对高并发有要求的功能使用异步。
简单消息,异步消息,同步消息辨析
a31081314的博客
12-02 5486
简单消息,异步消息,同步消息辨析 附例子
面试官再问我如何保证 RocketMQ 不丢失消息,这回我笑了！
楼下小黑哥
03-25 3975
最近看了 @JavaGuide 发布的一篇『面试官问我如何保证Kafka不丢失消息?我哭了！』，这篇文章承接这个主题，来聊聊如何保证 RocketMQ 不丢失消息。 0x00. 消息的发送流程 一条消息从生产到被消费，将会经历三个阶段： 生产阶段，Producer 新建消息，然后通过网络将消息投递给 MQ Broker 存储阶段，消息将会存储在 Broker 端磁盘中 消息阶段， Consum...
RocketMQ三种消息发送方式-同步、异步、单向
热门推荐
u010277958的博客
03-18 1万+
可靠同步发送 主要运用在比较重要一点消息传递/通知等业务： public class SyncProducer { public static void main(String[] args) throws Exception { DefaultMQProducer producer = new DefaultMQProducer("test"...
java实现异步非阻塞的几种方式-消息中间件
bug_null的博客
03-23 634
java实现异步非阻塞的几种方式-消息中间件 4. 消息中间件 在前面已经实现了异步调用、接口回调两种形式，都较为复杂，需要自己控制多线程，那有没有简单点的方式来实现异步的消息通讯。这个当然是有的，可以使用消息中间件的形式，来实现整个消息的异步调用。还是以订单这个场景为示例来举个粟子。 4.1 样例代码 我的样例程序使用rabbitmq来做为消息队列传输数据，其他消息队列功能类似。 先从订单服务开始。 @RestController @RequestMapping("/order") public cla
RocketMQ5.0.0定时消息
爱我所爱0505
03-18 1985
本章节介绍延迟消息的概览，及实现机制。根据延迟级别来创建不同的定时任务，延迟到延迟级别对应的延迟时间，进行还原原始主题和消费队列，再次存储到commitlog文件中，供消费者消费。
mysql和elasticsearch数据同步方案：rocketmq做异步
jaybroisbig的博客
06-02 478
先记录一下我新学习的东西所踩到的坑，elasticsearch的index必须是不包含大写字母的，不然会报错，还有rocketmq的consumerGroup是一个大坑，必须依据topic做区分，当有两个topic的消息队列时，一定要保证consumeGroup是两个不同的。这是因为，Consumer会定期发送心跳，默认是30s一次。心跳会像全部broker发送，心跳包内容包括groupname，topicname1。然后broker端会缓存这个信息，以groupname为key，在broker端的缓存里，
RocketMQ（七） RocketMQ的两种消费模式
m0_67402970的博客
06-12 1451
目录一、概述二、集群消费三、广播消费RocketMQ主要提供了两种消费模式：集群消费以及广播消费。我们只需要在定义消费者的时候通过**setMessageModel(MessageModel.XXX)**方法就可以指定是集群还是广播式消费，默认是集群消费模式，即每个Consumer Group中的Consumer均摊所有的消息。下面我们通过简单的示例演示一下。一个 Consumer Group 中的 Consumer 实例平均分摊消费消息。使用方法：setMessageModel(MessageModel.
RocketMQ支持哪几种类型的消息
weixin_43442127的博客
03-20 689
RocketMQ支持哪几种类型的消息
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值