SpringBoot集成Dubbo企业级实战教程

1. 开发环境准备

你需要先确保本地开发环境符合企业级标准配置要求，这是hep-前缀标准化Dubbo项目搭建的基础：

• IDE：IntelliJ IDEA 2023 Ultimate 版
• JDK：17(SpringBoot3.x 强制要求JDK17及以上)
• Maven：3.9.4
• SpringBoot：3.5.10
• Dubbo：3.3.0(适配SpringBoot3.5.10的最新兼容版本)
• 注册中心：Nacos 2.3.2(企业级主流注册中心，适配JDK17)

Nacos安装

Dubbo依赖注册中心管理服务地址，企业级项目首选Nacos，Rocky Linux 10环境安装步骤如下：

cd /usr/software
# 去这个https://github.com/alibaba/nacos/releases/tag/2.3.2下载
tar -xvf nacos-server-2.3.2.tar.gz
cd nacos/bin

./startup.sh

vim /etc/systemd/system/hep-nacos.service

# 内容如下
[Unit]
Description=Nacos Server (hep-nacos)
After=network.target network-online.target
Wants=network-online.target

[Service]
# 改回forking(Nacos启动脚本是fork模式)
Type=forking
# 强制指定JDK和语言环境(避免编码/权限问题)
Environment="JAVA_HOME=/usr/local/java/jdk-17.0.18+8"
Environment="LANG=en_US.UTF-8"
# 正确的启动命令(仅保留-m standalone)
ExecStart=/usr/software/nacos/bin/startup.sh -m standalone
ExecStop=/usr/software/nacos/bin/shutdown.sh
# 增加超时等待(给足Nacos启动时间)
TimeoutStartSec=60
# 重启策略
Restart=on-failure
RestartSec=5s
User=root
Group=root
LimitNOFILE=65535
# 关键：关闭systemd对stdout的捕获(彻底解决209错误)
StandardOutput=journal+console
StandardError=journal+console

[Install]
WantedBy=multi-user.target

# 先停止失败的服务
systemctl stop hep-nacos

# 启动服务
systemctl start hep-nacos

# 查看状态
systemctl status hep-nacos

firewall-cmd --add-port=8848/tcp --permanent
firewall-cmd --add-port=9848/tcp --permanent
firewall-cmd --reload

#访问`http://192.168.31.116:8848/nacos`，默认账号/密码：nacos/nacos

2. 项目架构设计

为避免单模块项目的耦合问题，采用企业级标准多模块Maven架构，并统一使用hep-前缀规范命名，结构如下：

• SprinBoot-Dubbo(父工程)：统一管理依赖版本、全局构建配置，所有子模块继承此父工程
• hep-dubbo-api(公共API模块)：定义服务接口、通用实体类，供提供者/消费者共享，带hep-前缀标识归属
• hep-dubbo-provider(服务提供者)：实现API接口，暴露Dubbo远程服务，标准化命名便于运维识别
• hep-dubbo-consumer(服务消费者)：引用API模块，调用Dubbo远程服务，统一前缀提升项目辨识度

3. 创建父工程(SprinBoot-Dubbo)

3.1 IDEA创建父工程

3.2 配置父工程pom.xml

