RocketMQ整合Springboot实战

一、RocketMQ核心组件介绍

RocketMQ的正题运行架构如下图：

1、nameServer 命名服务

nameserver服务是独立运行的，不依赖任何其他服务，类似于微服务的注册中心，我们在实际应用中，只需要访问nameserver的地址就可以，支持 Topic、Broker 的动态注册与发现。

主要包括两个功能：

• Broker管理，NameServer接受Broker集群的注册信息并且保存下来作为路由信息的基本数据。然后提供心跳检测机制，检查Broker是否还存活；
• 路由信息管理，每个NameServer将保存关于 Broker 集群的整个路由信息和用于客户端查询的队列信息。Producer和Consumer通过NameServer就可以知道整个Broker集群的路由信息，从而进行消息的投递和消费。

NameServer通常会有多个实例部署，各实例间相互不进行信息通讯。Broker是向每一台NameServer注册自己的路由信息，所以每一个NameServer实例上面都保存一份完整的路由信息。当某个NameServer因某种原因下线了，客户端仍然可以向其它NameServer获取路由信息。

2、broker 核⼼服务

broker是最重要的核心组件，消息的存储、推送、查询都是broker提供的，也是rocketmq中最复杂的部分

3、client 客户端

客户端分为消息的生产者和消费者，生产者将消息推送给broker，消费者通过拉或者推的模式消费消息

三、RocketMQ原生API消息收发实战

原生API，大家可以参考源码包里面的example,这里面详细的介绍了RocketMQ各类消息是如何发送和消费的

官网地址：下载 | RocketMQ

四、springboot整合RocketMQ实战

1、POM文件中引入RocketMQ的jar包

        
            org.apache.rocketmq
            rocketmq-spring-boot-starter
            2.2.2
            
                
                    org.apache.rocketmq
                    rocketmq-client
                
            
        
        
            org.apache.rocketmq
            rocketmq-client
            4.9.5
        
        
            org.springframework.boot
            spring-boot-starter-web
            2.5.9
        
        
            org.springframework.boot
            spring-boot-starter-test
            2.7.5
        
        
            junit
            junit
            4.13.2
            test
        
        
            io.springfox
            springfox-swagger-ui
            2.10.5
        
        
            io.springfox
            springfox-swagger2
            2.10.5
        
        
            com.github.xiaoymin
            knife4j-openapi2-spring-boot-starter
            4.4.0
        
    

2、application.properties

server:
  port: 8092
rocketmq:
  producer:
    group: myProducerGroup
  name-server: 192.168.1.112:9876
knife4j:
  enable: true
  openapi:
    title: RocketMQ实战
    description: RocketMQ实战
    # aaa"
    email:
    concat: sun初一
    url:
    version: v4.0
    license: Apache 2.0
    license-url:
    terms-of-service-url:
    group:
      test1:
        group-name: rocketmq
        api-rule: package
        api-rule-resources:
          - com.sun.rocketmq

3、编写一个consumer类

@Component
@RocketMQMessageListener(consumerGroup = "MyConsumerGroup", topic = "TestTopic", consumeMode = ConsumeMode.CONCURRENTLY, messageModel = MessageModel.BROADCASTING)
public class SpringBootConsumer implements RocketMQListener {
    @Override
    public void onMessage(String message) {
        System.out.println("Received message : " + message);
    }
}

4、编写producer类

package com.sun.rocketmq.controller;

import com.sun.rocketmq.pojo.User;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQLocalRequestCallback;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.apache.rocketmq.spring.support.RocketMQHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/test/producer")
@Api(tags = "RocketMQ实战")
public class ProducerController {

    private final static String topicName = "TestTopic";

    @Resource
    private RocketMQTemplate rocketMQTemplate;

    @GetMapping("sendExample")
    @ApiOperation("发送字符串消息")
    public String sendExample() {
        //发送字符消息
        SendResult sendResult = rocketMQTemplate.syncSend(topicName, "Hello, World!");
        System.out.printf("syncSend1 to topic %s sendResult=%s %n", topicName, sendResult);
        return "ok";
    }

    @GetMapping("sendObjectMsg")
    @ApiOperation("发送对象消息")
    public String sendObjectMsg() {
        SendResult sendResult = rocketMQTemplate.syncSend(topicName, new User("初一", 18, "上海"));
        System.out.println(sendResult);
        return "ok";
    }

    @GetMapping("sendAsyncObjectMsg")
    @ApiOperation("异步发送对象消息")
    public String sendAsyncObjectMsg() {
        //发送对象消息
        rocketMQTemplate.sendAndReceive(topicName, new User("初一", 30, "北京"), new RocketMQLocalRequestCallback() {
            @Override
            public void onSuccess(User message) {
                System.out.printf("send user object and receive %s %n", message.toString());
            }

            @Override
            public void onException(Throwable e) {
                e.printStackTrace();
            }
        }, 5000);
        return "ok";
    }

    @GetMapping("sendBatchMsg")
    @ApiOperation("批量发送消息")
    public String sendBatchMsg() {
        //发送批量消息
        List msgs = new ArrayList();
        for (int i = 0; i < 10; i++) {
            msgs.add(MessageBuilder.withPayload("Batch Msg#" + i).
                    setHeader(RocketMQHeaders.KEYS, "KEY_" + i).build());
        }
        SendResult sr = rocketMQTemplate.syncSend(topicName, msgs, 60000);
        System.out.println(sr);
        return "ok";
    }

}

上面是个简单的小例子，供大家参考，欢迎一起交流