如何在同一个Java进程中连接多个RocketMQ服务器

解决RocketMQ单JVM实例连接多个NameServer的问题

最新推荐文章于 2025-03-17 08:00:00 发布

转载最新推荐文章于 2025-03-17 08:00:00 发布 · 2.2k 阅读

2 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/2436973/blog/3089151

文章标签：

#java-rocketmq

中间件专栏收录该内容

1 篇文章

订阅专栏

博客分析了RocketMQ客户端限制一个JVM实例只能连接一个NameServer的原因，并提供了三种解决方案。通过修改instanceName或unitName、使用不同配置启动多个实例以及利用sandbox工具实现代码隔离，可以实现多个MQClient实例。示例代码展示了如何在SpringBoot应用中创建并使用多个RocketMQClient实例，每个连接不同的NameServer。

问题的根源

我们从代码层级来分析到底为什么会产生 “一个 JVM 实例只能连接一个 NameServer”。
RocketMQ Client 有一个核心类 MQClientManager, 在我们需要使用 MQ Client 实例的时候，实际上都是通过它的 getAndCreateMQClientInstance 方法进行创建的；名称比较拗口，同时是 Get 和 Create，这不太符合我们所说的设计单一性原则，但这不是我们讨论的重点，我们看一看这个方法的实现

    public MQClientInstance getAndCreateMQClientInstance(ClientConfig clientConfig, RPCHook rpcHook) {
        String clientId = clientConfig.buildMQClientId();
        MQClientInstance instance = (MQClientInstance)this.factoryTable.get(clientId);
        if (null == instance) {
            instance = new MQClientInstance(clientConfig.cloneClientConfig(), this.factoryIndexGenerator.getAndIncrement(), clientId, rpcHook);
            MQClientInstance prev = (MQClientInstance)this.factoryTable.putIfAbsent(clientId, instance);
            if (prev != null) {
                instance = prev;
                log.warn("Returned Previous MQClientInstance for clientId:[{}]", clientId);
            } else {
                log.info("Created new MQClientInstance for clientId:[{}]", clientId);
            }
        }

        return instance;
    }

代码不复杂，我们可以看到它利用客户的配置信息生成一个固定的 clientId，以此去缓存 factoryTable 中查找，不存在才会创建全新一个实例。
那么，可以理解一个 clientID 仅能存在一个连接实例了，可这个 clientId 是怎么产生的呢？继续跟踪看看这段代码

    public String buildMQClientId() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.getClientIP());
        sb.append("@");
        sb.append(this.getInstanceName());
        if (!UtilAll.isBlank(this.unitName)) {
            sb.append("@");
            sb.append(this.unitName);
        }

        return sb.toString();
    }

代码层面上对 clientId 进行了约定，格式为 “ClientIp@InstanceName” 格式，当 unitName 不为空的时候还会在后面加上 “@unitName”。

怎么解决？

从代码分析上我们可以知道，为了创建多实例，我们可以

设定不同的 instanceName：
instanceName 从哪来的？
```
instanceName = System.getProperty("rocketmq.client.name", "DEFAULT");
```
从系统属性中读取出来的，也就是一般在 JVM 启动时设定的。。。可以变吗？当然，你可以通过代码去做到，但这么做的话，你会失去让人理解你代码的能力的，哈哈
这就是为什么多少 RocketMQ Client 都只能连接一个服务器的原因了，它根本不考虑服务器是谁，仅关心自己，自私的家伙！
设定不同的 unitName

除此之外还有其它解决方案吗？我仔细从网络上翻了一轮，没看到什么好方法，是大家都没这个场景还是有其它好办法解决了呢？欢迎大家讨论～

方法 3

在上一篇博文来自平行世界的救赎里面，我做了个工具 sandbox，我提供的方法 3 就是依托于这个工具。
sandbox 通过代码隔离的方式，将另一份类定义放入沙箱中运行，从而实现多个实例完全隔离的效果。
MQClientManager 通过缓存方式，以 clientId 作为 key 值存储到自身实例当中，为了实现多个 Client，那么前两种方法的逻辑是修改 clientId 实现多个实例，而方法 3 的逻辑则是 “既然你的缓存已经有这个 key，我就换个缓存”，本质就是 “你这个锅不装我，我就换个锅”。

