（RocketMQ）入门到上手

码下客
145 阅读9分钟

RockeMQ架构

架构图

rocketMQ.png

角色

  • Producer:生产者,会先和NameServer建立连接,得知要发送的topic时获取Broker信息,在与Broker建立连接发送消息。
  • Consumer:消费者,会先和NameServer建立连接,定时根据接受消息的topic来获取Broker信息,在与Broker建立连接接受消息。
  • NameServer:Broker会注册到NameServer中,同时管理者topic和Broker之间的关系。
  • Broker:暂存和传输消息

RocketMQ消息转发模型

1.消息模型(Message model)

RocketMQ主要由 Producer、Broker、Consumer 三部分组成，其中Producer负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。Broker 在实际部署过程中对应一台服务器，每个 Broker 可以存储多个Topic的消息，每个Topic的消息也可以分片存储于不同的 Broker。Message Queue 用于存储消息的物理地址，每个Topic中的消息地址存储于多个 Message Queue 中。ConsumerGroup由多个Consumer 实例构成。

2.消息生产者（Message Producer)

负责生产消息，一般由业务系统负责生产消息。一个消息生产者会把业务应用系统里产生的消息发送到broker服务器。RocketMQ提供多种发送方式，同步发送、异步发送、顺序发送、单向发送。同步和异步方式均需要Broker返回确认信息，单向发送不需要。生产者中，会把同一类Producer组成一个集合，叫做生产者组。同一组的Producer被认为是发送同一类消息且发送逻辑一致。

3.消息消费者 (Message Consumer)

负责消费消息，一般是后台系统负责异步消费。一个消息消费者会从Broker服务器拉取消息、并将其提供给应用程序。从用户应用的角度而言提供了两种消费形式：拉取式消费、推动式消费。

  • 拉取式消费的应用通常主动调用Consumer的拉消息方法从Broker服务器拉消息、主动权由应用控制。一旦获取了批量消息，应用就会启动消费过程。
  • 推动式消费模式下Broker收到数据后会主动推送给消费端，该消费模式一般实时性较高。

消费者同样会把同一类Consumer组成一个集合，叫做消费者组，这类Consumer通常消费同一类消息且消费逻辑一致。消费者组使得在消息消费方面，实现负载均衡和容错的目标变得非常容易。要注意的是，消费者组的消费者实例必 须订阅完全相同的Topic。
RocketMQ 支持两种消息模式：集群消费（Clustering）和广播消费（Broadcasting）。

  • 集群消费模式下, 相同Consumer Group的每个Consumer实例平均分摊消息。
  • 广播消费模式下，相同Consumer Group的每个Consumer实例都接收全量的消息。

4.主题(Topic)

表示一类消息的集合，每个主题包含若干条消息，每条消息只能属于一个主题，是RocketMQ进行消息订阅的基本单位。 Topic只是一个逻辑概念，并不实际保存消息。同一个Topic下的消息，会分片保存到不同的Broker上，而每一个分片单位，就叫做MessageQueue。
MessageQueue是一个具有FIFO特性的队列结构，生产者发送消息与消费者消费消息的最小单位。

5.代理服务器(BrokerServer)

消息中转角色，负责存储消息、转发消息。代理服务器在RocketMQ系统中负责接收从生产者发送来的消息并存储、同时为消费者的拉取请求作准备。代理服务器也存储消息相关的元数据，包括消费者组、消费进度偏移和主题和队列消息等。

Broker Server是RocketMQ真正的业务核心，包含了多个重要的子模块：

  • Remoting Module：整个Broker的实体，负责处理来自clients端的请求。Client Manager：负责管理客户端(Producer/Consumer)和维护Consumer的
  • Topic订阅信息
  • Store Service：提供方便简单的API接口处理消息存储到物理硬盘和查询功能。
  • HA Service：高可用服务，提供Master Broker 和 Slave Broker之间的数据同步功能。
  • Index Service：根据特定的Message key对投递到Broker的消息进行索引服务，以提供消息的快速查询。

而Broker Server要保证高可用需要搭建主从集群架构。RocketMQ中有两种Broker架构模式：

  • 普通集群：

