基于 Spring Cloud Alibaba 的微服务毕设架构设计与云原生部署实践

一、为什么毕业设计需要"云原生架构思维"？

在2026年的计算机专业毕设评审中，一个明显的趋势是：导师不再满足于"功能实现"，而是关注"架构设计"。

传统的 Spring Boot 单体应用虽然开发效率高，但在答辩环节常面临以下质疑：

• "如果用户量增长，单体能支撑吗？"
• "前后端分离了，但后端内部模块还是耦合在一起，有没有考虑过服务拆分？"
• "部署方式是什么？直接 java -jar 跑在服务器上？有没有容器化？"

这些问题背后，是评审标准对 "分布式架构思维" 和 "云原生实践能力" 的隐性要求。

但本科生面临的现实是：真实的微服务体系（Kubernetes、Service Mesh、GitOps）过于复杂，不适合在3个月内从零掌握并落地。

因此，本文的核心思路是：构建一套"轻量级微服务"毕设架构——使用 Spring Cloud Alibaba 核心组件完成服务治理，通过 Docker Compose 实现容器化部署，既展示分布式架构理解，又控制在毕设时间窗口内可完成。

二、架构总览：从单体到微服务的演进路径

2.1 单体架构的局限性

以一个典型的"校园二手交易平台"为例，单体架构下所有模块（用户、商品、订单、支付、文件）打包在一个 JAR 中：

┌─────────────────────────────────┐
│     Spring Boot 单体应用        │
│  ┌─────┐ ┌─────┐ ┌─────┐     │
│  │用户模块│ │商品模块│ │订单模块│ ... │
│  └─────┘ └─────┘ └─────┘     │
│        共享数据库               │
└─────────────────────────────────┘

问题：

• 任何模块代码变更都需要全量重新编译部署
• 某一模块内存泄漏会导致整个应用崩溃
• 技术栈单一，无法针对特定模块选择最优方案

2.2 微服务架构的毕设适配方案

本文采用 "3+1"服务拆分模型，将系统拆分为4个独立部署单元：

┌─────────────┐
│   Vue 3 前端  │
└──────┬──────┘
       │ HTTP
