Spring Boot 2.7 整合 Dubbo 3+Zookeeper

一、基础知识

1.1 分布式理论

什么是分布式系统

• 分布式系统：是若干独立计算机的集合，这些计算机对于用户来说，就像单个相关系统；

• 分布式系统，是由一组通过网络进行通信、为了完成共同的任务，而协调工作的计算机节点，组成的系统；

• 分布式系统的出现，是为了用廉价的、普通的机器，完成单个计算机无法完成的计算、存储任务，其目的是：利用更多的机器，处理更多的数据；

• 分布式系统（distributed system）是建立在网络之上的软件系统；

• 只有当单个节点的处理能力，无法满足日益增长的计算、存储任务时，且硬件的提升（加内存、加磁盘、使用更好的 CPU）高昂到，得不偿失时，应用程序也不能进一步优化时，才需要考虑分布式系统；

• 分布式系统，要解决的问题本身，就是和单机系统一样的，由于分布式系统多节点、通过网络通信的拓扑结构，会引入很多单机系统没有的问题，为了解决这些问题，又会引入更多的机制、协议，带来更多的问题；

• 随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构 以及 流动计算架构 势在必行，急需一个治理系统确保架构有条不紊的演进；

  

单一应用架构：

• 当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本，此时，用于简化增、删、改、查，工作量的 数据访问框架（ORM）是关键；

  

• 适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用；

• 缺点：

  • 性能扩展比较难；
  • 协同开发问题；
  • 不利于升级维护；

垂直应用架构：

• 当访问量逐渐增大，单一应用，增加机器带来的加速度，越来越小，将应用拆成互不相干的几个应用，以提升效率，此时，用于加速前端页面开发的，Web 框架（MVC）是关键；

  

• 通过切分业务，来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职，更易管理，性能扩展也更方便，更有针对性；

• 缺点：

  • 公用模块无法重复利用，开发性的浪费；

分布式服务架构：

• 当垂直应用越来越多，应用之间，交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用，能更快速的响应多变的市场需求，此时，用于提高业务复用及整合的 分布式服务框架（RPC）是关键；

  

流动计算架构：

• 当服务越来越多，容量的评估，小服务资源的浪费等问题，逐渐显现，此时需增加一个调度中心，基于访问压力，实时管理集群容量，提高集群利用率，此时，用于提高机器利用率的，资源调度和治理中心 （SOA）[ Service Oriented Architecture] 是关键；

  

1.2 什么是 RPC

• RPC（Remote Procedure Call）：是指远程过程调用，是一种进程间通信方式，是一种技术的思想，而不是规范，它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节，即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同；

• 也就是说两台服务器 A，B，一个应用部署在 A 服务器上，想要调用 B 服务器上应用提供的函数或方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据；

• 为什么要用 RPC：

  • 就是无法在一个进程内，甚至一个计算机内，通过本地调用的方式完成的需求，比如：不同的系统间的通讯，甚至不同的组织间的通讯，由于计算能力需要横向扩展，需要在多台机器组成的集群上，部署应用，RPC 就是要像调用本地的函数一样，去调远程函数；

• RPC 基本原理：

  

• 步骤解析：

  

• RPC 两个核心模块：

  • 通讯；
  • 序列化；

二、Dubbo

• 官方文档

2.1 Dubbo 基本概念

• Apache Dubbo ˈdʌbəʊ 是一款高性能、轻量级的开源 Java RPC 框架；

• Dubbo 提供了三大核心能力：

  • 面向接口的远程方法调用；
  • 智能容错和负载均衡；
  • 服务自动注册和发现；

  

• 服务提供者**（Provider）**：暴露服务的服务提供方，服务提供者，在启动时，向注册中心，注册自己提供的服务；

• 服务消费者**（Consumer）**：调用远程服务的服务消费方，服务消费者，在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用；

• 注册中心**（Registry）**：返回服务提供者地址列表，给消费者，如果有变更，注册中心将基于长连接，推送变更数据给消费者；

• 监控中心**（Monitor）**：服务消费者和提供者，在内存中，累计调用次数和调用时间，定时每分钟发送一次统计数据，到监控中心；

• 调用关系说明：

  • 服务容器，负责启动，加载，运行服务提供者；
  • 服务提供者，在启动时，向注册中心，注册自己提供的服务；
  • 服务消费者，在启动时，向注册中心，订阅自己所需的服务；
  • 注册中心，返回服务提供者地址列表，给消费者，如果有变更，注册中心，将基于长连接，推送变更数据给消费者；
  • 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用；
  • 服务消费者和提供者，在内存中累计调用次数，和调用时间，定时每分钟发送一次统计数据，到监控中心；