这种集群模式下会给每个节点分配一个固定的角色，master负责响应客户端的请求，并存储消息。slave则只负责对master的消息进行同步保存，并响应部分客户端的读请求。消息同步方式分为同步同步和异步同步。这种集群模式下各个节点的角色无法进行切换，也就是说，master节点挂了，这一组Broker就不可用了。

  • Dledger高可用集群：

Dledger是RocketMQ自4.5版本引入的实现高可用集群的一项技术。这个模式下的集群会随机选出一个节点作为master，而当master节点挂了后，会从slave中自动选出一个节点升级成为master。 Dledger技术做的事情：1、从集群中选举出master节点 2、完成master节点往slave节点的消息同步。

6.名字服务(NameServer)

名称服务充当路由消息的提供者。Broker Server会在启动时向所有的NameServer注册自己的服务信息，并且后续通过心跳请求的方式保证这个服务信息的实时性。生产者或消费者能够通过名字服务查找各主题相应的Broker IP列表。

多个Namesrv实例组成集群，但相互独立，没有信息交换。这种特性也就意味着NameServer中任意的节点挂了，只要有一台服务节点正常，整个路由服务就不会有影响。当然，这里不考虑节点的负载情况。

7.消息(Message)

消息系统所传输信息的物理载体，生产和消费数据的最小单位，每条消息必须属于一个主题Topic。RocketMQ中每个消息拥有唯一的Message ID，且可以携带具有业务标识的Key。系统提供了通过Message ID和Key查询消息的功能。并且Message上有一个为消息设置的标志，Tag标签。用于同一主题下区分不同类型的消息。来自同一业务单元的消息，可以根据不同业务目的在同一主题下设置不同标签。标签能够有效地保持代码的清晰度和连贯性，并优化RocketMQ提供的查询系统。消费者可以根据Tag实现对不同子主题的不同消费逻辑，实现更好的扩展性。

SpringBoot整合RocketMQ

pom.xml

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

生产者application.yaml

rocketmq:
  name-server: //NameServer地址,多个用逗号隔开
  producer:
    group: //生产者组名
    topic: //主题
    test-tag: //tag标签

1.基本消息使用

@RestController
@RequestMapping("/mq")
public class MqController {


    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Value(value = "${rocketmq.producer.topic}:${rocketmq.producer.test-tag}")
    private String tag;


    @GetMapping("/send/{id}")
    public void send(@PathVariable int id){
        String message = "test:" + id;
        Message<String> build = MessageBuilder.withPayload(message)
                .setHeader(RocketMQHeaders.KEYS, id)
                .build();
        //同步消息
        SendResult sendResult = rocketMQTemplate.syncSend(tag, build);
        //异步消息
        rocketMQTemplate.asyncSend(tag, build, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                //回调
            }

            @Override
            public void onException(Throwable throwable) {
                //异常回调
            }
        });
        //单向发送
        rocketMQTemplate.sendOneWay(tag,build);
    }

}

2.顺序消息

@GetMapping("/send2/{id}")
public void send2(@PathVariable int id){
    //模拟创建3个订单后续步骤
    for (int i = 0 ; i< 3; i++){
        String orderId = "i:" + id;
        for (int j = 0; j < 5; j++) {
            String message = orderId + ":" + j;
            Message<String> build = MessageBuilder.withPayload(message)
                    .build();
            //用选择器Selector发送消息
            rocketMQTemplate.setMessageQueueSelector(new MessageQueueSelector() {
                /**
                 * 设置放入同一个队列的规则
                 * @param list 消息队列
                 * @param message 消息
                 * @param o 比较的信息
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, org.apache.rocketmq.common.message.Message message, Object o) {
                    /**
                     * list中包含了当前topic下的所有队列，根据o来进行一些特定的算法取值来获得一个唯一值后拿到的队列就是相同的队列
                     */
                    int queueNum = Integer.valueOf(String.valueOf(o)) % list.size();
                    return list.get(queueNum);
                }
            });
            //第三个参数和上面选择器中的o对应
            rocketMQTemplate.syncSendOrderly(tag,build,String.valueOf(i));
        }

    }
}

3.发送延迟消息