┌──────▼──────────────────────────────┐
│      Gateway 网关服务 (8080)       │
│  ├─ 路由：/api/user/** → user-service│
│  ├─ 路由：/api/biz/**  → biz-service │
│  ├─ 路由：/api/base/** → base-service│
│  └─ 全局：JWT鉴权、限流、跨域        │
└──────┬──────────────────────────────┘
       │
   ┌───┼───┐
   ▼   ▼   ▼
┌────┐┌────┐┌────┐
│user││biz ││base│
│svc ││svc ││svc │
│9001││9002││9003│
└──┬─┘└─┬──┘└─┬──┘
   └─────┼─────┘
         ▼
    ┌─────────┐
    │  Nacos  │
    │ 8848    │
    │ 注册中心 │
    └─────────┘
         │
    ┌────▼────┐
    │  MySQL  │
    │  3306   │
    └─────────┘

拆分原则：

• 按业务边界拆分：遵循领域驱动设计（DDD）中的限界上下文理论
• 避免过度拆分：订单与支付在毕设场景下合并为一个服务，避免引入分布式事务复杂度
• 独立部署：每个服务拥有独立代码库、独立数据库表前缀、独立容器镜像

三、技术选型与版本矩阵

选型遵循两个原则：国内生态成熟（导师认识、资料丰富）、版本兼容稳定（已通过本地测试）。

四、工程结构：可复现的源码组织方式

graduation-cloud/
├── pom.xml                              # 父工程，统一版本管理
├── docker-compose.yml                   # 容器编排，一键部署
├── sql/
│   └── init.sql                         # 数据库初始化脚本
├── gateway-service/                     # 网关服务
│   ├── pom.xml
│   └── src/main/java/com/gateway/
│       ├── GatewayApplication.java
│       └── filter/
│           └── JwtAuthFilter.java
├── user-service/                        # 用户服务
│   ├── pom.xml
│   └── src/main/java/com/user/
│       ├── UserApplication.java
│       ├── controller/
│       ├── service/
│       ├── mapper/
│       └── entity/
├── biz-service/                         # 业务服务
│   ├── pom.xml
│   └── src/main/java/com/biz/
│       ├── BizApplication.java
│       ├── controller/
│       ├── service/
│       ├── feign/                       # Feign 客户端
│       │   └── UserFeignClient.java
│       ├── mapper/
│       └── entity/
└── base-service/                        # 基础服务
    ├── pom.xml
    └── src/main/java/com/base/
        ├── BaseApplication.java
        └── controller/

五、核心代码实现

5.1 父工程 POM：版本锁定是关键

微服务项目中，版本冲突是头号噩梦。父工程必须严格锁定 Spring Boot、Spring Cloud、Spring Cloud Alibaba 三者的兼容版本。

<?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-cloud</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 BOM -->
            <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 BOM -->
            <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 BOM -->
            <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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

5.2 Nacos 服务注册与发现

每个子服务的 bootstrap.yml（必须使用 bootstrap.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/nacos，进入"服务管理"→"服务列表"，验证4个服务全部注册成功。

5.3 Gateway 网关：路由 + 鉴权 + 跨域

Gateway 是微服务的唯一入口，前端和后端服务都不直接暴露。

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1

        - id: biz-service-route
          uri: lb://biz-service
          predicates:
            - Path=/api/biz/**
          filters:
            - StripPrefix=1

        - id: base-service-route
          uri: lb://base-service
          predicates:
            - Path=/api/base/**
          filters:
            - StripPrefix=1

      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "*"
            allowedMethods:
              - GET
              - POST
              - PUT
              - DELETE
              - OPTIONS
            allowedHeaders: "*"
            maxAge: 3600

JWT 全局过滤器（核心安全组件）：

@Component
@Slf4j
public class JwtAuthFilter implements GlobalFilter, Ordered {
   

    private static final String SECRET = "GraduationSecretKey2026GraduationSecretKey";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
   
        String path = exchange.getRequest().getURI().getPath();

        // 白名单路径直接放行
        if (isWhiteList(path)) {
   
            return chain.filter(exchange);
        }

        String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
   
            return unauthorized(exchange);
        }

        String token = authHeader.substring(7);
        try {
   
            SecretKey key = Keys.hmacShaKeyFor(SECRET.getBytes(StandardCharsets.UTF_8));
            Claims claims = Jwts.parser()
                .verifyWith(key)
                .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(StandardCharsets.UTF_8));
        return response.writeWith(Mono.just(buffer));
    }

    @Override
    public int getOrder() {
   
        return -100; // 确保最先执行
    }
}

5.4 OpenFeign：服务间调用"像调本地方法"

在 biz-service 中定义 Feign 客户端，调用 user-service：

@FeignClient(
    name = "user-service",
    path = "/user",
    fallbackFactory = UserFeignClientFallbackFactory.class
)
public interface UserFeignClient {
   

    @GetMapping("/{id}")
    UserDTO getUserById(@PathVariable("id") Long id);

    @GetMapping("/batch")
    List<UserDTO> getUserBatch(@RequestParam("ids") List<Long> ids);
}

业务层直接注入使用：

@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
   

    private final UserFeignClient userFeignClient;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public OrderVO createOrder(OrderDTO dto) {
   
        // 1. 校验商品库存（本地业务）
        Product product = productMapper.selectById(dto.getProductId());
        if (product == null || product.getStock() < 1) {
   
            throw new BusinessException("商品不存在或库存不足");
        }

        // 2. 获取买家信息（跨服务调用，Feign自动处理HTTP+负载均衡）
        UserDTO buyer = userFeignClient.getUserById(dto.getBuyerId());

        // 3. 创建订单（本地事务）
        Order order = new Order();
        order.setProductId(dto.getProductId());
        order.setBuyerId(dto.getBuyerId());
        order.setSellerId(product.getUserId());
        order.setPrice(product.getPrice());
        order.setStatus(0); // 待支付
        this.save(order);

        // 4. 扣减库存
        product.setStock(product.getStock() - 1);
        productMapper.updateById(product);

        // 5. 组装返回
        OrderVO vo = new OrderVO();
        BeanUtils.copyProperties(order, vo);
        vo.setBuyerName(buyer.getUserName());
        vo.setProductTitle(product.getTitle());
        return vo;
    }
}

六、数据库设计：逻辑隔离优于物理分库

毕设场景下，单库 + 表前缀隔离是性价比最高的方案：

-- 用户域
CREATE TABLE sys_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
    username VARCHAR(50) NOT NULL UNIQUE COMMENT '用户名',
    password VARCHAR(100) NOT NULL COMMENT '加密密码',
    email VARCHAR(100) COMMENT '邮箱',
    phone VARCHAR(20) COMMENT '手机号',
    role VARCHAR(20) DEFAULT 'USER' COMMENT '角色：ADMIN/USER',
    status TINYINT DEFAULT 1 COMMENT '状态：1正常 0禁用',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_username (username),
    INDEX idx_role (role)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

-- 业务域（以二手交易平台为例）
CREATE TABLE biz_product (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL COMMENT '发布者ID',
    title VARCHAR(200) NOT NULL COMMENT '商品标题',
    description TEXT COMMENT '商品描述',
    price DECIMAL(10,2) NOT NULL COMMENT '价格',
    category_id INT COMMENT '分类ID',
    image_url VARCHAR(500) COMMENT '主图URL',
    status TINYINT DEFAULT 1 COMMENT '1上架 2下架 3已售',
    view_count INT DEFAULT 0 COMMENT '浏览量',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_user_id (user_id),
    INDEX idx_status (status),
    INDEX idx_category (category_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品表';

CREATE TABLE biz_order (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    product_id BIGINT NOT NULL COMMENT '商品ID',
    buyer_id BIGINT NOT NULL COMMENT '买家ID',
    seller_id BIGINT NOT NULL COMMENT '卖家ID',
    price DECIMAL(10,2) NOT NULL COMMENT '成交价格',
    status TINYINT DEFAULT 0 COMMENT '0待支付 1已支付 2已发货 3已完成 4已取消',
    pay_time DATETIME COMMENT '支付时间',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_buyer (buyer_id),
    INDEX idx_seller (seller_id),
    INDEX idx_product (product_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

-- 基础域
CREATE TABLE base_file (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    file_name VARCHAR(255) NOT NULL COMMENT '原始文件名',
    file_url VARCHAR(500) NOT NULL COMMENT '存储URL',
    file_type VARCHAR(50) COMMENT '文件类型',
    file_size BIGINT COMMENT '文件大小（字节）',
    module VARCHAR(50) COMMENT '所属模块',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='文件表';

七、云原生部署：基于阿里云 ECS 的容器化实践

7.1 为什么推荐云上部署？

毕业设计的最终交付物通常需要在线演示。相比本地笔记本启动，云服务器部署有以下优势：

• 答辩稳定性：不受本地环境、网络、电量影响
• 可访问性：导师可随时访问验证
• 技术加分：展示"Linux + Docker + 云服务器"的完整 DevOps 能力

7.2 阿里云 ECS 选型建议

7.3 Docker Compose 一键部署脚本

以下 docker-compose.yml 已在阿里云 ECS（Alibaba Cloud Linux 3）验证通过：

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    container_name: graduation-mysql
    environment:
      MYSQL_ROOT_PASSWORD: Graduation@2026
      MYSQL_DATABASE: graduation_db
      TZ: Asia/Shanghai
    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
    networks:
      - graduation-net

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

  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=Graduation@2026
      - JVM_XMS=256m
      - JVM_XMX=512m
      - TZ=Asia/Shanghai
    ports:
      - "8848:8848"
    depends_on:
      - mysql
    networks:
      - graduation-net

  user-service:
    build: ./user-service
    container_name: graduation-user
    ports:
      - "9001:9001"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/graduation_db?useSSL=false&serverTimezone=Asia/Shanghai
    depends_on:
      - nacos
      - mysql
    networks:
      - graduation-net

  biz-service:
    build: ./biz-service
    container_name: graduation-biz
    ports:
      - "9002:9002"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/graduation_db?useSSL=false&serverTimezone=Asia/Shanghai
    depends_on:
      - nacos
      - mysql
    networks:
      - graduation-net

  base-service:
    build: ./base-service
    container_name: graduation-base
    ports:
      - "9003:9003"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/graduation_db?useSSL=false&serverTimezone=Asia/Shanghai
    depends_on:
      - nacos
      - mysql
    networks:
      - graduation-net

  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
    networks:
      - graduation-net

volumes:
  mysql_data:

networks:
  graduation-net:
    driver: bridge

阿里云 ECS 部署命令：

# 1. 安装 Docker（Alibaba Cloud Linux 3）
sudo yum install -y docker
sudo systemctl start docker
sudo systemctl enable docker

# 2. 安装 Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# 3. 上传项目代码（通过 scp 或 git clone）
git clone https://github.com/yourname/graduation-cloud.git
cd graduation-cloud

# 4. 构建并启动（首次约5-8分钟）
docker-compose up -d --build

# 5. 查看服务状态
docker-compose ps

# 6. 查看Nacos注册列表（确认全部上线）
curl http://localhost:8848/nacos/v1/ns/service/list?pageNo=1&pageSize=10

7.4 阿里云安全组配置

务必在阿里云控制台配置安全组规则：

八、论文写作：微服务架构章节的标准模板

8.1 架构选型对比

论述模板："单体架构适用于功能简单、开发周期短的场景，但随着业务模块增加，代码耦合度上升，不利于独立迭代与扩展。微服务架构通过服务拆分实现了业务边界清晰、技术栈灵活、独立部署等优势，符合现代软件工程的发展趋势。本系统采用微服务架构，既展示了分布式系统设计能力，又通过合理的拆分粒度控制了实现复杂度。"

8.2 服务拆分依据

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

8.3 关键技术组件说明

九、避坑指南：10个微服务毕设高频翻车点

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

写到这里，必须坦诚地说：上述所有代码和配置，如果你从零手敲+调试，至少需要 10-15 天。而你的业务逻辑（商品管理、订单流程、前端页面）可能只需要 3-5 天。

对于时间紧迫的同学（比如只剩 2 周就要交初稿），或者想先把微服务骨架跑起来再专注业务设计的同学，可以考虑借助工具快速生成项目脚手架。

智码方舟官网（thesis.polars.cc）目前支持 Spring Cloud Alibaba 微服务架构的一键生成：

输入毕设题目（如"基于微服务架构的校园二手书交易平台"），选择技术栈：

• 后端：Spring Cloud + Nacos + Gateway + Feign + MyBatis Plus + JWT
• 前端：Vue 3 + Element Plus
• 数据库：MySQL 8.0 + Redis 7.x
• 部署：Docker Compose 一键部署脚本

生成物包含：

✅ 完整的4服务模块源码（含统一依赖管理、Nacos注册配置、Gateway路由、Feign客户端）
✅ 可直接运行的 docker-compose.yml（适配阿里云 ECS / 本地 Docker Desktop）
✅ 数据库初始化 SQL + 表结构设计文档
✅ 论文初稿（含微服务架构设计章节、技术选型对比表、服务拆分说明）

你拿到后只需要：

1. 在 biz-service 中实现你的核心业务逻辑（Controller、Service、Mapper）
2. 调整前端页面 UI 与业务字段
3. 将自动生成的架构图和技术说明整合进论文

代码完全开源可修改，答辩时你能讲清楚每一行配置的作用。这不是代写，是"脚手架生成"——类似 Vue CLI 创建项目骨架，业务代码由你自己实现。

如果你现在正处于"想尝试微服务架构但怕时间不够"的阶段，可以去官网体验 免费生成项目骨架 的功能，先把 Nacos 和 Gateway 跑起来验证效果，再决定是否深入二开。

十一、结语

微服务架构不是毕设的"炫技工具"，而是你展示工程化思维和云原生实践能力的窗口。导师真正想看到的是：

1. 你知道为什么拆（业务边界清晰）
2. 你知道怎么通信（Feign + Gateway）
3. 你知道怎么治理（Nacos 注册发现）
4. 你知道怎么部署（Docker + 阿里云 ECS）

用本文的"3+1"模型，配合完整代码和云上部署方案，2-3周内完全可以落地一个"有架构深度"的毕设项目。

最后提醒：答辩时一定现场打开 Nacos 控制台（http://你的ECS公网IP:8848/nacos），给导师展示4个服务全部在线注册的截图——眼见为实，比你说100句都有用。

如果本文对你有帮助，欢迎：

• ⭐ 点赞 + 收藏：答辩前回来查避坑表
• 💬 评论交流：你在微服务毕设中遇到了什么问题？阿里云部署踩过哪些坑？
• 🔗 分享：转发给正在头秃的毕设队友