Spring Cloud微服务毕设架构实战：Nacos+Gateway+Feign让项目有“大厂味“，导师评分直接+10分（附完整源码结构+Docker部署脚本）

weixin_45183814

369人浏览 · 2026-05-11 16:47:03

weixin_45183814 · 2026-05-11 16:47:03 发布

⚠️ 声明：本文部分代码框架由开发工具辅助生成，核心架构设计与业务逻辑经人工审核调试，确保可运行。

一、前言：为什么你的单体项目，导师总问"有没有考虑分布式架构"？

去年帮学弟看答辩PPT，导师说了一句很典型的话：

“功能都实现了，但这就是一个普通的单体Web项目，如果用户量大了怎么办？有没有考虑过服务拆分？”

这句话点出了一个评分潜规则：2026年计算机毕设的技术架构评分，已经从"能跑通"升级为"有架构思维"。

但真实的微服务架构（K8s、Service Mesh、分布式事务）对本科生来说太重了。本文的思路是：用"轻量级微服务"做毕设——展示核心组件理解，不追求企业级完整度。

二、毕设微服务的"黄金拆分法则"：3个服务刚刚好

不要学阿里拆出几百个服务。本科毕设，能讲清楚3个服务的协作关系，已经胜过90%的同学。

2.1 "3+1"拆分模型

服务名	端口	职责	论文对应章节
`user-service`	9001	用户注册、登录、JWT鉴权、角色权限	系统用户模块设计
`biz-service`	9002	核心业务（订单/商品/预约/图书管理等）	核心业务模块设计
`base-service`	9003	文件上传、短信通知、字典数据、操作日志	系统公共模块设计
`gateway-service`	8080	路由转发、统一鉴权、跨域处理	系统网关设计

为什么不是"订单服务"“支付服务”"库存服务"分开？

因为毕设里不需要解决分布式事务（Seata），把订单和支付放在 biz-service 里，用本地事务 @Transactional 就能搞定。过度拆分 = 给自己挖坑。

三、技术选型与版本锁定（已验证兼容性）

别追最新版，选导师认识的、社区文档全的：

组件	版本	作用
Spring Boot	3.2.5	基础框架
Spring Cloud	2023.0.1	微服务规范
Spring Cloud Alibaba	2023.0.1.0	Nacos、Sentinel、Seata
Nacos	2.3.0	注册中心 + 配置中心
Gateway	4.x	API网关
OpenFeign	4.x	声明式服务调用
MySQL	8.0	数据持久化
Redis	7.x	缓存
Vue	3.4.x	前端框架

3.1 父工程 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.graduation</groupId>
    <artifactId>graduation-microservice</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    
    <modules>
        <module>gateway-service</module>
        <module>user-service</module>
        <module>biz-service</module>
        <module>base-service</module>
    </modules>
    
    <properties>
        <java.version>17</java.version>
        <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.2.5</spring-boot.version>
        <spring-cloud.version>2023.0.1</spring-cloud.version>
        <spring-cloud-alibaba.version>2023.0.1.0</spring-cloud-alibaba.version>
        <mybatis-plus.version>3.5.6</mybatis-plus.version>
    </properties>
    
    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            
            <!-- Spring Cloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            
            <!-- Spring Cloud Alibaba -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            
            <!-- MyBatis Plus -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <dependencies>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

3.2 子工程通用依赖（以 user-service 为例）

<dependencies>
    <!-- Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    
    <!-- Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    
    <!-- MyBatis Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
    
    <!-- MySQL -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- JWT -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.12.5</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.12.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.12.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

四、项目源码结构（可直接对照搭建）

graduation-microservice/
├── pom.xml                           # 父工程
├── docker-compose.yml                # 一键部署
├── sql/
│   └── init.sql                      # 数据库初始化
├── gateway-service/                  # 网关服务 (8080)
│   ├── pom.xml
│   └── src/main/java/com/gateway/
│       ├── GatewayApplication.java
│       └── filter/
│           └── JwtAuthFilter.java
├── user-service/                     # 用户服务 (9001)
│   ├── pom.xml
│   └── src/main/java/com/user/
│       ├── UserApplication.java
│       ├── controller/
│       ├── service/
│       ├── mapper/
│       └── entity/
├── biz-service/                      # 业务服务 (9002)
│   ├── pom.xml
│   └── src/main/java/com/biz/
│       ├── BizApplication.java
│       ├── controller/
│       ├── service/
│       ├── feign/                    # Feign客户端
│       │   └── UserFeignClient.java
│       ├── mapper/
│       └── entity/
└── base-service/                     # 基础服务 (9003)
    ├── pom.xml
    └── src/main/java/com/base/
        ├── BaseApplication.java
        └── controller/

五、Nacos 注册中心：微服务的"通讯录"

