RocketMQ〖三〗消息发送,同步消息,异步消息,单向消息,消息消费

最新推荐文章于 2024-02-04 07:46:50 发布
最新推荐文章于 2024-02-04 07:46:50 发布
阅读量1.8k 收藏 4
点赞数 2
分类专栏： RocketMQ 文章标签： java rocketmq 中间件 消息队列 消息发送
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingtok/article/details/104249540
版权

RocketMQ〖三〗

一. 开始步骤,创建springboot项目

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

二. 消息发送

1）发送同步消息

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

public class SyncProducer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("一号服务器公网IP:9876;二号服务器公网IP:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("springboot-mq", "Tag1", ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

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

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

运行结果

发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B76AA50000, offsetMsgId=3B6E9E5D00002A9F0000000000001780, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=3], queueOffset=7]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B76F0E0001, offsetMsgId=3B6E9E5D00002A9F0000000000001832, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=0], queueOffset=7]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B7731A0002, offsetMsgId=3B6E9E5D00002A9F00000000000018E4, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=1], queueOffset=8]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B777270003, offsetMsgId=3B6E9E5D00002A9F0000000000001996, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=2], queueOffset=8]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B77B350004, offsetMsgId=3B6E9E5D00002A9F0000000000001A48, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=3], queueOffset=8]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B77F430005, offsetMsgId=3B6E9E5D00002A9F0000000000001AFA, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=0], queueOffset=8]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B783500006, offsetMsgId=3B6E9E5D00002A9F0000000000001BAC, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=1], queueOffset=9]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B7875D0007, offsetMsgId=3B6E9E5D00002A9F0000000000001C5E, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=2], queueOffset=9]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B78B6E0008, offsetMsgId=3B6E9E5D00002A9F0000000000001D10, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=3], queueOffset=9]
发送结果:SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032505B000B4AAC231B78F7D0009, offsetMsgId=3B6E9E5D00002A9F0000000000001DC2, messageQueue=MessageQueue [topic=springboot-mq, brokerName=broker-b, queueId=0], queueOffset=9]
2）发送异步消息

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

public class AsyncProducer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("一号服务器公网IP:9876;二号服务器公网IP: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
                 */
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送结果：" + sendResult);
                }

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

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

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

发送结果

发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF7F330000, offsetMsgId=3B6E9E5D00002A9F0000000000001E74, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=0]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF7F330001, offsetMsgId=2760560400002A9F00000000000003F6, messageQueue=MessageQueue [topic=base, brokerName=broker-a, queueId=2], queueOffset=2]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF83130002, offsetMsgId=3B6E9E5D00002A9F0000000000001F1D, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=1]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF86FC0003, offsetMsgId=3B6E9E5D00002A9F0000000000001FC6, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=0]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF8AE50004, offsetMsgId=2760560400002A9F000000000000049F, messageQueue=MessageQueue [topic=base, brokerName=broker-a, queueId=3], queueOffset=1]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF8ECC0005, offsetMsgId=2760560400002A9F0000000000000548, messageQueue=MessageQueue [topic=base, brokerName=broker-a, queueId=3], queueOffset=2]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF92B50006, offsetMsgId=3B6E9E5D00002A9F000000000000206F, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=1], queueOffset=2]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF969E0007, offsetMsgId=3B6E9E5D00002A9F0000000000002118, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=2], queueOffset=2]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF9A870008, offsetMsgId=2760560400002A9F00000000000005F1, messageQueue=MessageQueue [topic=base, brokerName=broker-a, queueId=3], queueOffset=3]
发送结果：SendResult [sendStatus=SLAVE_NOT_AVAILABLE, msgId=C0A8032509E400B4AAC231BF9E6F0009, offsetMsgId=3B6E9E5D00002A9F00000000000021C1, messageQueue=MessageQueue [topic=base, brokerName=broker-b, queueId=3], queueOffset=1]
3）单向发送消息

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

/**
 * 发送单向消息
 */
public class OneWayProducer {