父工程核心作用是统一依赖版本、全局跳过test测试，且子模块声明全部替换为hep-前缀，配置如下：

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

    <!-- 父工程基本信息(统一hep-前缀) -->
    <groupId>cc.hep</groupId>
    <artifactId>SprinBoot-Dubbo</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    <name>SprinBoot-Dubbo</name>
    <description>hep前缀标准化 - SpringBoot集成Dubbo企业级实战项目</description>

    <!-- 子模块声明(全部替换为hep-前缀) -->
    <modules>
        <module>hep-dubbo-api</module>
        <module>hep-dubbo-provider</module>
        <module>hep-dubbo-consumer</module>
    </modules>

    <!-- 统一版本管理 -->
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-boot.version>3.5.10</spring-boot.version>
        <dubbo.version>3.3.0</dubbo.version>
        <nacos-client.version>2.3.2</nacos-client.version>
        <lombok.version>1.18.30</lombok.version>
        <jackson.version>2.15.2</jackson.version>
    </properties>

    <!-- 依赖管理：仅声明版本，不实际引入 -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot父依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Dubbo SpringBoot Starter -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
            </dependency>

            <!-- Dubbo Nacos注册中心适配 -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-registry-nacos</artifactId>
                <version>${dubbo.version}</version>
            </dependency>

            <!-- Nacos Client -->
            <dependency>
                <groupId>com.alibaba.nacos</groupId>
                <artifactId>nacos-client</artifactId>
                <version>${nacos-client.version}</version>
            </dependency>

            <!-- Lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>

            <!-- Jackson JSON序列化 -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 全局构建配置：跳过test测试 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.2.5</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- SpringBoot打包插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

关键说明：

• <packaging>pom</packaging>：标识为Maven父工程
• maven-surefire-plugin的skipTests=true：全局跳过test模块测试
• <dependencyManagement>：统一管理所有hep-前缀子模块的依赖版本，避免版本冲突
• 新增版本变量统一管理(如lombok.version)，提升维护性

4. 创建公共API模块

hep-dubbo-api模块是提供者和消费者的通信桥梁，仅定义接口/实体，不包含业务实现，企业级项目中需单独抽离并添加hep-前缀规范命名。

4.1 创建子模块

1. 右键父工程SprinBoot-Dubbo -> New -> Module
2. 选择Maven，点击Next
3. 填写信息(带hep-前缀)：
   • Name：hep-dubbo-api
   • GroupId：cc.hep
   • ArtifactId：hep-dubbo-api
   • Version：1.0.0
4. 点击Finish

4.2 配置pom.xml

hep-dubbo-api的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">
    <parent>
        <groupId>cc.hep</groupId>
        <artifactId>SprinBoot-Dubbo</artifactId>
        <version>1.0.0</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>hep-dubbo-api</artifactId>
    <name>hep-dubbo-api</name>
    <description>hep前缀标准化 - Dubbo公共API模块</description>

    <dependencies>
        <!-- Lombok：简化实体类代码 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- JSON序列化依赖(Dubbo远程调用必备) -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>
</project>

4.3 编写公共接口和实体类

实体类(HepUser)

为统一hep-前缀规范，实体类命名添加Hep标识，创建包路径cc.hep.api.entity，新建HepUser.java：

package cc.hep.api.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * hep前缀标准化 - 用户实体类
 * 注意：Dubbo远程调用的实体类必须实现Serializable接口(序列化)
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class HepUser implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long id;         // 用户ID
    private String username; // 用户名
    private String phone;    // 手机号
}

核心要点：

• 实体类命名添加Hep前缀，与项目整体命名规范保持一致
• 必须实现Serializable接口，否则Dubbo远程调用会抛出序列化异常

服务接口(HepUserService)

创建包路径cc.hep.api.service，新建HepUserService.java：

package cc.hep.api.service;

import cc.hep.api.entity.HepUser;

/**
 * hep前缀标准化 - 用户服务接口(Dubbo远程服务)
 * 企业级开发中接口需清晰定义入参/返回值，避免复杂类型
 */
public interface HepUserService {

    /**
     * 根据ID查询用户
     * @param id 用户ID
     * @return 用户信息
     */
    HepUser getUserById(Long id);

    /**
     * 新增用户
     * @param user 用户信息
     * @return 新增是否成功
     */
    Boolean addUser(HepUser user);
}

5. 创建服务提供者模块

hep-dubbo-provider服务提供者负责实现API接口，并将服务暴露到Nacos注册中心，供消费者调用，命名统一为hep-dubbo-provider。

5.1 创建子模块

