rocketmq框架详细介绍（二）

批量发送消息

批量发送消息条件：
1、发送到同一个topic
2、等待同一个发送结果
3、不允许使用定时消息
4、不支持半事务特性
5、同一批消息大小不能超过1MB，否则需要自己进行切割

发送批量消息，最主要的区别是在发送消息的send方法入参一个List。

生产端

@Test
    public void sendMessage() throws Exception {
        DefaultMQProducer defaultMQProducer = RocketMqUtil.getDefaultMQProducer();
        Message message1 = new Message(RocketMqUtil.TOPIC, "batch-1", "batch-message-1".getBytes(Charset.forName("UTF-8")));
        Message message2 = new Message(RocketMqUtil.TOPIC, "batch-2", "batch-message-2".getBytes(Charset.forName("UTF-8")));
        Message message3 = new Message(RocketMqUtil.TOPIC, "batch-3", "batch-message-3".getBytes(Charset.forName("UTF-8")));
        //批量发送消息
        List<Message> messages = Lists.newArrayList(message1, message2, message3);
        SendResult sendResult = defaultMQProducer.send(messages);
        log.info("发送消息结果：{}", sendResult.getSendStatus().name());
        defaultMQProducer.shutdown();
    }

消费端

@Test
    public void consumer() throws Exception {
        DefaultMQPushConsumer defaultMQPushConsumer = RocketMqUtil.getDefaultMQPushConsumer();
        defaultMQPushConsumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        defaultMQPushConsumer.subscribe(RocketMqUtil.TOPIC, "*");
        defaultMQPushConsumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                msgs.stream().map(MessageExt::getBody).map(String::new).forEach(System.out::println);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        defaultMQPushConsumer.start();
        Thread.sleep(5000L);
        defaultMQPushConsumer.shutdown();
    }

SpringBoot整合RocketMQ，集群、广播消息

发送普通消息

import cn.hutool.core.util.IdUtil;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ProducerTest {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Test
    public void demo1() {
        for (int i = 0; i < 10; i++) {
            rocketMQTemplate.syncSend("topic-A", "消息  " + i + "  " + IdUtil.getSnowflake(1, 1).nextId());
        }
    }
}

消费者

消费组（consumerGroup）集群
当consumerGroup 消费组有多个，集群消费同一个主题时，默认情况下这个主题的消息会分流到这个消费组的不同消费者进行消费，不同消费组之间可以同时消费同一个消息

消费者1 consumer-group-1 （集群）

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RocketMQMessageListener(consumerGroup="consumer-group-1", topic="topic-A")
public class TestConsumer1 implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("消费者1: " + message);
    }
}

消费者2 consumer-group-1 （集群）

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RocketMQMessageListener(consumerGroup="consumer-group-1", topic="topic-A")
public class TestConsumer2 implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("消费者2: " + message);
    }
}

消费者3 consumer-group-2

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RocketMQMessageListener(consumerGroup="consumer-group-2", topic="topic-A")
public class TestConsumer3 implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("消费者3: " + message);
    }
}

集群模式小结
消费者1 和 消费者2同为一个消费组并订阅同一个主题时，默认情况下会平分这个主题的消息进行消费。
消费者3 跟 消费者1、2不在同一个消费组，会单独消费这个主题下的所有消息。

广播模式消费

默认情况下同一消费组群集时会分滩来消费一个主题的消息。
如果特殊情况需要集群下的所有消费者都消费这个主题的消息时，可将消费模式设置为广播模式 messageModel = MessageModel.BROADCASTING

消费者

@Slf4j
@Component
@RocketMQMessageListener(consumerGroup = "consumer-group-3", topic = "topic-B", messageModel = MessageModel.BROADCASTING)
public class TestConsumer5 implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("消费者5: " + message);
    }
}

@Slf4j
@Component
@RocketMQMessageListener(consumerGroup = "consumer-group-3", topic = "topic-B", messageModel = MessageModel.BROADCASTING)
public class TestConsumer6 implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("消费者6: " + message);
    }
}

广播模式小结
消费者5 和 消费者6都同为一个消费组（consumer-group-3），并订阅同一个主题（topic-B），只需要在@RocketMQMessageListener注解中添加 messageModel = MessageModel.BROADCASTING 参数设置为广播模式，即可实现每个消费者都消费这个主题的所有消息。