03，springboot整合RocketMQ

1，maven和配置文件

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>

    </dependencies>

spring:
  application:
    name: rocketmq-boot
server:
  port: 8083

# rocketmq配置
rocketmq:
  name-server: http://127.1.1.1:9876
  #自定义的组名称
  producer:
    group: producer_test
    #消息发送超时时长
    send-message-timeout: 5000

2，基础应用

2.1，创建生产者

package com.study.producer;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class Demo01_TestProducer {
    private static final Logger log = LoggerFactory.getLogger(Demo01_TestProducer.class);

    @Resource
    RocketMQTemplate rocketmqTemplate;

    public void send() {
        log.info("开始发送...");
        for (int i=1; i <= 20;i++){
            String text = "测试发送" + i;
            Message<String> message = MessageBuilder.withPayload(text).build();
            rocketmqTemplate.send("TEST_MESSAGE", message);
        }
        log.info("已发送...");
    }
}

2.2，创建消费者

package com.study.consumer;

import com.study.producer.Demo01_TestProducer;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "TEST_MESSAGE", consumerGroup = "test_group")
public class Demo01_TestConsumer implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo01_TestConsumer.class);

    @Override
    public void onMessage(String message) {
        log.info("TestConsumer - 接受到消息:" + message);
    }
}

2.3 调用接口

@GetMapping("sendDemo01TestPro")
    private void sendDemo01TestPro(){
        testProducer.send();
    }

2.4 测试

3，基本消息

• 同步消息：这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
• 异步消息：用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
• 单向发送消息：这种方式主要用在不关心发送结果的场景，例如日志发送。

3.1，创建生产者

package com.study.producer;

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * 基本消息样例
 * 1,同步消息：这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
 * 2,异步消息：用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
 * 3,单向发送消息：这种方式主要用在不关心发送结果的场景，例如日志发送。
 */
@Service
public class Demo02_BasicsProducer {
    @Resource
    RocketMQTemplate rocketMQTemplate;

    private static final Logger log = LoggerFactory.getLogger(Demo02_BasicsProducer.class);

    /**
     * 同步消息: 这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
     */
    public void sync() {
        String text = "基本信息案例-同步发送" + System.currentTimeMillis();
        log.info(text);
        for (int a = 1; a <= 10; a++) {
            rocketMQTemplate.syncSend("SYNC_TOPIC", text+"----"+a);
        }
        log.info("同步发送-已发送...");
    }

    /**
     * 异步消息:异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
     */
    public void async() {
        String text = "基本信息案例-异步发送" + System.currentTimeMillis();
        log.info(text);
        for (int a = 1; a <= 10; a++) {
            rocketMQTemplate.asyncSend("ASYNC_TOPIC", text + "，ID:" + a, new SendCallback() {

                // SendCallback接收异步返回结果的回调
                // 成功发送
                @Override
                public void onSuccess(SendResult sendResult) {
                    log.info("异步发送 - 发送成功");
                }

                // 发送失败
                @Override
                public void onException(Throwable throwable) {
                    log.info("异步发送 - 发送失败");
                    throwable.printStackTrace();
                }
            });
        }
        log.info("异步发送-已发送...");
    }

    /**
     * 单向发送消息:这种方式主要用在不特别关心发送结果的场景，例如日志发送。
     */
    public void oneWay() {
        String text = "基本信息案例-单向发送" + System.currentTimeMillis();
        log.info(text);
        for (int a = 1; a <= 10; a++) {
            rocketMQTemplate.sendOneWay("ONEWAY_TOPIC", text+"----"+a);
        }
        rocketMQTemplate.sendOneWay("ONEWAY_TOPIC", text);
        log.info("单向发送-已发送...");
    }
}

3.1，创建消费者

3.1.1 异步消息消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 异步消息
 */
@Component
@RocketMQMessageListener(selectorExpression = "", topic = "ASYNC_TOPIC", consumerGroup = "async_group")
public class Demo02_Basics_Async_Consumer implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo02_Basics_Async_Consumer.class);

    /**
     *
     * @param message
     */
    @Override
    public void onMessage(String message) {
        log.info("异步消息-接受到消息:" + message);
    }
}