    public static void main(String[] args) throws Exception, MQBrokerException {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("一号服务器公网IP:9876;二号服务器公网IP: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(5);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }
}
4）发送状态为sendStatus=SLAVE_NOT_AVAILABLE,但集群都好着呢,什么原因造成的有待考察,评论区的大神帮帮我~

三. 消息消费

1) 负载均衡模式(默认)

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

public class Consumer {

    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("39.96.86.4:9876;59.110.158.93:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("springboot-mq", "Tag1")
        
        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();
    }
}

消费信息

[MessageExt [queueId=0, storeSize=178, queueOffset=3, sysFlag=0, bornTimestamp=1581266391102, bornHost=/36.41.156.59:38339, storeTimestamp=1581266391444, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000000BD2, commitLogOffset=3026, bodyCRC=1761454578, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437443, UNIQ_KEY=C0A80325055800B4AAC22E7DB83E0007, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 55], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=12, sysFlag=0, bornTimestamp=1581322213951, bornHost=/36.41.156.59:39835, storeTimestamp=1581322214204, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F00000000000027FA, commitLogOffset=10234, bodyCRC=2017637475, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437446, UNIQ_KEY=C0A803252B2000B4AAC231D1823F0008, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 56], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=11, sysFlag=0, bornTimestamp=1581322209826, bornHost=/36.41.156.59:39835, storeTimestamp=1581322210079, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000002532, commitLogOffset=9522, bodyCRC=1911879752, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437446, UNIQ_KEY=C0A803252B2000B4AAC231D172220004, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 52], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=15, sysFlag=0, bornTimestamp=1581322599135, bornHost=/36.41.156.59:39947, storeTimestamp=1581322599392, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000002EEE, commitLogOffset=12014, bodyCRC=2017637475, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437446, UNIQ_KEY=C0A8032513C000B4AAC231D762DF0008, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 56], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=9, sysFlag=0, bornTimestamp=1581320513405, bornHost=/36.41.156.59:41650, storeTimestamp=1581320513647, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000001DC2, commitLogOffset=7618, bodyCRC=256214261, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437443, UNIQ_KEY=C0A8032505B000B4AAC231B78F7D0009, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 57], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=10, sysFlag=0, bornTimestamp=1581322205664, bornHost=/36.41.156.59:39835, storeTimestamp=1581322205951, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F000000000000226A, commitLogOffset=8810, bodyCRC=1989753937, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437443, UNIQ_KEY=C0A803252B2000B4AAC231D161DE0000, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 48], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=7, sysFlag=0, bornTimestamp=1581320505102, bornHost=/36.41.156.59:41650, storeTimestamp=1581320505343, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000001832, commitLogOffset=6194, bodyCRC=27135175, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437443, UNIQ_KEY=C0A8032505B000B4AAC231B76F0E0001, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 49], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=8, sysFlag=0, bornTimestamp=1581320509251, bornHost=/36.41.156.59:41650, storeTimestamp=1581320509493, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000001AFA, commitLogOffset=6906, bodyCRC=116639966, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437443, UNIQ_KEY=C0A8032505B000B4AAC231B77F430005, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 53], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=14, sysFlag=0, bornTimestamp=1581322594996, bornHost=/36.41.156.59:39947, storeTimestamp=1581322595254, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F0000000000002C26, commitLogOffset=11302, bodyCRC=1911879752, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437446, UNIQ_KEY=C0A8032513C000B4AAC231D752B40004, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 52], transactionId='null'}]]
[MessageExt [queueId=0, storeSize=178, queueOffset=13, sysFlag=0, bornTimestamp=1581322590782, bornHost=/36.41.156.59:39947, storeTimestamp=1581322591097, storeHost=/59.110.158.93:10911, msgId=3B6E9E5D00002A9F000000000000295E, commitLogOffset=10590, bodyCRC=1989753937, reconsumeTimes=0, preparedTransactionOffset=0, toString()=Message{topic='springboot-mq', flag=0, properties={MIN_OFFSET=0, MAX_OFFSET=16, CONSUME_START_TIME=1581329437446, UNIQ_KEY=C0A8032513C000B4AAC231D7423D0000, WAIT=true, TAGS=Tag1}, body=[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 48], transactionId='null'}]]
2) 广播模式

