Spring Boot + Spring Cloud + Dubbo + Nacos 分布式微服务项目整合

1. Spring Boot + Spring Cloud + Dubbo + Nacos 分布式微服务项目整合

1.1. 技术栈整合概览

1.1.1. 技术栈列表

技术版本作用
Spring Boot3.4.5快速构建和启动应用，提供自动装配机制
Spring Cloud Alibaba2023.0.3.2提供服务注册发现、配置中心等微服务治理能力
Dubbo3.3.4高性能 RPC 框架，用于服务间通信
Nacos2024.0.1注册中心 & 实现服务注册、发现

1.2. 项目总览

1.2.1. 项目总体架构图

1
2
3
4
5
6
7
8
spring-boot-demo (父工程)
├── common
│   ├── common_generator：自动生成 Dubbo 接口与实现类的maven插件
└── user-service
    └── oem
        ├── provider：Dubbo 服务提供者，暴露业务接口和服务逻辑
        ├── api：Dubbo 服务接口定义
        └── consumer：Dubbo 服务消费者，调用远程服务并对外暴露 REST API

1.2.2. 主要模块功能描述

  • common_generator

    • 使用 Java 注解处理器（APT） + JavaPoet 自动生成 Dubbo 接口和实现类。
    • 支持通过 @AutoDubboService 注解自动创建接口和服务实现。

  • provider

    • Dubbo 服务提供者，定义并实现业务逻辑（如 HelloService）。
    • 启动类 Application.java 使用 @EnableDubbo 启用 Dubbo 功能。
    • 使用 Nacos 进行服务注册。

  • consumer

    • Dubbo 服务消费者，调用 provider 提供的服务。
    • 控制器 OpenController.java 对外暴露 REST 接口 /open/hello。
    • 通过 @DubboReference 引用远程服务。

3. 🧱每个 模块 说明

父工程spring-boot-demo

说明：

  • 定义全局依赖版本管理。
  • 所有子模块继承该 pom.xml，避免重复定义版本号。
  • 📦 Maven 依赖配置 spring-boot-demo/pom.xml
    • 定义全局属性如 Java 版本、Spring Boot / Cloud 版本。
    • 使用 <dependencyManagement> 统一管理所有依赖的版本。
    • 配置 Maven 插件如 maven-compiler-plugin 和 spring-boot-maven-plugin。
1
2
3
4
5
6
7
8
9
10
11

<properties>
    <java.version>21</java.version>
    <spring-cloud.version>2024.0.1</spring-cloud.version>
    <spring-cloud-alibaba.version>2023.0.3.2</spring-cloud-alibaba.version>
    <dubbo.version>3.3.4</dubbo.version>
</properties>

<dependencyManagement>
<!-- 统一管理 Spring Boot、Spring Cloud、Dubbo、MySQL、HikariCP 等依赖版本 -->
</dependencyManagement>

✅ 角色：功能（common_generator）common/common_generator 模块

🔧说明：

  • 使用 JavaParser 生成 Java 代码。
  • 编译时会根据 @AutoDubboService 注解自动生成接口和实现类。

1.2.2.1. 📁目录结构：

1
2
3
4
5
6
7
8
9
10
11
common_generator/
├── src/
│   └── main/
│       └── java/
│           └── top/
│               └── cjf_rb/
│                   └── aut_interface/
│                       ├── annotation/            # 注解定义
│                       │   └── AutoDubboService.java
│                       └── DubboGeneratorMojo.java # 插件实现
├── pom.xml                                       # Maven caj文件

1.2.2.2. 📦 Maven 依赖配置 common/common_generator/pom.xml