2.2 Dubbo 环境搭建

• 推荐使用 Zookeeper 注册中心

ZooKeeper 简介

• 官网地址
• ZooKeeper 是一个开源的分布式协调服务，由雅虎创建，是 Google Chubby 的开源实现；
• 分布式应用程序，可以基于 ZooKeeper 实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、配置维护，名字服务、分布式同步、分布式锁和分布式队列等功能；

window 下安装 Zookeeper

• Zookeeper 3.8.0：下载地址

• win 10 下解压 .tar.gz 文件：

  • 管理员身份运行，命令行窗口；

  • 提示符下输入：tar -zxvf 要解压的文件名；

    

• 运行 /bin/zkServer.cmd，初次运行会报错，需要配置 zoo.cfg 文件；

• 可能遇到问题：闪退；

  • 解决方案：编辑 zkServer.cmd，在文件末尾，添加 pause，这样，运行出错就不会退出，会提示错误信息，方便找到原因；

    

  • 提示错误原因：未找到 zoo.cfg 文件；

    

• 修改 zoo.cfg 配置文件：

  • 将 conf 文件夹下的 zoo_sample.cfg 复制一份，改名为 zoo.cfg 即可；

  • 注意几个重要位置：

    • dataDir=/tmp/zookeeper：临时数据存储的目录（可写相对路径）；

    • clientPort=2181：Zookeeper 客户端连接端口；

    • audit.enable=true：3.6 以上的版本，需要添加，开启审核日志，否则启动失败；

      

    • admin.serverPort=8088：添加服务端口，Zookeeper 在 3.5.5 版本后，默认为 8080 端口；

• 修改完成后，再次启动 Zookeeper；

• 打开 zkCli.cmd 测试：

  • ls /：列出 Zookeeper 根下，保存的所有节点；

    

  • create -e /test 123：创建一个 test 节点，值为 123：

    

  • get /test：获取 /test 节点的值：

    

  • 再次查看一下所有节点：ls /

    

Docker 安装 Zookeeper

# 1.查看镜像
docker search zookeeper

# 2.拉取镜像
docker pull zookeeper

# 3.查看镜像
docker images

# 4.运行容器
# 命令限制内存大小，并映射端口2181到本地
docker run -d --name myZookeeper --restart always -e JVMFLAGS="-Xmx1024m" -p 2181:2181 zookeeper

# 5.查看容器是否运行
docker ps

# 6.进入容器
docker exec -it myZookeeper /bin/bash

# 7.进入到bin目录下，连接zkClinet.sh
cd bin
zkClinet.sh

Dubbo-admin 简介

• Dubbo 本身并不是一个服务软件，它其实就是一个 jar 包，能够帮助 Java 程序连接到 Zookeeper，并利用 Zookeeper 消费、提供服务；
• 为了让用户更好的管理监控众多的 Dubbo 服务，官方提供了一个可视化的监控程序 Dubbo-admin，不安装也不影响使用；

window 下安装 Dubbo-admin

• 下载 Dubbo-admin

  • 注意：新版的 Dubbo-admin 为前后端分离项目，需要开启 Zookeeper 后，先运行后端，再运行前端；

• 解压下载的文件：dubbo-admin-develop.zip；

  

• 修改后端配置：进入目录 dubbo-admin-server/src/main/resources，修改 application.properties 配置文件；

# 默认注册中心的地址(必须与zookeeper对应)
admin.registry.address=zookeeper://127.0.0.1:2181
admin.config-center=zookeeper://127.0.0.1:2181
admin.metadata-report.address=zookeeper://127.0.0.1:2181
# 默认的用户名密码
admin.root.user.name=root
admin.root.user.password=root

# 添加自定义端口(避免冲突)
server.port=8000

• mvn 打包项目，在 dubbo-admin-server 目录下，执行命令：
  • 需要先安装 Maven；
  • 注意：JDK 版本要一致（1.8）；

# 打包项目并且跳过测试
mvn clean package -Dmaven.test.skip=true

• 打包成功：

  

• 运行后端项目：执行 dubbo-admin-server\target 下生成的 jar 包；

  • 注意运行环境与 jar 包的 JDK 版本要一致（1.8）；

java -jar dubbo-admin-server-0.4.0.jar

• 运行成功：

  

• 注意：Zookeeper 的服务一定要打开，否则无法运行；