3.1.2 单向发送消息消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 单向发送消息
 */
@Component
@RocketMQMessageListener(selectorExpression = "", topic = "ONEWAY_TOPIC", consumerGroup = "oneway_group")
public class Demo02_Basics_Oneway_Consumer implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo02_Basics_Oneway_Consumer.class);

    /**
     *
     * @param message
     */
    @Override
    public void onMessage(String message) {
        log.info("单向发送消息-接受到消息:" + message);
    }
}

3.1.3 同步消息消费者

package com.study.consumer;

import com.study.producer.Demo02_BasicsProducer;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 同步消息
 */
@Component
@RocketMQMessageListener(selectorExpression = "", topic = "SYNC_TOPIC", consumerGroup = "sync_group")
public class Demo02_Basics_Sync_Consumer implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo02_Basics_Sync_Consumer.class);

    /**
     *
     * @param message
     */
    @Override
    public void onMessage(String message) {
        log.info("同步消息-接受到消息:" + message);
    }
}

3.3 调用接口

/**
     * 异步消息
     */
    @GetMapping("sendAsync")
    private String sendAsync(){
        demo02_basicsProducer.async();
        return"异步发送 - 发送成功";
    }

    /**
     * 单向发送消息
     */
    @GetMapping("sendOneway")
    private String sendOneway(){
        demo02_basicsProducer.oneWay();
        return"单向发送消息 - 发送成功";
    }

    /**
     * 同步消息
     */
    @GetMapping("sendSync")
    private String sendSync(){
        demo02_basicsProducer.sync();
        return"同步消息 - 发送成功";
    }

3.4 测试

3.4.1 测试异步消息

http://localhost:8083/sendAsync

3.4.2 测试单项发送消息

http://localhost:8083/sendOneway

3.4.3 测试同步消息

http://localhost:8083/sendSync

4，顺序消息

消息有序指的是可以按照消息的发送顺序来消费(FIFO)，rocketmq可以严格的保证消息有序

4.1 创建生产者

package com.study.producer;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * 顺序消息
 */
@Service
public class Demo03_OrderProducer {
    @Resource
    RocketMQTemplate rocketMQTemplate;

    private static final Logger log = LoggerFactory.getLogger(Demo03_OrderProducer.class);

    public void order() {
        log.info("顺序消息");
        try {
            for (int i = 1; i <= 10; i++) {
                int num = (int) (Math.random() * 10000);
                // 设置一个延时，表示同一个消息先后进入到队形中
                TimeUnit.MILLISECONDS.sleep(50);
                log.info("顺序消息,ID:" + num);
                // 第一个参数为topic，第二个参数为内容，第三个参数为Hash值，不同hash值在不同的队列中
                rocketMQTemplate.syncSendOrderly("ORDER_TOPIC", "顺序消息,ID:" + num, "order");
            }
            log.info("已发送...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.2 创建消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "ORDER_TOPIC", consumerGroup = "ORDER_TOPIC", consumeMode = ConsumeMode.ORDERLY)
public class Demo03_OrderConsumer implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo03_OrderConsumer.class);
    @Override
    public void onMessage(String message) {
        log.info("顺序消息生产-接受到消息:" + message);
    }


}

4.3 调用接口

@GetMapping("/sendOrder")
    public Object order() {
        demo03_orderProducer.order();
        return "发送顺序消息";
    }

4.4 测试

5，延时消息

通过设置延时等级，实现消费者延时消费数据，比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。

5.1 创建生产者

package com.study.producer;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class Demo04_ScheduledProducer {
    private static final Logger log = LoggerFactory.getLogger(Demo04_ScheduledProducer.class);

    /**
     * 测试发送将参数topic定死，实际开发写入到配置文件
     */
    @Resource
    RocketMQTemplate rocketMQTemplate;

    public void scheduled() {
        String text = "延时消息"+ System.currentTimeMillis();
        log.info(text);

        // 设置延时等级2,这个消息将在5s之后发送
        // 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
        Message<String> message = MessageBuilder.withPayload(text).build();
        rocketMQTemplate.syncSend("SCHEDULED_TOPIC", message, 1000, 4);

        log.info("已发送...");
    }

}

5.2 创建消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "SCHEDULED_TOPIC", consumerGroup = "SCHEDULED_TOPIC")
public class Demo04_ScheduledConsumer  implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo04_ScheduledConsumer.class);

    /**
     * 测试接收将参数topic定死，实际开发写入到配置文件
     * @param message
     */
    @Override
    public void onMessage(String message) {
        log.info("延时消息-接受到消息:" + message);
    }
}