-

  • 定义依赖：
    • 使用 JavaPoet 生成 Java 代码。
    • 使用 AutoService 实现注解处理器注册。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<dependencies>
    <!-- Maven Plugin API -->
    <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-plugin-api</artifactId>
        <version>${maven.plugin.api.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.maven.plugin-tools</groupId>
        <artifactId>maven-plugin-annotations</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-core</artifactId>
        <version>${maven.plugin.api.version}</version>
        <scope>provided</scope>
    </dependency>

    <!-- 新增: JavaParser 依赖 -->
    <dependency>
        <groupId>com.github.javaparser</groupId>
        <artifactId>javaparser-core</artifactId>
        <version>3.26.4</version>
    </dependency>

    <!-- 其他依赖保持不变 -->
    <dependency>
        <groupId>org.codehaus.plexus</groupId>
        <artifactId>plexus-utils</artifactId>
        <version>3.0.24</version>
    </dependency>
    <dependency>
        <groupId>org.reflections</groupId>
        <artifactId>reflections</artifactId>
        <version>0.10.2</version>
    </dependency>
</dependencies>

1.2.3. ✅ 角色：提供者（Provider）user-service/oem/provider 模块

1.2.3.1. 🔧说明：

  • 依赖 Dubbo Starter 和 Nacos Discovery。
  • 引入 common_generator 模块，支持自动生成接口。
  • 使用 build-helper-maven-plugin 添加生成源码路径。

📁目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
provider/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── top/
│   │   │       └── cjf_rb/
│   │   │           └── provider/
│   │   │               ├── Application.java      # 启动类
│   │   │               └── api/
│   │   │                   └── HelloServiceApi.java # 业务实现类（带 @AutoDubboService 注解）
│   │   ├── resources/
│   │   │   ├── application.yml                  # 主配置文件
│   │   │   └── application-local.yml            # 本地环境配置文件
│   └── target/
│       └── generated-sources/
│           └── annotations/
│               └── top/
│                   └── cjf_rb/
│                       └── provider/
│                           └── api/
│                               ├── service/
│                               │   └── HelloService.java  # 自动生成的接口
│                               └── service/
│                                   └── impl/
│                                       └── HelloServiceImpl.java # 自动生成的实现类
├── pom.xml

📦 Maven 依赖配置 user-service/oem/provider/pom.xml

  • pom.xml
    • 引入 Dubbo、Nacos、Lombok、MyBatis、MySQL、HikariCP 等依赖。
    • 使用 build-helper-maven-plugin 添加生成源码路径，确保编译器识别自动生成的代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

<dependencies>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>top.cjf_rb</groupId>
        <artifactId>common_generator</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>
</dependencies>

<build>
<plugins>
    <!-- Spring Boot Maven Plugin -->
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <version>${spring-boot-starter.version}</version>
    </plugin>
    <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
        <version>3.6.0</version>
        <executions>
            <execution>
                <id>add-source</id>
                <phase>generate-sources</phase>
                <goals>
                    <goal>add-source</goal>
                </goals>
                <configuration>
                    <sources>
                        <source>${project.build.directory}/generated-sources/annotations</source>
                    </sources>
                </configuration>
            </execution>
        </executions>
    </plugin>
</plugins>
</build>

⚙️ provider/src/main/resources/application.yml

说明：

  • 应用名：provider
  • 注册到 Nacos 地址为 nacos://192.168.33.33
  • Dubbo 协议使用 dubbo://20880
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 2. 服务端口配置
server:
  port: 8080

spring:
  # 应用名称
  application:
    name: provider

  # 指定当前激活的 Spring Profile，默认为 local
  profiles:
    active: ${PROFILES_ACTIVE:local}

  # 数据库配置
  datasource:
    dynamic:
      primary: master   # 设置默认数据源
      datasource:
        master:
          url: jdbc:mysql://${DB_HOST:192.168.33.33}:${DB_PORT:3306}/master_db?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8
          username: ${DB_USERNAME}
          password: ${DB_PASSWORD}
          driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      # 最大连接池数量（根据数据库负载调整）
      maximum-pool-size: 10
      # 最小空闲连接数（保持一定数量的空闲连接，减少频繁创建销毁开销）
      minimum-idle: 5
      # 空闲连接超时时间（毫秒），超过该时间未使用的连接将被回收
      idle-timeout: 30000
      # 连接最大存活时间（毫秒），防止连接老化（建议略小于数据库 wait_timeout）
      max-lifetime: 1800000
      # 获取连接的最大等待时间（毫秒），用于控制数据库压力过大时的阻塞行为
      connection-timeout: 30000
      # 自定义连接池名称，方便在监控或日志中识别
      pool-name: MyHikariPool
      # 是否自动提交事务，默认 true，可根据业务需求设置为 false
      auto-commit: true
      # 验证连接是否有效的超时时间（毫秒），确保获取到的是可用连接
      validation-timeout: 5000
      # 连接泄漏检测阈值（毫秒），如果连接未在指定时间内释放，会记录警告日志
      leak-detection-threshold: 30000

  # Nacos 服务发现配置
  cloud:
    nacos:
      discovery:
        # Nacos Server 地址
        server-addr: 192.168.33.33
        namespace: ${NACOS_NAMESPACE:public}
        port: 8848
        username: ${NACOS_USERNAME:admin}
        password: ${NACOS_PASSWORD:admin}

dubbo:
  # Dubbo 注册中心配置
  registry:
    # 使用 Nacos 作为注册中心
    address: nacos://${NACOS_ADDR:192.168.33.33}
    port: 8848
    # 账号
    username: ${NACOS_USERNAME:admin}
    password: ${NACOS_PASSWORD:admin}
    # 配置 Nacos 注册中心参数
    parameters:
      # 设置服务注册模式为应用级（instance）而非接口级（service）
      register-mode: instance
    use-as-config-center: false
  consumer:
    check: false
  # Dubbo 协议及端口配置
  protocol:
    name: dubbo  # 使用 Dubbo 协议
    port: 20880  # Dubbo 服务监听端口

  #  # 使用 Dubbo 3.x 推荐的元数据服务配置方式
  metadata-report:
    # 元数据服务地址（Nacos）
    address: nacos://${NACOS_ADDR:192.168.33.33}
    port: 8848
    username: admin
    password: admin

logging:
  level:
    org.apache.dubbo.registry.configured: debug
    org.apache.dubbo.common.config.Environment: debug

2.1. 代码说明

2.1.1. provider/api/HelloService.java
1
2
3
4
5
6
7
@AutoDubboService(interfaceName = "HelloService")
@DubboService
public class HelloService {
    public String sayHello(String name) {
        return "Hello " + name;
    }
}
2.1.2. 说明：
  • 使用 @AutoDubboService 注解，编译期自动生成接口 HelloService 和实现类 HelloServiceImpl。
  • 使用 @DubboService 将服务发布为 Dubbo 服务。
provider/Application.java
1
2
3
4
5
6
7
@SpringBootApplication
@EnableDubbo
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

说明：

  • 启动类，启用 Dubbo 功能。
  • 自动扫描并注册 Dubbo 服务。

2.2. 核心文件说明：

  • Application.java
    • Spring Boot 启动类，使用 @EnableDubbo 启用 Dubbo 功能。
  • HelloServiceApi.java
    • 业务逻辑实现类，使用 @AutoDubboService 和 @DubboService 注解。
  • application.yml
    • 配置服务端口、应用名、Nacos 地址、数据库连接池等信息。
  • target/generated-sources/annotations/...
    • 编译时自动生成的接口和实现类：
      • HelloService（接口）
      • HelloServiceImpl（实现类，自动包装 HelloServiceApi）

✅ 角色：消费者（Consumer）user-service/oem/consumer 模块

🔧说明：

  • 引入 Dubbo 和 Nacos 依赖。
  • 引用本地的 provider 模块作为服务接口来源。

2.3. 目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
consumer/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── top/
│   │   │       └── cjf_rb/
│   │   │           └── oem/
│   │   │               ├── Application.java      # 启动类
│   │   │               └── controller/
│   │   │                   └── OpenController.java # 控制器，调用远程服务
│   │   ├── resources/
│   │   │   ├── application.yml                  # 主配置文件
│   │   │   └── application-local.yml            # 本地环境配置文件
├── pom.xml

2.4. 📦 Maven 依赖配置user-service/oem/consumer/pom.xml

  • pom.xml
    • 引入 Dubbo、Nacos、Lombok、Spring Web、Actuator 等依赖。
    • 依赖 provider 模块作为服务接口来源。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<dependencies>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>top.cjf_rb</groupId>
        <artifactId>provider</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>
</dependencies>

2.5. ⚙️ consumer/src/main/resources/application.yml

2.6. 说明：

  • 应用名：consumer
  • 注册到 Nacos，与其他服务进行通信。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# 服务端口配置
server:
  port: 8081

spring:
  # 应用名称
  application:
    name: consumer
  # 指定当前激活的 Spring Profile，默认为 local
  profiles:
    active: ${PROFILES_ACTIVE:local}
  # Nacos 服务发现配置
  cloud:
    nacos:
      discovery:
        # Nacos Server 地址
        server-addr: ${NACOS_ADDR:192.168.33.33}
        namespace: ${NACOS_NAMESPACE:public}
        port: 8848
        username: ${NACOS_USERNAME:admin}
        password: ${NACOS_PASSWORD:admin}


dubbo:
  # Dubbo 应用配置，使用 Spring 的应用名
  application:
    name: ${spring.application.name}
    qos-enable: false
  consumer:
    timeout: 3000
    retries: 2
    check: false
  # Dubbo 注册中心配置
  registry:
    # 使用 Nacos 作为注册中心
    address: nacos://${NACOS_ADDR:192.168.33.33}
    parameters:
      # 设置服务注册模式为应用级（instance）而非接口级（service）
      register-mode: instance
      register-consumer-url: true
      enable-empty-protection: true
    port: 8848
    username: ${NACOS_USERNAME:admin}
    password: ${NACOS_PASSWORD:admin}
    use-as-config-center: false
  #  # 使用 Dubbo 3.x 推荐的元数据服务配置方式
  metadata-report:
    # 元数据服务地址（Nacos）
    address: nacos://${NACOS_ADDR:192.168.33.33}
    port: 8848
    username: admin
    password: admin

logging:
  level:
    org.apache.dubbo.registry.configured: debug
    org.apache.dubbo.common.config.Environment: debug

代码说明

consumer/controller/OpenController.java
1
2
3
4
5
6
7
8
9
10
11
@RestController
@RequestMapping("/open")
public class OpenController {
    @DubboReference
    private final HelloService helloService;

    @RequestMapping("/hello")
    public String hello(@RequestParam("name") String name) {
        return helloService.sayHello7(name);
    }
}
说明：
  • 使用 @DubboReference 注入远程服务。
  • 提供 REST 接口 /open/hello，调用远程服务方法。
2.6.1. 核心文件说明：
  • Application.java
    • Spring Boot 启动类。
  • OpenController.java
    • REST 控制器，通过 @DubboReference 注入远程服务接口 HelloService。
    • 提供 /open/hello 接口，调用远程方法 sayHello7()。
  • application.yml
    • 配置服务端口、Nacos 地址、Dubbo 注册中心等信息。
  • pom.xml
    • 引入 Dubbo、Nacos、Lombok、Spring Web、Actuator 等依赖。
    • 依赖 provider 模块作为服务接口来源。

🌐 Nacos 注册中心配置

  • 地址：nacos://192.168.33.33
  • 端口：8848
  • 命名空间：public
  • 服务注册模式：instance（应用级注册） (其中特别说明应用级注册必须配置元数据服务，否则消费端无法找到服务提供者)
  • 元数据服务：使用 Nacos 存储元数据

🧪 启动与测试步骤

  1. 启动 Nacos Server

    1
    startup.cmd -m standalone

  2. 启动服务提供者 provider

    1
    mvn spring-boot:run

    访问 http://localhost:8080/actuator/health 查看健康状态

  3. 启动消费者 consumer

    1
    mvn spring-boot:run

    访问 http://localhost:8081/open/hello?name=test

  4. 验证 Dubbo 服务是否注册成功
    登录 Nacos 控制台查看服务列表：

    1
    http://192.168.33.33:8848/nacos

总结

📦 模块关系图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
consumer (调用者)
    ┌─────────────────────────┐
    │ OpenController.java     │
    │ @DubboReference         │
    │ HelloService.sayHello() │
    └─────────────────────────┘
            ↓
    ┌──────────────────────────┐
    │ Nacos Server             │
    │ 注册中心：记录服务地址       │
    └──────────────────────────┘
            ↓
    ┌──────────────────────────────┐
    │ provider                 │
    │ 提供服务                       │
    │ @DubboService                │
    │ HelloServiceApi              │
    └──────────────────────────────┘

本项目基于 Spring Boot + Spring Cloud Alibaba + Dubbo + Nacos 构建了完整的微服务架构，具备如下特点：

  • 模块化设计：各模块职责清晰，便于维护与扩展。
  • 服务自动注册与发现：通过 Nacos 实现服务注册与发现。
  • 高性能 RPC 调用：通过 Dubbo 实现高效的服务间通信。
  • 代码生成机制：利用注解处理器 + JavaPoet 自动生成 Dubbo 接口和服务实现类，提升开发效率。
  • 统一依赖管理：通过父工程统一管理版本，确保依赖一致性。

整体架构适用于中大型微服务系统，具有良好的可维护性和可扩展性。

项目已经成功整合了 Spring Boot、Spring Cloud Alibaba、Nacos 和 Dubbo，以下是详细的整合说明和关键配置点。

已完成以下集成：

功能已实现
Spring Boot 自动装配✅
Spring Cloud Alibaba 整合 Nacos✅
Dubbo 服务注册与发现✅
Dubbo 远程调用✅
多模块项目结构管理✅
数据源动态配置（Dynamic-Datasource）✅
日志调试级别设置✅
java框架
#java #spring-boot #spring-cloud #nacos #dubbo
Spring Boot + Spring Cloud + Dubbo + Nacos 分布式微服务项目整合
http://blog.cjf-rb.top/2025/06/04/spring-boot-spring-cloud-nacos-dubbo框架整合/
作者
cjf
发布于
2025年6月4日
许可协议