指的是不同的comsumer接收到的消息是一样的

public class Consumer {

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

        consumer.setMessageModel(MessageModel.BROADCASTING);

        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();
    }
}
ktoking
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分布式消息中间件-Rocketmq
02-24
本文来自于csdn，文章分享了分布式消息中间件，主要基于JMS规范、Rocketmq的介绍、部署方式、特性的一些使用几大模块阐述。今天要给大家分享的是分布式消息中间件。消息中间件主要是实现分布式系统中解耦、异步消息、流量销锋、日志处理等场景，后面我也会结合一些场景进行探讨。现在生产中用的最多的消息队列有Activemq，rabbitmq，kafka，rocketmq等。不过这个题目写的有点大。为什么这样说呢，因为虽然这样写，但实际上我这边是以Jms规范和rocketmq为主来分享的。大家一般都是遵从的是公司技术规范和选择(也就是公司用什么基础组件基本上都是选择好的)。基于我的一些工作经历，所以
Kafka面试专题及答案2019
Hengji的博客
09-06 413
Kafka面试专题及答案 Kafka面试专题及答案2019 1.Kafka的设计是什么样的呢? 2.数据传输的事物定义有哪三种? 3.Kafka 判断一个节点是否还活着有那两个条件？ 4.producer 是否直接将数据发送到broker的leader(主节点)？ 5、Kafa consumer 是否可以消费指定分区消息？ 6、Kafka 消息是采用 Pull 模式，还是 Push 模式？ 7.Kafka 存储在硬盘上的消息格式是什么？ 8.Kafka 高效文件存储设计特点： 9.Kafka 与传统消息系统
RocketMQ—RocketMQ发送同步、异步、单向、延迟、批量、顺序、批量消息、带标签消息
最新发布
随机的未知——用已知去面对未知
02-04 1159
本文介绍了RocketMQ如何使用Java代码发送同步、异步、单向、延迟、批量、顺序、批量消息和带标签消息。
RocketMQ发送各种消息（同步，异步，单项，延迟，批量，顺序，事务，带标签，带key）
m0_65819602的博客
09-27 1207
我们往一个主题里面发送消息的时候，根据业务逻辑，可能需要区分，比如带有tagA标签的被A消费，带有tagB标签的被B消费，还有在事务监听的类里面，只要是事务消息都要走同一个监听，我们也需要通过过滤才区别对待。发送同步消息，发送过后会有一个返回值，也就是mq服务器接收到消息后返回的一个确认，这种方式非常安全（发送消息存在消息丢失的风险），但是性能上并没有这么高。对于一个指定的Topic，消息严格按照先进先出（FIFO）的原则进行消息发布和消费，后发布的消息后消费。延时消息约束
ROCKETMQ消息消费原理
weixin_34387284的博客
05-27 2533
2019独角兽企业重金招聘Python工程师标准>>> ...
关于消息队列的使用----ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ
程序员闪充宝
03-24 246
点击上面　　免费订阅本账号！本公众号主要推送javaweb开发相关技术，基础知识点，同时会深入剖析复杂的问题，分享一些优秀的框架，大型项目经验，当今最流行的Javaweb技术，热点科技新...
RockerMQ 的异步消费
gaohechao的博客
03-06 1583
项目终于开发完了，明天就开始联调了，总结下rocketma的使用场景和使用方法。 业务正常流程是这样的：用户下单 - 扣减库存 - 生成待支付订单 - 调用支付网关 - 支付成功后回调 - 修改订单数据 - 调发码平台购票，流程走完。 mq这里要做的是在生成待支付订单后将消息延迟10分钟放到mq，然后做一个异步监听，将监听到的数据去库里面查一遍有没有支付完成，如果没有支付完成就将订单取消，增加库存。 这么做的目的是防止有很多待支付的订单占用库存数量。 ...
RocketMQ入门教程(三)：发送消息和消费消息
人不风流枉少年
01-10 4853
一：普通消息 RocketMQ提供了三种方式来发送普通消息：可靠同步发送、可靠异步发送、单向发送。 1.1 可靠同步发送 同步发送是发送消息后必须等待RocketMQ服务返回发送的结果，这里会一直同步阻塞，直到拿到RocketMQ服务返回发送的结果才继续往下执行代码。 同步发送一般应用于对发送成功可靠性要求很严格的场景，一般是要保证100%发送成功，不成功就重试。 @RestController public class RocketMQController { @Autowired pr
RocketMQ消息支持的模式-消息异步发送
Leon_Jinhai_Sun的博客
10-31 653
异步发送是指发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。 MQ 的异步发送，需要用户实现异步发送回调接口（SendCallback）。消息发送方在发送了一条消息后，不需要等待服务器响应即可返回，进行第二条消息发送。发送方通过回调接口接收服务器响应，并对响应结果进行处理 异步代码改造 producer.send(msg, new SendCallback() { @Override public void onSuccess(SendResult sendR...
使用python发送接受rocketmq消息~
小苗瞄的博客
12-11 1892
我在思否里写了详细的步骤。感兴趣的可以看一看 https://segmentfault.com/a/1190000038400077
RocketMQ超时用的消息发送、消费实践总结
爱雨轩
05-28 2102
oneway发送了不等待应答，即在实现层面仅仅将数据写入 socket缓冲区，此过程耗时通常在微秒级......
第七章Rocketmq--消息驱动
02-24
7.1.1什么是MQMQ（MessageQueue）是一种跨进程的通信机制，用于传递消息。通俗点说，就是一个先进先出的数据结构。7.1.2MQ的应用场景7.1.2.1异步解耦最常见的一个场景是用户注册后，需要发送注册邮件和短信通知，以...
使用SpringJMS轻松实现异步消息传递
02-04
传统的使用JMSAPI进行消息传递的实现包括多个步骤，例如JNDI查询队列连接工厂和Queue资源，在实际发送和接收消息前创建一个JMS会话。Spring框架则简化了使用JEE组件(包括JMS)的任务。它提供的模板机制隐藏了典型的...
RocketMQ-基础概念
weixin_43420030的博客
06-03 241
面试RocketMQ必背八股文
面渣逆袭：RocketMQ二十三问
三分恶的博客
04-07 4223
RocketMQ二十三问，这下通透了！
RocketMQ基础篇（一）
搬砖农民工的博客
03-07 3645
RocketMQ基础篇，这篇文章会介绍RocketMQ的基础语法
【RocketMQ】4.消息发送，同步消息，异步消息，单向消息，消息消费
qmqm33的博客
05-10 426
开始步骤，创建springboot项目 导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.4.0</version> </dependency> 消息发送者步骤分析 创建消息生产者producer，并制
RocketMQ：消息发送与消费
上海一九四三
07-02 2061
在此之前，我们已经介绍过《RocketMQ：快速入门》和《RocketMQ：搭建集群》。现在我们已经准备好RocketMQ的环境了，接下来就是通过实战去演示RocketMQ中各种消息类型的生产和消费了。 1. 开发环境 （1）引入RocketMQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId&
RocketMQ 消息发送设计和原理详解 源码剖析
金甲虫的博客
06-22 1250
1. 背景 发送消息是 MQ 最基础的操作之一。RocketMQ 官方提供了多语言客户端支持消息的发送和消费操作。 当然，消息发送并不仅仅牵扯到客户端操作。客户端做的是向 Broker 发送请求，请求中包含了消息的全部信息。而 Broker 需要处理客户端发送来的生产请求，将消息存储起来。 在这篇文章中我将将解析消息发送流程中生产者和 Broker 的处理流程，揭秘 RocketMQ 消息发送高性能、高可靠的原理。 2. 概述 RocketMQ 的 Java 客户端提供了丰富的消息发送 API，支持多种消息
rocketmq同步异步单向消息
08-27
RocketMQ支持同步、异步和单向消息发送方式。 1. 同步消息：发送方发送消息后，会阻塞等待服务器返回发送结果。如果发送成功，发送方会收到服务器的响应；如果发送失败，发送方可以根据服务器的响应进行重试或者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值