SpringBoot整合RocketMQ

方式一：使用rocketmq-spring-boot-starter依赖

引入依赖：

<dependency>

        <groupId>org.apache.rocketmq</groupId>

        <artifactId>rocketmq-spring-boot-starter</artifactId>

        <version>2.0.3</version>

</dependency>

项目配置文件配置：

rocketmq:

    name-server: 127.0.0.1:9876

    producer:

        group: newProducer

        topic: newTopic

配置生产者消息发送工具类：

@Slf4j
@Component
public class SpringProducer
{
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    public void sendMsg(String topic, String msg)
    {
        log.info("发送报文：" + msg);
        this.rocketMQTemplate.convertAndSend(topic, msg);
    } 
}

配置消费者进行消息处理：

@Slf4j
@Component
@RocketMQMessageListener(topic = "${rocketmq.producer.topic}", consumerGroup = "${rocketmq.producer.group}")
public class SpringConsumer implements RocketMQListener<String>
{
    @Override
    public void onMessage(String msg)
    {
        log.info("收到消息:" + msg);
    }
}

 

方式二：使用org.apache.rocketmq依赖

引入依赖：

<!-- https://mvnreSpository.com/artifact/org.apache.rocketmq/rocketmq-client -->

<dependency>

        <groupId>org.apache.rocketmq</groupId>

        <artifactId>rocketmq-client</artifactId>

        <version>4.6.0</version>

</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.rocketmq/rocketmq-common -->

<dependency>

        <groupId>org.apache.rocketmq</groupId>

        <artifactId>rocketmq-common</artifactId>

        <version>4.6.0</version>

</dependency>

项目配置文件配置：

apache:

    rocketmq:

        topic: consumerTopic

        consumerGroup: consumerProducer

        namesrvAddr: 127.0.0.1:9876

生产者配置数据发送工具类：

@Component
public class RocketMQProducer
{
    @Value("${apache.rocketmq.consumerGroup}")
    private String consumerGroup;
    
    @Value("${apache.rocketmq.namesrvAddr}")
    private String namesrvAddr;
    
    private DefaultMQProducer producer;
    
    public DefaultMQProducer getProducter()
    {
        return producer;
    }
    
    @PostConstruct
    public void init()
    {
        producer = new DefaultMQProducer(consumerGroup);
        producer.setNamesrvAddr(namesrvAddr);
        producer.setVipChannelEnabled(false);
        try
        {
            producer.start();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

 

数据发送方法：

@Autoware

RocketMQConfig mqConfig;

mqConfig.getProducter().send(msg);// msg为Message对象

Message类说明：

构造方法有：

public Message()

public Message(String topic, byte[] body)

public Message(String topic, String tags, byte[] body)

public Message(String topic, String tags, String keys, byte[] body)

public Message(String topic, String tags, String keys, int flag, byte[] body, boolean waitStoreMsgOK)

其中：

topic：表示消息要到的发送主题，必填，例如配置文件中设置的consumerTopic

tags：表示消息的标签，消费者在消费时，可以根据标签进行过滤，需要注意的是，一个生产者，只能指定一个tag

keys：用于建立索引，之后可以通过命令工具/API/或者管理平台查询key，可以为一个消息设置多个key，用空格""进行分割

flag：选填，消息的标记，完全由应用设置，RocketMQ不做任何处理

body：消息的内容，这是一个字节数组，序列化方式由应用决定，例如你可以将一个json转为字节数组

waitStoreMsgOK：表示发送消息后，是否需要等待消息同步刷新到磁盘上。如果broker配置为ASYNC_MASTER，那么只需要消息在master上刷新到磁盘即可；如果配置为SYNC_MASTER，那么还需要等待slave也刷新到磁盘。需要注意的是，waitStoreMsgOK默认为false，只有将设置为true的情况下，才会等待刷盘成功再返回。

消费者：

@Slf4j
@Component
public class RocketMQConsumer
{
    @Value("${apache.rocketmq.consumerGroup}")
    private String consumerGroup;
    
    @Value("${apache.rocketmq.namesrvAddr}")
    private String namesrvAddr;
    
    @Value("${apache.rocketmq.topic}")
    private String topic;
    
    @PostConstruct
    public void defaultMQPushConsumer()
    {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerGroup);
        // 指定NameServer地址，多个地址以 ; 隔开
        consumer.setNamesrvAddr(namesrvAddr);
        try
        {
            // 设置consumer所订阅的Topic和Tag，*代表全部的Tag
            consumer.subscribe(topic, "*");
            // 设置消费策略，CONSUME_FROM_LAST_OFFSET 默认策略，从该队列最尾开始消费，跳过历史消息，CONSUME_FROM_FIRST_OFFSET 从队列最开始开始消费，即历史消息（还储存在broker的）全部消费一遍
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
            // MessageListenerOrderly 这个是有序的，MessageListenerConcurrently 这个是无序的,并行的方式处理，效率高很多
            consumer.registerMessageListener((MessageListenerConcurrently)(list, context) -> {
                try
                {
                    for (MessageExt messageExt : list)
                    {
                        String messageBody = new String(messageExt.getBody(), RemotingHelper.DEFAULT_CHARSET);
                        log.info("收到消息：" + messageBody);
                    }
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER; // 稍后再试
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; // 消费成功
            });
            consumer.start();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}