• 或者在 IDEA 中打开项目，直接运行（注意 JDK 版本要一致）；

• 修改前端配置文件：dubbo-admin-ui 目录下的 vue.config.js；

proxy: {
  '/': {
    // 修改对应后端的地址及端口
    target: 'http://localhost:8000/',
    changeOrigin: true,
    pathRewrite: {
      '^/': '/'
    }
  }
}

• 运行前端程序：

  • npm install：安装依赖，如报错，可多试几次；
  • npm run dev：运行项目；
  • 注意：需要安装 Node.js 和 npm，Node 和 npm 版本过高可能出错，测试版本：Node：v12.22.12，npm：6.14.16；

  

• 访问测试：http://localhost:8082/，账户和密码，默认都为 root；

  • 注：首次运行，加载较慢；

  

• 运行界面：

  

三、SpringBoot 2.7 整合 Dubbo 3.0.8 + zookeeper 3.8.0

3.1 项目搭建

• 项目结构：

  

• 业务提供者没有 controller 层，消费者只有 controller 对外暴露服务；

• 相关依赖：

<!-- dubbo-spring-boot依赖 -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>3.0.8</version>
</dependency>
<!--zookeeper客户端：包含curator-framework、curator-recipes这两个依赖-->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-x-discovery</artifactId>
    <version>5.2.1</version>
</dependency>

创建父模块项目

• IDEA 创建一个空的 Maven 项目，删除 src 目录；
• 在父模块项目中，只对依赖进行统一管理；
• 修改配置文件：pom.xml