5.3 调用接口

 /**
     * 延时消息
     * @return
     */
    @GetMapping("/sendScheduled")
    public Object scheduled() {
        scheduledProducer.scheduled();
        return "发送延时消息";
    }

5.4 测试

http://localhost:8083/sendScheduled

6，标签过滤消息

一个应用尽可能用一个Topic，消息子类型用tag来标识，tag可以由应用自由设置。 在使用rocketmqTemplate发送消息时，通过设置发送方法的destination参数来设置消息的目的地，destination的格式为topicName:tagName，:前面表示topic的名称，后面表示tag名称。

6.1 创建生产者

package com.study.producer;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class Demo05_TagProducer {
    private static final Logger log = LoggerFactory.getLogger(Demo05_TagProducer.class);

    @Resource
    RocketMQTemplate rocketMQTemplate;

    public void tag() {
        String text = "标签过滤消息," + System.currentTimeMillis();
        log.info(text);
        for (int i = 1; i <= 10; i++) {
            // 任何类型的send方法均可以指定TAG，默认可以不指定则为*
            Message<String> message = MessageBuilder.withPayload(text+"-----"+i).build();
            rocketMQTemplate.syncSend("TAG_TOPIC:TAG-A", message);
        }
        log.info("已发送...");
    }
}

6.2 创建消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(selectorExpression = "TAG-A||TAG-B", topic = "TAG_TOPIC", consumerGroup = "TAG_TOPIC")
public class Demo05_TagConsumer implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo05_TagConsumer.class);

    /**
     *
     * @param message
     */
    @Override
    public void onMessage(String message) {
        log.info("标签过滤消息-接受到消息:" + message);
    }

}

6.3 调用接口

@GetMapping("/sendTag")
    public Object tag() {
        // TAG过滤
        tag.tag();
        return "指定标签消息";
    }

6.4 测试

http://localhost:8083/sendTag

7，批量消息

生产者进行消息发送时可以一次发送多条消息，这可以大大提升Producer的发送效率。

• 批量发送的消息必须具有相同的Topic。
• 批量发送的消息必须具有相同的刷盘策略。
• 批量发送的消息不能是延时消息与事务消息。
• 消息的总大小不应超过4MB。

默认情况下，一批发送的消息总大小不能超过4MB字节，如果想超出该值，有两种解决

• 方案一：将批量消息进行拆分，拆分为若干不大于4M的消息集合分多次批量发送，一般不大于1M。
• 方案二：在Producer端与Broker端修改属性。
  Producer端需要在发送之前设置Producer的maxMessageSize属性
  Broker端需要修改其加载的配置文件中的maxMessageSize属性

7.1 创建工具类

package com.study.splitter;

import org.springframework.messaging.Message;

import java.util.Iterator;
import java.util.List;

public class MessageSplitter implements Iterator<List<Message>> {
    /**
     * 分割数据大小
     */
    private final int sizeLimit = 1024 * 1024;
    ;

    /**
     * 分割数据列表
     */
    private final List<Message> messages;

    /**
     * 分割索引
     */
    private int currIndex;

    public MessageSplitter(List<Message> messages) {
        this.messages = messages;
        // 保证单条数据的大小不大于sizeLimit
        messages.forEach(m -> {
            if (m.toString().length() > sizeLimit) {
                throw new RuntimeException("单挑消息不能大于" + sizeLimit + "B");
            }
        });
    }