怎么做？

这里我使用一个 springboot 项目作为演示案例。
通过 springboot 的 Configuration 将多个 RocketMQ Client 进行注册，再定义一个 Controller 接收不同请求去发送 MQ 消息，最后加上启动类。

我们先从 pom 文件中引入包（我没有推上 maven 仓库，各位可以从 github/gitee 上下载），代码如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>me.van</groupId>
    <artifactId>rocket-mq-multi-client-test</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>测试多个rocketmq client共存</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <start-class>me.van.App</start-class>
        <java.version>1.8</java.version>
        <lombok.version>1.14.8</lombok.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.4.0</version>
        </dependency>
        <dependency>
            <groupId>me.van</groupId>
            <artifactId>sandbox</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

此处引入了 apache 的 rocketmq-client 组件作为 mq 客户端，也就是存在前面所说的问题的组件。

启动类

package me.van;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

非常的简单，没什么好介绍的。

配置类

package me.van;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MQProducer;
import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean(autowire = Autowire.BY_NAME, value = "producer")
    MQProducer producer() throws MQClientException {
        DefaultMQProducer producer = new DefaultMQProducer();
        initProducer(producer, "a.io:9876;b.io:9876");
        return producer;
    }


    @Bean(autowire = Autowire.BY_NAME, value = "producer_sandbox1")
    MQProducer producerSandbox1() throws MQClientException, SandboxCannotCreateObjectException {
        DefaultMQProducer producer = createProducerInSandbox();
        initProducer(producer, "x.io:9876;y.io:9876");
        return producer;
    }


    @Bean(autowire = Autowire.BY_NAME, value = "producer_sandbox2")
    MQProducer producerSandbox2() throws MQClientException, SandboxCannotCreateObjectException {
        DefaultMQProducer producer = createProducerInSandbox();
        initProducer(producer, "1.io:9876;2.io:9876");
        return producer;
    }

    private DefaultMQProducer createProducerInSandbox() throws SandboxCannotCreateObjectException {
        Sandbox sandbox = new Sandbox("org.apache.rocketmq.client");
        return sandbox.createObject(DefaultMQProducer.class);
    }

    private void initProducer(DefaultMQProducer producer, String namesrvAddr) throws MQClientException {
        producer.setNamesrvAddr(namesrvAddr);
        producer.setProducerGroup("test-group");
        producer.setRetryAnotherBrokerWhenNotStoreOK(true);
        producer.start();
    }
}

这里可以看到，producer 对象是直接 new 出来的 DefaultMQProducer，而 producer_sandbox1 和 producer_sandbox2 是通过不同的沙箱创建出来的；三个 client 分别连接到不同的 NameServer 中，同时其它属性保持一致。

Controller

package me.van;

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.MQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    MQProducer producer;
    @Autowired
    MQProducer producer_sandbox1;
    @Autowired
    MQProducer producer_sandbox2;

    @GetMapping("/")
    public String hello(){
        return "hello world";
    }

    @GetMapping("/send")
    public String send(String msg){
        if(null == msg) return "msg is null";

        String returnMsg = "";
        Message message = new Message("topic-test-multi-mq-client", msg.getBytes());
        try {
            producer.send(message);
            returnMsg += "原生producer发送完成<br/>";

            producer_sandbox1.send(message);
            returnMsg += "第一个沙箱内producer发送完成<br/>";

            producer_sandbox2.send(message);
            returnMsg += "第二个沙箱内producer发送完成<br/>";
        } catch (MQClientException | InterruptedException | RemotingException | MQBrokerException e) {
            returnMsg += "发送过程出现异常：" + e.getMessage();
        }
        return returnMsg;
    }
}

通过 send 方法同时向三个 producer 发送消息。