<?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>com.study</groupId>
    <artifactId>springboot-dubbo-zookeeper</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--子模块-->
    <modules>
        <module>common</module>
        <module>dubbo-consumer</module>
        <module>dubbo-provider</module>
    </modules>

    <!--使用maven分模块管理-->
    <packaging>pom</packaging>
    <!--父类：继承spring-boot-dependencies，统一依赖管理-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <!--从父级仓库查找依赖版本-->
        <relativePath/>
    </parent>

    <!-- 统一管理jar包版本 -->
    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <dubbo-boot.version>3.0.8</dubbo-boot.version>
        <curator.version>5.2.1</curator.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- dubbo-spring-boot依赖 -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo-boot.version}</version>
            </dependency>
            <!--zookeeper客户端，包含curator-framework、curator-recipes这两个依赖-->
            <dependency>
                <groupId>org.apache.curator</groupId>
                <artifactId>curator-x-discovery</artifactId>
                <version>${curator.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

创建公共子模块

• 创建 Spring Boot 模块 common；
• 配置文件：pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--父类-->
    <parent>
        <groupId>com.study</groupId>
        <artifactId>springboot-dubbo-zookeeper</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>com.study</groupId>
    <artifactId>common</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>common</name>
    <description>common</description>

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

• 创建公共的服务接口：
  • 新建 service 目录，创建接口文件：UserService；

public interface UserService {
    public String getUserName(String name);
}

3.2 服务提供者

创建提供者子模块

• 创建 Spring Boot 模块，实现服务 提供者：dubbo-provider；

• 修改配置文件：pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.study</groupId>
        <artifactId>springboot-dubbo-zookeeper</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>com.study</groupId>
    <artifactId>dubbo-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dubbo-provider</name>
    <description>dubbo-provider</description>

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

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

        <!-- dubbo-spring-boot依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
        <!--zookeeper客户端，包含curator-framework、curator-recipes这两个依赖-->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-x-discovery</artifactId>
        </dependency>
        <!--引入公共模块common-->
        <dependency>
            <groupId>com.study</groupId>
            <artifactId>common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

• 配置文件：application.yaml

server:
  port: 8091

dubbo:
  application:
    # 当前服务/应用的名字
    name: dubbo-provider
  registry:
    # 注册中心的协议和地址
    address: zookeeper://127.0.0.1:2181
    # 使用curator客户端
    client: curator
    # 通信规则（通信协议和接口）
  protocol:
    name: dubbo
    port: 20881
  scan:
    base-packages: com.study.service

• 创建 service 实现类：
  • 新建 service 目录，创建 UserServiceImpl；

// 注册组件：使用Dubbo尽量不是使用@Service
@Component
// Dubbo注册：项目启动时，自动注册到注册中心
@DubboService
// 实现公共接口UserService，通过公共模块依赖引入
public class UserServiceImpl implements UserService {
    @Override
    public String getUserName(String name) {
        return "hello " + name;
    }
}

• 主程序类：@EnableDubbo 开启 Dubbo；

@SpringBootApplication
// 开启Dubbo
@EnableDubbo
public class DubboProviderApplication {

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

}

3.3 消费者模块

创建消费者子模块

• 创建 Spring Boot 模块，实现服务 消费者：dubbo-consumer，添加 web 依赖；

• 配置文件：pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.study</groupId>
        <artifactId>springboot-dubbo-zookeeper</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>com.study</groupId>
    <artifactId>dubbo-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dubbo-consumer</name>
    <description>dubbo-consumer</description>

    <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>

        <!-- dubbo-spring-boot依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
        <!--zookeeper客户端，包含curator-framework、curator-recipes这两个依赖-->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-x-discovery</artifactId>
        </dependency>
        <!--引入公共模块common-->
        <dependency>
            <groupId>com.study</groupId>
            <artifactId>common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

• 配置文件：application.yaml

server:
  port: 8092

dubbo:
  application:
    # 当前服务/应用的名字
    name: dubbo-consumer
  registry:
    # 注册中心的协议和地址
    address: zookeeper://127.0.0.1:2181
    # 使用curator客户端
    client: curator
    # 通信规则（通信协议和接口）
  protocol:
    name: dubbo
    port: 20882
#  consumer:
#    check: false # 关闭所有服务的启动时检查：(默认没有提供者时报错) 写在定义服务消费者一方
#    retries: 3 # 失败重试次数

• 创建 controller：UserController

@RestController
public class UserController {
    // 消费者，需要调用注册中心的服务
    // @DubboReference：注入分布式中,远程服务对象
    @DubboReference
    private UserService userService;

    @RequestMapping("/user/{name}")
    public String getUser(@PathVariable("name") String name) {
        return userService.getUserName(name);
    }
}

• 主程序类：@EnableDubbo 开启 Dubbo；

@SpringBootApplication
@EnableDubbo
public class DubboConsumerApplication {

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

}

3.4 运行测试

• 开启 Zookeeper；

  

• 先运行提供者模块，再运行消费者模块；

• 访问测试：http://localhost:8092/user/测试；

  

• 开启 Dubbo-admin；

  

• 查看信息：

  

• 提供者：

  

• 消费者：

  

可能遇到的问题：

• 问题1：项目代码，启动一直报错：

  

java.lang.reflect.InaccessibleObjectException: Unable to make field final int java.math.BigInteger.signum accessible: module java.base does not "opens java.math" to unnamed module @5f058f00

• 分析：可能是 JDK9 及以上版本中，引入的 Java Platform Module System 模块化导致的；

• 解决方案：

  • 在 IDEA 中修改 VM 增加启动参数：
    • --add-opens java.base/java.math=ALL-UNNAMED --add-opens java.base/java.lang=ALL-UNNAMED

  

• 问题 2：dubbo 提供者和消费者都成功启动，dubbo 管控台没有显示；

• 解决：先运行提供者和消费者模块（启动消费者后，要运行消费者项目，使消费者调用到提供者提供的服务），再运行 dubbo 管控台；

3.5 负载均衡测试

• 观察负载均衡，需要启动两个服务器提供者：
  • 两个服务提供者的端口不能相同，并且 protocol 下面的端口也不能相同；
  • 注意：两个服务提供者的 application.name 必须相同，要不然它们就是两种服务了，不是一种服务的两个服务器提供者；

创建提供者子模块 2

• 参照上面的提供者子模块，再创建一个提供者子模块；
• 配置文件：application.yaml

server:
  # 端口号不能相同
  port: 8093

dubbo:
  application:
    # 名称必须一致
    name: dubbo-provider
  registry:
    address: zookeeper://127.0.0.1:2181
    client: curator
  protocol:
    name: dubbo
    # 端口号不能相同
    port: 20883
  scan:
    base-packages: com.study.service

• service 实现类：UserServiceImpl

// 注册组件：使用Dubbo尽量不是使用@Service
@Component
// Dubbo注册：项目启动时，自动注册到注册中心
@DubboService
// 实现公共接口UserService，通过公共模块依赖引入
public class UserServiceImpl implements UserService {
    @Override
    public String getUserName(String name) {
        // 为方便查看，修改返回内容
        return "hi " + name;
    }
}

• 依次启动三个服务器，查看 dubboAdmin，可以发现消费者和服务提供者都注册成功了：

  

• 访问测试：http://localhost:8092/user/测试

  

• 刷新：

  

• 两次访问相同的地址，返回不同的结果，负载均衡运行成功；