5.1 Docker 启动 Nacos（单机版，毕设够用）

# docker-compose.yml 片段
services:
  nacos:
    image: nacos/nacos-server:v2.3.0
    container_name: nacos
    ports:
      - "8848:8848"
    environment:
      - MODE=standalone
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=mysql
      - MYSQL_SERVICE_DB_NAME=nacos
      - MYSQL_SERVICE_PORT=3306
      - MYSQL_SERVICE_USER=root
      - MYSQL_SERVICE_PASSWORD=root
      - JVM_XMS=256m
      - JVM_XMX=512m
    depends_on:
      - mysql

💡 内存优化：毕设演示机配置一般，设置 JVM_XMS=256m 和 JVM_XMX=512m 防止Nacos吃光内存。

5.2 服务注册配置

每个服务的 bootstrap.yml（注意不是 application.yml，Nacos配置中心需要提前加载）：

spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev
        group: DEFAULT_GROUP
      config:
        server-addr: 127.0.0.1:8848
        namespace: dev
        group: DEFAULT_GROUP
        file-extension: yaml
        refresh-enabled: true
server:
  port: 9001

启动后访问 http://localhost:8848/nacos，账号密码都是 nacos，进入"服务管理"→"服务列表"，看到4个服务全部注册上，截图贴进论文。

六、Gateway 网关：统一入口 + JWT 鉴权