@GetMapping("/send3/{id}")
public void send3(@PathVariable int id){
    String message = "test:" + id;
    Message<String> build = MessageBuilder.withPayload(message)
            .build();
    //设置超时和延迟消息,超时是broker返回到生产者这一过程的时间
    //rocketMQ免费开源版不能随意指定过期时间,只能选择对应的level:"1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
    rocketMQTemplate.syncSend(tag,build,3000,3);
}

4.批量发送消息

@GetMapping("/send4/{id}")
public void send4(@PathVariable int id){
    List<Message> messages = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        Message<String> build = MessageBuilder.withPayload(i + ":" + id)
                .build();
        messages.add(build);
        // 批量下发消息到broker,不支持消息顺序操作，并且对消息体有大小限制（不超过4M）
        rocketMQTemplate.syncSend(tag,messages);
    }
}

5.事务消息

@GetMapping("/send4/{id}")
public void send4(@PathVariable int id){
    String message = "test:" + id;
    Message<String> build = MessageBuilder.withPayload(message)
            .build();
    rocketMQTemplate.sendMessageInTransaction(tag,build,null);
}

@RocketMQTransactionListener
@Component
public class OrderTransactionListener implements TransactionListener {


    /**
     * 提交完事务消息后执行
     * @param message
     * @param o
     * @return
     */
    @Override
    public LocalTransactionState executeLocalTransaction(Message message, Object o) {
        LocalTransactionState state;
        try {
            //举例订单超时业务来  生产者收到消息则修改订单为已支付
            //要用事务id和当前的业务id去建立一个关系
            //判断用户是否支付 true支付 false未支付
            boolean type = true;
            if(type){
                // COMMIT_MESSAGE状态的消息会立即被消费者消费到
                state = LocalTransactionState.COMMIT_MESSAGE;
            } else {
                //UNKNOW状态会执行下面checkLocalTransaction()方法进行回查
                state = LocalTransactionState.UNKNOW;
            }
        } catch (Exception e){
            //丢弃消息
            state = LocalTransactionState.ROLLBACK_MESSAGE;
        }
        return state;
    }

    /**
     * 在对UNKNOWN状态的消息进行状态回查时执行。
     * @param messageExt
     * @return
     */
    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
        LocalTransactionState state;
        //根据事务id查到当前的业务id去判断订单是否支付
        try {
            //判断用户是否支付 true支付 false未支付
            boolean type = true;
            if(type){
                // COMMIT_MESSAGE状态的消息会立即被消费者消费到
                state = LocalTransactionState.COMMIT_MESSAGE;
            } else {
                //UNKNOW状态会执行下面checkLocalTransaction()方法进行回查
                state = LocalTransactionState.UNKNOW;
            }
        } catch (Exception e){
            //丢弃消息
            state = LocalTransactionState.ROLLBACK_MESSAGE;
        }
        return state;
    }
}

消费者application.yaml

rocketmq:
  name-server: //NameServer地址
  consumer:
    group: //消费者组名
    topic: //监听的topic
    tags: //监听的tag 监听多个用||隔开

消费者

/**
 * 设置消息监听
 * 1.监听组(consumerGroup)：监听topic(topic)：监听tag(selectorExpression)(默认监听topic下所有)
 * 2.监听消费模式(messageModel):默认负载均衡：CLUSTERING（每一个消息只发给一个消费者）、广播模式：BROADCASTING（发送给所有消费者）
 * 3.设置顺序消息处理模式(consumeMode)（默认是所有线程可以处理同一个消息队列（ConsumeMode.CONCURRENTLY）,当前消息没有线程在执行时其他线程才能够执行（ConsumeMode.ORDERLY）。
 * 4.设置过滤tags类型：默认时tag（SelectorType.TAG）,可以修改为sql语法(SelectorType.SQL92)：
 */
@Component
@RocketMQMessageListener(consumerGroup = "${rocketmq.consumer.group}", topic = "${rocketmq.consumer.topic}",
        selectorExpression = "${rocketmq.consumer.tags}", messageModel = MessageModel.CLUSTERING,
        consumeMode = ConsumeMode.ORDERLY, selectorType = SelectorType.TAG)
public class Consumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String s) {
        System.out.println(s);
    }
}
avatar
文章
阅读
粉丝