1. 右键父工程SprinBoot-Dubbo -> New -> Module
2. 选择Spring Initializr，点击Next
3. 填写信息(带hep-前缀)：
   • Name：hep-dubbo-provider
   • Group：cc.hep
   • Artifact：hep-dubbo-provider
   • Package name：cc.hep
   • Java Version：17
   • Spring Boot Version：3.5.10
4. 点击Next(无需选择依赖)，点击Finish

5.2 配置pom.xml

hep-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">
    <parent>
        <groupId>cc.hep</groupId>
        <artifactId>SprinBoot-Dubbo</artifactId>
        <version>1.0.0</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>hep-dubbo-provider</artifactId>
    <name>hep-dubbo-provider</name>
    <description>hep前缀标准化 - Dubbo服务提供者模块</description>

    <dependencies>
        <!-- SpringBoot核心依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- 公共API模块依赖(hep-前缀) -->
        <dependency>
            <groupId>cc.hep</groupId>
            <artifactId>hep-dubbo-api</artifactId>
            <version>1.0.0</version>
        </dependency>

        <!-- Dubbo SpringBoot Starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>

        <!-- Dubbo Nacos注册中心 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-nacos</artifactId>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>cc.hep.HepDubboProviderApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

5.3 编写SpringBoot启动类

启动类命名添加Hep前缀，创建包路径cc.hep，新建HepDubboProviderApplication.java：

package cc.hep;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * hep前缀标准化 - Dubbo服务提供者启动类
 * @EnableDubbo：开启Dubbo自动配置，扫描@DubboService注解
 */
@SpringBootApplication
@EnableDubbo
public class HepDubboProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(HepDubboProviderApplication.class, args);
        System.out.println("hep-dubbo-provider 服务提供者启动成功 ✨");
    }
}

核心要点：

• 启动类命名添加Hep前缀，符合项目整体命名规范
• @EnableDubbo是Dubbo与SpringBoot整合的核心注解，必须添加

5.4 编写服务实现类

创建包路径cc.hep.provider.service.impl，新建HepUserServiceImpl.java：

package cc.hep.provider.service.impl;

import cc.hep.api.entity.HepUser;
import cc.hep.api.service.HepUserService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * hep前缀标准化 - 用户服务实现类(Dubbo服务提供者)
 * @DubboService：暴露Dubbo服务，version用于版本管理(企业级必备)
 */
@DubboService(version = "1.0.0")
@Component
public class HepUserServiceImpl implements HepUserService {

    // 模拟数据库存储
    private static final Map<Long, HepUser> HEP_USER_MAP = new HashMap<>();

    // 初始化模拟数据
    static {
        HEP_USER_MAP.put(1L, new HepUser(1L, "张三", "13800138000"));
        HEP_USER_MAP.put(2L, new HepUser(2L, "李四", "13900139000"));
    }

    @Override
    public HepUser getUserById(Long id) {
        // 企业级开发中此处替换为MyBatis/MyBatis-Plus操作数据库
        return HEP_USER_MAP.get(id);
    }

    @Override
    public Boolean addUser(HepUser user) {
        if (user == null || user.getId() == null) {
            return false;
        }
        HEP_USER_MAP.put(user.getId(), user);
        return true;
    }
}

核心要点：

• 实现类命名添加Hep前缀，变量名(HEP_USER_MAP)也添加前缀，保持规范统一
• @DubboService(version = "1.0.0")：标记为Dubbo服务，version用于灰度发布/版本兼容
• 实际项目中需添加参数校验、异常处理、日志记录

5.5 配置Dubbo

在src/main/resources下新建application.yml，所有服务名替换为hep-前缀：

# SpringBoot基础配置(hep-前缀)
spring:
  application:
    name: hep-dubbo-provider