6.1 路由配置

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1
            
        - id: biz-service
          uri: lb://biz-service
          predicates:
            - Path=/api/biz/**
          filters:
            - StripPrefix=1
            
        - id: base-service
          uri: lb://base-service
          predicates:
            - Path=/api/base/**
          filters:
            - StripPrefix=1
            
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "*"
            allowedMethods:
              - GET
              - POST
              - PUT
              - DELETE
              - OPTIONS
            allowedHeaders: "*"
            allowCredentials: false
            maxAge: 3600

6.2 JWT 全局过滤器（核心代码）

@Component
@Slf4j
public class JwtAuthFilter implements GlobalFilter, Ordered {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getURI().getPath();
        
        // 白名单放行
        if (isWhiteList(path)) {
            return chain.filter(exchange);
        }
        
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        
        if (token == null || !token.startsWith("Bearer ")) {
            return unauthorized(exchange);
        }
        
        token = token.substring(7);
        try {
            Claims claims = Jwts.parser()
                .verifyWith(Keys.hmacShaKeyFor("YourSecretKeyYourSecretKeyYourSecretKey".getBytes()))
                .build()
                .parseSignedClaims(token)
                .getPayload();
            
            // 把用户信息传给下游服务
            ServerHttpRequest mutatedRequest = exchange.getRequest().mutate()
                .header("X-User-Id", claims.getSubject())
                .header("X-User-Role", claims.get("role", String.class))
                .build();
            
            return chain.filter(exchange.mutate().request(mutatedRequest).build());
            
        } catch (Exception e) {
            log.error("JWT验证失败: {}", e.getMessage());
            return unauthorized(exchange);
        }
    }
    
    private boolean isWhiteList(String path) {
        return path.contains("/login") 
            || path.contains("/register") 
            || path.contains("/public");
    }
    
    private Mono<Void> unauthorized(ServerWebExchange exchange) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        String body = "{\"code\":401,\"message\":\"未授权或token已过期\"}";
        DataBuffer buffer = response.bufferFactory().wrap(body.getBytes());
        return response.writeWith(Mono.just(buffer));
    }
    
    @Override
    public int getOrder() {
        return -100; // 最高优先级
    }
}

答辩话术：

“Gateway作为系统唯一入口，承担路由转发和统一鉴权职责。我实现了JWT全局过滤器，对登录注册以外的请求进行Token校验，并将解析后的用户信息通过Header传递给下游服务，避免了每个微服务重复实现鉴权逻辑。”

七、OpenFeign：服务间调用像调本地方法

7.1 Feign 客户端定义（biz-service 调用 user-service）

@FeignClient(
    name = "user-service", 
    path = "/user",
    configuration = FeignConfig.class,
    fallbackFactory = UserFeignClientFallbackFactory.class
)
public interface UserFeignClient {
    
    @GetMapping("/{id}")
    UserDTO getUserById(@PathVariable("id") Long id);
    
    @GetMapping("/batch")
    List<UserDTO> getUserBatch(@RequestParam("ids") List<Long> ids);
}

7.2 Feign 配置（连接池优化）

@Configuration
public class FeignConfig {
    
    @Bean
    public Request.Options options() {
        return new Request.Options(10, TimeUnit.SECONDS, 60, TimeUnit.SECONDS, true);
    }
    
    @Bean
    public Retryer retryer() {
        return new Retryer.Default(1000, 3000, 3);
    }
}

7.3 业务层使用示例

@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    
    private final UserFeignClient userFeignClient;
    
    @Override
    public OrderVO getOrderDetail(Long orderId) {
        Order order = this.getById(orderId);
        if (order == null) {
            throw new BusinessException("订单不存在");
        }
        
        // Feign自动处理HTTP请求、负载均衡、服务发现
        UserDTO user = userFeignClient.getUserById(order.getUserId());
        
        OrderVO vo = new OrderVO();
        BeanUtils.copyProperties(order, vo);
        vo.setUserName(user.getUserName());
        vo.setUserPhone(user.getPhone());
        return vo;
    }
}

八、数据库设计：单库 + 表前缀隔离

不要搞分库，一个MySQL实例，用前缀区分归属：

-- 用户域表
CREATE TABLE sys_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(100) NOT NULL,
    email VARCHAR(100),
    phone VARCHAR(20),
    role VARCHAR(20) DEFAULT 'USER',
    status TINYINT DEFAULT 1,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 业务域表（以二手交易平台为例）
CREATE TABLE biz_product (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    title VARCHAR(200) NOT NULL,
    description TEXT,
    price DECIMAL(10,2) NOT NULL,
    category_id INT,
    status TINYINT DEFAULT 1 COMMENT '1上架 2下架 3已售',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_user_id (user_id),
    INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE biz_order (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    product_id BIGINT NOT NULL,
    buyer_id BIGINT NOT NULL,
    seller_id BIGINT NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    status TINYINT DEFAULT 0 COMMENT '0待支付 1已支付 2已发货 3已完成',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_buyer (buyer_id),
    INDEX idx_seller (seller_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 基础域表
CREATE TABLE base_file (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    file_name VARCHAR(255),
    file_url VARCHAR(500),
    file_type VARCHAR(50),
    file_size BIGINT,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

论文写法：

“本系统采用单数据库实例 + 逻辑表前缀隔离策略。用户域表以 sys_ 为前缀，业务域表以 biz_ 为前缀，基础域表以 base_ 为前缀。该策略在保证数据归属清晰的同时，避免了分布式事务的复杂性，为未来物理分库预留了扩展空间。”

九、前端 Vue3 对接：只认 Gateway 一个地址

// .env.development
VITE_API_BASE_URL = 'http://localhost:8080/api'

// utils/request.js
import axios from 'axios'

const service = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL,
  timeout: 15000
})

// 请求拦截器：带上JWT
service.interceptors.request.use(config => {
  const token = localStorage.getItem('token')
  if (token) {
    config.headers.Authorization = `Bearer ${token}`
  }
  return config
})

// 响应拦截器：统一错误处理
service.interceptors.response.use(
  response => response.data,
  error => {
    if (error.response?.status === 401) {
      localStorage.removeItem('token')
      window.location.href = '/login'
    }
    return Promise.reject(error)
  }
)

export default service

// API 调用示例
export const login = (data) => service.post('/user/login', data)
export const getProductList = (params) => service.get('/biz/product/list', { params })
export const uploadFile = (data) => service.post('/base/upload', data)

十、Docker Compose 一键部署（答辩救急版）

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    container_name: graduation-mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: graduation_db
    ports:
      - "3306:3306"
    volumes:
      - ./sql/init.sql:/docker-entrypoint-initdb.d/init.sql
      - mysql_data:/var/lib/mysql
    command: --default-authentication-plugin=mysql_native_password

  redis:
    image: redis:7-alpine
    container_name: graduation-redis
    ports:
      - "6379:6379"

  nacos:
    image: nacos/nacos-server:v2.3.0
    container_name: graduation-nacos
    environment:
      - MODE=standalone
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=mysql
      - MYSQL_SERVICE_DB_NAME=nacos
      - MYSQL_SERVICE_PORT=3306
      - MYSQL_SERVICE_USER=root
      - MYSQL_SERVICE_PASSWORD=root
      - JVM_XMS=256m
      - JVM_XMX=512m
    ports:
      - "8848:8848"
    depends_on:
      - mysql

  user-service:
    build: ./user-service
    container_name: graduation-user
    ports:
      - "9001:9001"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
    depends_on:
      - nacos
      - mysql

  biz-service:
    build: ./biz-service
    container_name: graduation-biz
    ports:
      - "9002:9002"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
    depends_on:
      - nacos
      - mysql

  base-service:
    build: ./base-service
    container_name: graduation-base
    ports:
      - "9003:9003"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
    depends_on:
      - nacos
      - mysql

  gateway:
    build: ./gateway-service
    container_name: graduation-gateway
    ports:
      - "8080:8080"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
    depends_on:
      - nacos
      - user-service
      - biz-service
      - base-service

volumes:
  mysql_data:

启动命令：

# 构建并启动所有服务
docker-compose up -d --build

# 查看健康状态
docker-compose ps

# 查看Nacos注册列表（确认4个服务都上线了）
curl http://localhost:8848/nacos/v1/ns/instance/list?serviceName=user-service

十一、论文"微服务架构设计"章节模板（直接复制改）

11.1 架构选型对比表

架构模式	开发效率	维护成本	扩展能力	技术复杂度	本系统适配性
单体架构	高	中	低	低	⭐⭐⭐
SOA架构	中	中	中	高	⭐⭐
微服务架构	中	高	高	中	⭐⭐⭐⭐⭐

论述模板：“单体架构适用于小型项目，但随着业务模块增加，代码耦合度上升，不利于独立迭代。微服务架构通过服务拆分，实现了业务边界清晰、技术栈灵活、独立部署等优势，符合现代软件工程的发展趋势。”

11.2 服务拆分理论支撑

“本系统基于领域驱动设计（DDD）中的限界上下文（Bounded Context）理论进行服务划分。将系统划分为用户域、业务域和基础域三个限界上下文，每个上下文对应一个独立部署单元，上下文之间通过API网关进行通信，保证了领域边界的清晰性。”

11.3 核心组件技术说明

组件	技术作用	本系统应用场景
Nacos	服务注册与发现、配置中心	管理4个微服务实例的动态注册与健康检查
Gateway	API网关	统一系统入口，实现路由转发、JWT鉴权、跨域处理
OpenFeign	声明式HTTP客户端	简化biz-service与user-service之间的服务调用
Ribbon	客户端负载均衡	当服务多实例部署时，自动分配请求（预留扩展）

十二、10个毕设微服务翻车点与急救方案

序号	翻车现象	根因	急救方案
1	Nacos启动报错，提示数据库连接失败	Nacos需要MySQL作为外部存储	检查docker-compose中`MYSQL_SERVICE_HOST`是否为`mysql`（容器名）
2	Feign调用返回404	路径不匹配	检查`@FeignClient(path="")`与服务端`@RequestMapping`是否一致
3	Gateway路由不生效	StripPrefix过滤后路径错误	前端请求`/api/user/login`，StripPrefix(1)后变成`/user/login`，确保Controller映射正确
4	JWT token传递到下游服务丢失	Gateway未把token写入Header	在Gateway过滤器中`mutate().header("Authorization", token)`
5	服务循环依赖	A调B，B调A	毕设中避免双向调用，需要用户信息时在biz表冗余字段
6	端口冲突，服务起不来	本地已有其他项目占用端口	统一规划：Gateway 8080，Nacos 8848，服务 9001/9002/9003
7	docker-compose启动顺序错误	服务比Nacos先启动	使用`depends_on`，但注意：docker-compose只保证启动顺序，不保证就绪，建议加健康检查或重试机制
8	前端跨域报错	浏览器拦截	在Gateway配置`globalcors`，不要在前端配代理
9	MySQL 8.0连接报错	驱动版本或认证插件问题	连接串加`?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true`
10	答辩时Nacos页面打不开	导师质疑服务是否真注册了	提前在Nacos控制台截图"服务列表"页面，放入PPT作为证据

十三、效率工具推荐：从"手敲两周"到"生成骨架+二开两天"

读到这里，你应该发现了：微服务毕设最大的时间黑洞不是业务代码，而是框架搭建。

Nacos配置、Gateway路由、Feign客户端、Docker Compose编排、跨服务鉴权传递……这些"基建"工作，手敲+调试至少需要 10-15天。而你的业务逻辑（商品管理、订单流程）可能只需要3天。

如果你时间紧迫（比如只剩2周），或者想先把骨架跑起来再慢慢填业务，推荐一个我最近在用的工具：

智码方舟（官网：https://thesis.polars.cc/）

它支持 Spring Cloud Alibaba 微服务架构的一键生成。输入你的毕设题目（比如"基于微服务架构的校园二手书交易平台"），选择技术栈：

后端：Spring Cloud + Nacos + Gateway + Feign + MyBatis Plus
前端：Vue 3 + Element Plus
数据库：MySQL 8.0

生成物包含：

✅ 完整的4服务模块源码（user-service / biz-service / base-service / gateway-service）
✅ 已配置好的 Nacos 注册中心 + Gateway 动态路由 + Feign 声明式调用
✅ 可直接运行的 docker-compose.yml 一键部署脚本（含MySQL、Redis、Nacos）
✅ 数据库设计文档 + 可直接导入的 SQL 初始化脚本
✅ 论文初稿（含"微服务架构设计"章节、技术选型表、架构图描述）

你拿到后只需要做两件事：