    @Override
    public boolean hasNext() {
        return currIndex < messages.size();
    }

    @Override
    public List<Message> next() {
        int nextIndex = currIndex;
        int totalSize = 0;
        for (; nextIndex < messages.size(); nextIndex++) {
            Message t = messages.get(nextIndex);
            totalSize = totalSize + t.toString().length();
            if (totalSize > sizeLimit) {
                break;
            }
        }
        List<Message> subList = messages.subList(currIndex, nextIndex);
        currIndex = nextIndex;
        return subList;
    }
}

7.2 创建生产者

package com.study.producer;

import com.study.splitter.MessageSplitter;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Service
public class Demo06_BatchProducer {
    private static final Logger log = LoggerFactory.getLogger(Demo06_BatchProducer.class);

    /**
     * 测试发送将参数topic定死，实际开发写入到配置文件
     */
    @Resource
    RocketMQTemplate rocketMQTemplate;

    public void batch() {
        String text = "批量消息";
        log.info(text);

        List<Message> messageList = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            messageList.add(MessageBuilder.withPayload(text + "--" + i).build());
        }
        log.info("开始发送...");

        //把大的消息分裂成若干个小的消息
        MessageSplitter splitter = new MessageSplitter(messageList);

        while (splitter.hasNext()) {
            List<Message> nextList = splitter.next();
            SendResult result = rocketMQTemplate.syncSend("BATCH_TOPIC", nextList);
            if (result.getSendStatus() == SendStatus.SEND_OK) {
                log.info("发送批量消息成功!消息ID为:{}", result.getMsgId());
            } else {
                log.info("发送批量消息失败!消息ID为:{},消息状态为:{}", result.getMsgId(), result.getSendStatus());
            }
        }
        log.info("已发送...");
    }
}

7.3 创建消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "BATCH_TOPIC", consumerGroup = "BATCH_TOPIC")
public class Demo06_BatchComsumer  implements RocketMQListener<String> {
    private static final Logger log = LoggerFactory.getLogger(Demo06_BatchComsumer.class);

    /**
     *
     * @param message
     */
    @Override
    public void onMessage(String message) {
        log.info("批量消息-接受到消息:" + message);
    }

}

7.4 调用接口

@GetMapping("/sendBatch")
    public Object batch() {
        // 批量消息样例
        batchProducer.batch();
        return "批量消息样例";
    }

7.5 测试

http://localhost:8083/sendBatch

8，回馈消息

生产者通过sendAndReceive发送消息，消费者需要实现rocketmqReplyListener<T,T>接口

如果连续通过sendAndReceive发送消息，生产者必须收到消费者的回复才能发送下一条消息。

8.1 创建生产者

package com.study.producer;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class Demo07_ReplyProducer {
    private static final Logger log = LoggerFactory.getLogger(Demo07_ReplyProducer.class);

    @Resource
    RocketMQTemplate rocketMQTemplate;

    public void reply() {

        // 如果消费者没有回馈消息，则不会发送下一条消息
        for (int i = 1; i <= 10; i++) {
            String text = "回馈消息" + "--" + i;
            log.info("发送" + text);
            Object obj = rocketMQTemplate.sendAndReceive("REPLY_TOPIC", text, String.class);
            log.info("消费者返回的消息：" + obj);
        }
    }
}

8.2 创建消费者

package com.study.consumer;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQReplyListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "REPLY_TOPIC", consumerGroup = "REPLY_TOPIC")
public class Demo07_ReplyConsumer implements RocketMQReplyListener<String, byte[]> {
    private static final Logger log = LoggerFactory.getLogger(Demo07_ReplyConsumer.class);

    @Override
    public byte[] onMessage(String message) {
        log.info("接受到消息:" + message);
        // 返回消息到生成者
        return ("返回消息到生产者").getBytes();
    }
}

8.3 调用接口

 @GetMapping("/sendReply")
    public Object reply() {
        // 消息事务
        replyProducer.reply();
        return "回馈消息样例";
    }

8.4 测试

http://localhost:8083/sendReply