【RocketMQ】4.消息发送，同步消息，异步消息，单向消息，消息消费

开始步骤，创建springboot项目

• 导入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. 发送同步消息

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

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();
    }
}

两种基本的消息消费

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();
    }
}

2. 广播模式

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

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();
    }
}

与负载均衡不同的加了下面一行代码。