# Dubbo核心配置
dubbo:
  application:
    name: hep-dubbo-provider
    owner: hep # 服务负责人(企业级运维必备，与项目前缀一致)
  registry:
    address: nacos://192.168.31.116:8848 # Nacos地址
    username: nacos
    password: nacos
    timeout: 5000 # 注册中心连接超时
  protocol:
    name: dubbo # Dubbo默认协议
    port: 20880 # 服务端口(冲突可修改为20881/20882)
  scan:
    base-packages: cc.hep.provider.service.impl # 扫描Dubbo服务实现类
  provider:
    timeout: 3000 # 服务调用超时
    retries: 1 # 失败重试次数(注意幂等性)
    loadbalance: random # 负载均衡策略

6. 创建服务消费者模块

hep-dubbo-consumer服务消费者通过Nacos发现提供者服务，调用远程接口，命名统一为hep-dubbo-consumer。

6.1 创建子模块

1. 右键父工程SprinBoot-Dubbo -> New -> Module
2. 选择Spring Initializr，点击Next
3. 填写信息(带hep-前缀)：
   • Name：hep-dubbo-consumer
   • Group：cc.hep
   • Artifact：hep-dubbo-consumer
   • Package name：cc.hep
   • Java Version：17
   • Spring Boot Version：3.5.10
4. 点击Next，选择Spring Web依赖(用于HTTP接口测试)，点击Finish

6.2 配置pom.xml

hep-dubbo-consumer的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">
    <parent>
        <groupId>cc.hep</groupId>
        <artifactId>SprinBoot-Dubbo</artifactId>
        <version>1.0.0</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>hep-dubbo-consumer</artifactId>
    <name>hep-dubbo-consumer</name>
    <description>hep前缀标准化 - Dubbo服务消费者模块</description>

    <dependencies>
        <!-- SpringBoot Web依赖(HTTP接口测试) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 公共API模块依赖(hep-前缀) -->
        <dependency>
            <groupId>cc.hep</groupId>
            <artifactId>hep-dubbo-api</artifactId>
            <version>1.0.0</version>
        </dependency>

        <!-- Dubbo SpringBoot Starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>

        <!-- Dubbo Nacos注册中心 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-nacos</artifactId>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>cc.hep.HepDubboConsumerApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

6.3 编写SpringBoot启动类

启动类命名添加Hep前缀，创建包路径cc.hep，新建HepDubboConsumerApplication.java：

package cc.hep;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * hep前缀标准化 - Dubbo服务消费者启动类
 * @EnableDubbo：扫描@DubboReference注解，注入远程服务
 */
@SpringBootApplication
@EnableDubbo
public class HepDubboConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(HepDubboConsumerApplication.class, args);
        System.out.println("hep-dubbo-consumer 服务消费者启动成功 ✨");
    }
}

6.4 编写消费端业务类和Controller

业务服务类

创建包路径cc.hep.consumer.service，新建HepUserConsumerService.java：

package cc.hep.consumer.service;

import cc.hep.api.entity.HepUser;
import cc.hep.api.service.HepUserService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.stereotype.Service;

/**
 * hep前缀标准化 - 消费端业务类
 * @DubboReference：注入远程Dubbo服务，version需与提供者一致
 */
@Service
public class HepUserConsumerService {

    @DubboReference(version = "1.0.0", timeout = 3000)
    private HepUserService hepUserService;

    /**
     * 调用远程服务查询用户
     */
    public HepUser getUserById(Long id) {
        return hepUserService.getUserById(id);
    }

    /**
     * 调用远程服务新增用户
     */
    public Boolean addUser(HepUser user) {
        return hepUserService.addUser(user);
    }
}

核心要点：

• 类名和变量名均添加Hep前缀，符合命名规范
• @DubboReference的version必须和提供者@DubboService的version一致

控制器

创建包路径cc.hep.consumer.controller，新建HepUserController.java：

package cc.hep.consumer.controller;

import cc.hep.api.entity.HepUser;
import cc.hep.consumer.service.HepUserConsumerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * hep前缀标准化 - HTTP接口控制器，测试Dubbo服务调用
 */
@RestController
@RequestMapping("/hep/user")
public class HepUserController {

    @Autowired
    private HepUserConsumerService hepUserConsumerService;

    /**
     * 查询用户接口(hep前缀路径)
     * 请求示例：http://localhost:8080/hep/user/1
     */
    @GetMapping("/{id}")
    public HepUser getUserById(@PathVariable Long id) {
        return hepUserConsumerService.getUserById(id);
    }

    /**
     * 新增用户接口(hep前缀路径)
     * 请求示例：POST http://localhost:8080/hep/user
     * Body：{"id":3,"username":"王五","phone":"13700137000"}
     */
    @PostMapping
    public Boolean addUser(@RequestBody HepUser user) {
        return hepUserConsumerService.addUser(user);
    }
}

核心要点：

• 控制器命名添加Hep前缀，请求路径也添加/hep前缀，统一规范
• 入参和返回值均使用HepUser实体类，与API模块保持一致

6.5 配置Dubbo

在src/main/resources下新建application.yml，服务名替换为hep-前缀：

# SpringBoot基础配置(hep-前缀)
spring:
  application:
    name: hep-dubbo-consumer

# 服务器配置
server:
  port: 8080 # HTTP端口

# Dubbo核心配置
dubbo:
  application:
    name: hep-dubbo-consumer
  registry:
    address: nacos://192.168.31.116:8848
    username: nacos
    password: nacos
  consumer:
    timeout: 3000 # 全局调用超时
    retries: 0 # 关闭自动重试(避免幂等问题)
    check: false # 启动时不检查服务是否存在(企业级常用)

核心要点：

• spring.application.name和dubbo.application.name均改为hep-dubbo-consumer
• consumer.check: false避免消费者因提供者未启动而启动失败

7. 启动和测试

7.1 启动顺序

1. 启动Nacos：执行startup.cmd -m standalone
2. 启动Dubbo提供者：运行HepDubboProviderApplication的main方法
3. 启动Dubbo消费者：运行HepDubboConsumerApplication的main方法

7.2 验证服务注册

访问Nacos控制台http://192.168.31.116:8848/nacos，进入服务管理 -> 服务列表，可看到hep-dubbo-provider已注册且状态健康(服务名已替换为hep前缀)。

7.3 接口测试

7.3.1 查询用户

访问http://localhost:8080/hep/user/1，返回结果：

{
  "id": 1,
  "username": "张三",
  "phone": "13800138000"
}

7.3.2 新增用户

发送POST请求http://localhost:8080/hep/user，请求体：

{
  "id": 3,
  "username": "王五",
  "phone": "13700137000"
}

返回true，再次访问http://localhost:8080/hep/user/3可查询到新增用户。

8. 企业级优化配置

8.1 日志配置(logback-spring.xml)

在提供者/消费者的src/main/resources下添加日志配置，日志路径和名称添加hep-前缀：

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"/>
    <property name="LOG_PATH" value="./logs/hep-dubbo"/> <!-- hep前缀日志目录 -->

    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- 文件输出(按天分割，hep前缀) -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/hep-dubbo.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/hep-dubbo.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <logger name="org.apache.dubbo" level="INFO"/>
    <logger name="cc.hep" level="INFO"/> <!-- hep包路径日志级别 -->

    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
</configuration>

8.2 全局异常处理

在消费者添加全局异常处理器，统一返回格式，类名添加Hep前缀：

package cc.hep.consumer.exception;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

/**
 * hep前缀标准化 - 全局异常处理器
 */
@RestControllerAdvice
public class HepGlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public Map<String, Object> handleException(Exception e) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 500);
        result.put("msg", "hep-dubbo-consumer 服务调用失败：" + e.getMessage());
        result.put("data", null);
        return result;
    }
}

8.3 服务监控

部署Dubbo Admin监控hep-前缀服务状态：

1. 下载：https://github.com/apache/dubbo-admin
2. 修改application.yml中的Nacos地址，确保能连接到本地Nacos
3. 打包运行：mvn clean package -DskipTests
4. 访问http://localhost:8080，可查看hep-dubbo-provider和hep-dubbo-consumer的服务调用链路/成功率

---