Spring Boot + Vue 项目开发流程完整指南

本文为前后端分离项目开发团队提供了一份详细的开发流程文档，涵盖从需求收集到部署上线的完整生命周期，以Spring Boot + Vue技术栈为例，适用于中小型Web项目开发。

项目开发流程概览

一个完整的Spring Boot + Vue项目开发通常包含以下主要阶段：

1. 项目启动与规划阶段 - 明确目标，组建团队
2. 需求分析与设计阶段 - 需求梳理，原型设计
3. 技术设计与准备阶段 - 架构设计，环境准备
4. 开发实施阶段 - 前后端并行开发
5. 测试与质量保证阶段 - 联调测试，质量验收
6. 部署与上线阶段 - 环境部署，正式发布
7. 运维与维护阶段 - 监控运维，迭代优化

下面我们详细介绍每个阶段的具体内容。

---

第一阶段：项目启动与规划阶段

1.1 项目立项与可行性分析

时间周期： 1-2天
参与人员： 项目经理、产品经理、技术负责人
核心交付物：

• 项目立项书
• 可行性分析报告
• 项目charter

关键活动：

• 明确项目目标和商业价值
• 评估技术可行性和资源需求
• 确定项目预算和时间计划
• 识别主要风险和制约因素

1.2 团队组建与角色分工

核心角色配置：

• 项目经理：项目统筹，进度管理
• 产品经理：需求管理，用户体验
• UI/UX设计师：界面设计，交互设计
• 后端开发工程师：Java后端开发
• 前端开发工程师：Vue前端开发
• 测试工程师：质量保证，测试执行
• 运维工程师：环境部署，系统运维

1.3 项目计划制定

制定关键计划：

• 项目WBS（工作分解结构）
• 详细项目进度计划
• 里程碑节点规划
• 风险管理预案

---

第二阶段：需求分析与设计阶段

2.1 业务需求收集与分析

核心工作内容：

## 需求收集清单
- [ ] 业务背景调研
- [ ] 用户角色分析
- [ ] 功能需求梳理
- [ ] 非功能需求定义
- [ ] 业务流程梳理
- [ ] 数据需求分析

输出文档：

• 业务需求文档（BRD）
• 用户故事地图
• 业务流程图

2.2 需求细化与用户体验设计

设计流程：

1. 需求分析 → 产品需求文档（PRD）
2. 用户体验设计 → 用户流程图
3. 界面设计 → UI设计稿和原型
4. 交互设计 → 交互规范文档

重要提示： 在这个阶段，前端开发同学需要深度参与，确保设计的可实现性。

2.3 系统架构设计

架构设计要点：

• 整体架构选择：单体应用 vs 微服务架构
• 技术栈确定：
  • 后端：Spring Boot + Spring Security + MyBatis/JPA
  • 前端：Vue 3 + Vue Router + Pinia + Element Plus
  • 数据库：MySQL + Redis
• 部署架构：容器化部署 + 负载均衡
• 安全策略：JWT认证 + HTTPS + 数据加密

---

第三阶段：技术设计与准备阶段

3.1 数据库设计

设计步骤：

1. 概念设计 - 实体关系图（ER图）
2. 逻辑设计 - 数据表设计
3. 物理设计 - 索引和分区策略

示例表结构：

-- 用户表设计
CREATE TABLE t_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
    username VARCHAR(50) NOT NULL UNIQUE COMMENT '用户名',
    password VARCHAR(255) NOT NULL COMMENT '密码（加密）',
    email VARCHAR(100) COMMENT '邮箱',
    phone VARCHAR(20) COMMENT '手机号',
    avatar_url VARCHAR(255) COMMENT '头像URL',
    status TINYINT DEFAULT 1 COMMENT '状态：1-正常，0-禁用',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    
    INDEX idx_username (username),
    INDEX idx_email (email),
    INDEX idx_phone (phone)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

3.2 API接口设计

设计原则：

• 遵循RESTful风格
• 统一响应格式
• 完善的错误处理
• 接口版本管理

API设计示例：

# 用户相关接口设计
paths:
  /api/v1/users:
    get:
      summary: 获取用户列表
      parameters:
        - name: page
          in: query
          schema:
            type: integer
            default: 1
        - name: size
          in: query
          schema:
            type: integer
            default: 10
      responses:
        '200':
          description: 成功
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: integer
                    example: 200
                  message:
                    type: string
                    example: "success"
                  data:
                    type: object
                    properties:
                      total:
                        type: integer
                      records:
                        type: array
                        items:
                          $ref: '#/components/schemas/User'

统一响应格式：

{
  "code": 200,
  "message": "success",
  "data": {
    // 具体业务数据
  },
  "timestamp": 1692954000000
}

3.3 开发环境搭建

环境配置清单：

# 后端开发环境
- JDK 17+
- Maven 3.6+
- MySQL 8.0+
- Redis 6.0+
- IntelliJ IDEA

# 前端开发环境  
- Node.js 16+
- npm/yarn
- Vue CLI
- VS Code

# 协作工具
- Git版本控制
- Docker容器
- Postman接口测试

---

第四阶段：开发实施阶段

4.1 后端开发

4.1.1 项目初始化

创建Spring Boot项目：

<!-- pom.xml 核心依赖配置 -->
<dependencies>
    <!-- Spring Boot Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    
    <!-- Spring Boot Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- JWT -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

4.1.2 基础架构开发

统一响应格式封装：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ApiResponse<T> {
    private Integer code;
    private String message;
    private T data;
    private Long timestamp;
    
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "success", data, System.currentTimeMillis());
    }
    
    public static <T> ApiResponse<T> error(Integer code, String message) {
        return new ApiResponse<>(code, message, null, System.currentTimeMillis());
    }
}

全局异常处理：

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(BusinessException.class)
    public ApiResponse<Void> handleBusinessException(BusinessException e) {
        return ApiResponse.error(e.getCode(), e.getMessage());
    }
    
    @ExceptionHandler(ValidationException.class)
    public ApiResponse<Void> handleValidationException(ValidationException e) {
        return ApiResponse.error(400, e.getMessage());
    }
    
    @ExceptionHandler(Exception.class)
    public ApiResponse<Void> handleException(Exception e) {
        log.error("系统异常", e);
        return ApiResponse.error(500, "系统内部错误");
    }
}

4.1.3 业务功能开发

分层架构实现：

// Controller层
@RestController
@RequestMapping("/api/v1/users")
@Validated
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    public ApiResponse<PageResult<UserVO>> getUsers(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size) {
        PageResult<UserVO> result = userService.getUsers(page, size);
        return ApiResponse.success(result);
    }
    
    @PostMapping
    public ApiResponse<Void> createUser(@Valid @RequestBody CreateUserRequest request) {
        userService.createUser(request);
        return ApiResponse.success(null);
    }
}

// Service层
@Service
@Transactional
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public PageResult<UserVO> getUsers(Integer page, Integer size) {
        Pageable pageable = PageRequest.of(page - 1, size);
        Page<User> userPage = userRepository.findAll(pageable);
        
        List<UserVO> userVOs = userPage.getContent().stream()
                .map(this::convertToVO)
                .collect(Collectors.toList());
                
        return PageResult.of(userVOs, userPage.getTotalElements());
    }
}

4.2 前端开发

4.2.1 项目初始化

创建Vue项目：

# 使用Vue CLI创建项目
npm create vue@latest my-vue-project
cd my-vue-project
npm install

# 安装核心依赖
npm install axios element-plus @element-plus/icons-vue
npm install vue-router@4 pinia
npm install @types/node --save-dev

项目结构规划：

src/
├── components/          # 公共组件
├── views/              # 页面组件
├── router/             # 路由配置
├── stores/             # 状态管理
├── utils/              # 工具函数
├── api/               # API接口
├── styles/            # 样式文件
└── assets/            # 静态资源

4.2.2 基础设施开发

HTTP请求封装：

// utils/request.js
import axios from 'axios'
import { ElMessage } from 'element-plus'

const request = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
request.interceptors.request.use(
  config => {
    const token = localStorage.getItem('access_token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器
request.interceptors.response.use(
  response => {
    const { code, message, data } = response.data
    if (code === 200) {
      return data
    } else {
      ElMessage.error(message || '请求失败')
      return Promise.reject(new Error(message))
    }
  },
  error => {
    ElMessage.error(error.message || '网络错误')
    return Promise.reject(error)
  }
)

export default request

API接口管理：

// api/user.js
import request from '@/utils/request'

export const userApi = {
  // 获取用户列表
  getUsers(params) {
    return request({
      url: '/v1/users',
      method: 'get',
      params
    })
  },
  
  // 创建用户
  createUser(data) {
    return request({
      url: '/v1/users',
      method: 'post',
      data
    })
  },
  
  // 更新用户
  updateUser(id, data) {
    return request({
      url: `/v1/users/${id}`,
      method: 'put',
      data
    })
  }
}

4.2.3 页面组件开发

用户列表页面示例：

<template>
  <div class="user-list">
    <div class="header">
      <h2>用户管理</h2>
      <el-button type="primary" @click="showCreateDialog">
        <el-icon><Plus /></el-icon>
        新增用户
      </el-button>
    </div>
    
    <el-table :data="userList" v-loading="loading">
      <el-table-column prop="id" label="ID" width="80" />
      <el-table-column prop="username" label="用户名" />
      <el-table-column prop="email" label="邮箱" />
      <el-table-column prop="createTime" label="创建时间" />
      <el-table-column label="操作" width="150">
        <template #default="scope">
          <el-button size="small" @click="editUser(scope.row)">编辑</el-button>
          <el-button size="small" type="danger" @click="deleteUser(scope.row)">删除</el-button>
        </template>
      </el-table-column>
    </el-table>
    
    <el-pagination
      v-model:current-page="pagination.page"
      v-model:page-size="pagination.size"
      :total="pagination.total"
      @current-change="loadUsers"
      @size-change="loadUsers"
    />
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue'
import { userApi } from '@/api/user'
import { ElMessage } from 'element-plus'

const loading = ref(false)
const userList = ref([])
const pagination = ref({
  page: 1,
  size: 10,
  total: 0
})

const loadUsers = async () => {
  loading.value = true
  try {
    const result = await userApi.getUsers({
      page: pagination.value.page,
      size: pagination.value.size
    })
    userList.value = result.records
    pagination.value.total = result.total
  } catch (error) {
    ElMessage.error('加载用户列表失败')
  } finally {
    loading.value = false
  }
}

onMounted(() => {
  loadUsers()
})
</script>

4.3 开发阶段质量控制

代码质量保证措施：

1. 代码规范

   • ESLint + Prettier（前端）
   • Checkstyle + SpotBugs（后端）

2. 代码审查

   • Pull Request必须经过审查
   • 关键代码至少两人审查

3. 单元测试

   • 后端核心业务逻辑测试覆盖率 > 80%
   • 前端核心组件测试覆盖

4. 持续集成

   • 自动化构建和测试
   • 代码质量门禁检查

---

第五阶段：测试与质量保证阶段

5.1 前后端联调

联调准备工作：

1. 接口文档对齐 - 确保前后端对接口的理解一致
2. Mock数据准备 - 前端准备测试数据
3. 环境配置 - 前后端环境互通

联调测试重点：

## 联调测试检查清单
- [ ] 接口请求格式正确性
- [ ] 接口响应数据格式一致性  
- [ ] 错误场景处理完整性
- [ ] 跨域问题解决
- [ ] 认证授权流程验证
- [ ] 文件上传下载功能
- [ ] 分页查询正确性

5.2 系统测试

测试类型覆盖：

5.2.1 功能测试

• 用户注册登录流程
• 核心业务功能验证
• 边界条件测试
• 异常场景处理

5.2.2 性能测试

• 接口响应时间测试
• 并发用户负载测试
• 数据库查询性能测试

JMeter测试脚本示例：

<!-- HTTP请求性能测试配置 -->
<HTTPSamplerProxy>
  <elementProp name="HTTPsampler.Arguments">
    <collectionProp name="Arguments.arguments"/>
  </elementProp>
  <stringProp name="HTTPSampler.domain">localhost</stringProp>
  <stringProp name="HTTPSampler.port">8080</stringProp>
  <stringProp name="HTTPSampler.path">/api/v1/users</stringProp>
  <stringProp name="HTTPSampler.method">GET</stringProp>
</HTTPSamplerProxy>

5.2.3 安全测试

• SQL注入攻击防护
• XSS跨站脚本攻击防护
• CSRF跨站请求伪造防护
• 敏感数据加密验证

5.3 用户验收测试（UAT）

UAT测试流程：

1. 测试环境准备 - 部署接近生产的测试环境
2. 业务用户培训 - 介绍系统功能和操作方法
3. 实际业务场景测试 - 按真实业务流程测试
4. 问题反馈和修复 - 收集问题并快速响应
5. 验收确认 - 业务方签字确认验收通过

---

第六阶段：部署与上线阶段

6.1 生产环境准备

基础设施配置：

# docker-compose.yml 生产环境配置
version: '3.8'
services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_NAME}
    volumes:
      - mysql_data:/var/lib/mysql
    ports:
      - "3306:3306"
      
  redis:
    image: redis:6.0-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
      
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - backend
      
volumes:
  mysql_data:
  redis_data:

6.2 应用部署

6.2.1 后端部署

Dockerfile配置：

FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/my-app.jar app.jar

EXPOSE 8080

ENV JAVA_OPTS="-Xmx512m -Xms256m"

ENTRYPOINT exec java $JAVA_OPTS -jar app.jar

部署脚本：

#!/bin/bash
# deploy-backend.sh

echo "开始部署后端应用..."

# 停止旧容器
docker stop my-app-backend || true
docker rm my-app-backend || true

# 构建新镜像
docker build -t my-app-backend:latest .

# 启动新容器
docker run -d \
  --name my-app-backend \
  -p 8080:8080 \
  -e SPRING_PROFILES_ACTIVE=prod \
  -e DB_HOST=${DB_HOST} \
  -e DB_PASSWORD=${DB_PASSWORD} \
  --restart=unless-stopped \
  my-app-backend:latest

echo "后端应用部署完成！"

6.2.2 前端部署

构建配置：

// vite.config.js 生产环境配置
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'

export default defineConfig({
  plugins: [vue()],
  build: {
    outDir: 'dist',
    assetsDir: 'assets',
    minify: 'terser',
    terserOptions: {
      compress: {
        drop_console: true,
        drop_debugger: true
      }
    }
  },
  define: {
    'process.env.NODE_ENV': '"production"'
  }
})

Nginx配置：

server {
    listen 80;
    server_name your-domain.com;
    
    # 前端静态文件
    location / {
        root /var/www/html;
        try_files $uri $uri/ /index.html;
        
        # 缓存配置
        location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
            expires 1y;
            add_header Cache-Control "public, immutable";
        }
    }
    
    # API代理
    location /api/ {
        proxy_pass http://backend:8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

6.3 生产验证

上线检查清单：

## 生产环境验证清单
- [ ] 应用健康检查接口正常
- [ ] 数据库连接正常
- [ ] 缓存服务正常
- [ ] 核心功能验证通过
- [ ] 性能指标符合要求
- [ ] 安全配置检查完成
- [ ] 监控告警配置正确
- [ ] 日志收集正常
- [ ] 备份机制验证
- [ ] 回滚方案准备完成

---

第七阶段：运维与维护阶段

7.1 系统监控

监控体系建设：

7.1.1 应用监控

// Spring Boot Actuator 健康检查
@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Autowired
    private UserService userService;
    
    @Override
    public Health health() {
        try {
            // 检查核心服务是否正常
            userService.healthCheck();
            return Health.up()
                .withDetail("status", "UP")
                .withDetail("timestamp", System.currentTimeMillis())
                .build();
        } catch (Exception e) {
            return Health.down()
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

7.1.2 业务监控

// 前端埋点监控
export const trackEvent = (eventName, properties = {}) => {
  // 发送埋点数据到监控系统
  const trackData = {
    event: eventName,
    properties: {
      ...properties,
      timestamp: Date.now(),
      userId: getCurrentUserId(),
      url: window.location.href
    }
  }
  
  // 发送到监控服务
  fetch('/api/track', {
    method: 'POST',
    body: JSON.stringify(trackData)
  }).catch(err => {
    console.error('埋点上报失败:', err)
  })
}

7.2 日志管理

日志配置：

<!-- logback-spring.xml -->
<configuration>
    <springProfile name="prod">
        <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>logs/application.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>logs/application.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <maxFileSize>100MB</maxFileSize>
                <maxHistory>30</maxHistory>
                <totalSizeCap>3GB</totalSizeCap>
            </rollingPolicy>
            <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
                <providers>
                    <timestamp/>
                    <logLevel/>
                    <loggerName/>
                    <message/>
                    <mdc/>
                    <stackTrace/>
                </providers>
            </encoder>
        </appender>
    </springProfile>
</configuration>

7.3 问题处理与优化

故障响应流程：

1. 问题发现 - 监控告警触发
2. 问题定位 - 查看日志和监控数据
3. 影响评估 - 评估问题影响范围
4. 应急处理 - 快速恢复服务
5. 根因分析 - 深入分析问题原因
6. 永久修复 - 代码修复并测试
7. 复盘总结 - 总结经验和改进措施

---

项目管理最佳实践

沟通协作机制

会议体系：

• 每日站会 (15分钟) - 同步进度，识别阻塞
• 周例会 (60分钟) - 回顾周进展，计划下周工作
• 里程碑评审 - 阶段性成果验收
• 技术评审 - 重要技术方案评审

质量管理体系

代码质量保证：

# .github/workflows/ci.yml
name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  backend-test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up JDK 17
      uses: actions/setup-java@v3
      with:
        java-version: '17'
    - name: Run tests
      run: ./mvnw test
    - name: Code coverage
      run: ./mvnw jacoco:report
      
  frontend-test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '16'
    - name: Install dependencies
      run: npm ci
    - name: Run tests
      run: npm run test:unit
    - name: Build
      run: npm run build

工具链推荐

开发工具：

• 代码管理：Git + GitHub/GitLab
• 项目管理：Jira + Confluence
• 接口测试：Postman + Swagger
• 代码审查：SonarQube
• 构建部署：Jenkins/GitHub Actions
• 监控运维：Prometheus + Grafana + ELK

---

时间周期与成本估算

项目周期规划

阶段	时间范围	人力投入	关键里程碑
项目启动与规划	1周	PM + 技术负责人	项目启动
需求分析与设计	2-3周	产品 + 设计 + 开发	需求评审通过
技术设计与准备	1-2周	架构师 + 开发团队	技术方案评审
开发实施	6-8周	全体开发团队	功能开发完成
测试与质量保证	2-3周	测试 + 开发	测试通过
部署与上线	1周	运维 + 开发	成功上线
总计	13-18周	全团队	项目交付

团队配置建议

小型项目（3-5人）：

• 全栈开发工程师 × 2
• 前端开发工程师 × 1
• 产品经理/项目经理 × 1
• 测试工程师 × 1（兼职）

中型项目（6-10人）：

• 后端开发工程师 × 2-3
• 前端开发工程师 × 2
• 产品经理 × 1
• 项目经理 × 1
• UI/UX设计师 × 1
• 测试工程师 × 1
• 运维工程师 × 1（兼职）

---

项目成功要素

技术层面

1. 架构设计合理 - 符合业务发展需要
2. 代码质量高 - 可维护、可扩展
3. 测试覆盖完整 - 功能、性能、安全测试
4. 部署流程标准 - 自动化、可回滚

管理层面

1. 需求管理规范 - 变更控制、版本管理
2. 进度管控有效 - 里程碑节点、风险预警
3. 团队协作顺畅 - 沟通机制、分工明确
4. 质量意识强 - 代码审查、持续改进

业务层面

1. 用户体验优秀 - 界面友好、操作简单
2. 性能表现良好 - 响应快速、稳定可靠
3. 功能完整实用 - 覆盖核心业务场景
4. 安全保障充分 - 数据安全、系统安全

---

总结

本文详细介绍了Spring Boot + Vue项目的完整开发流程，从项目启动到运维维护的各个阶段都有具体的指导。成功的项目需要：

• 充分的前期规划 - 需求明确，设计完整
• 有效的团队协作 - 沟通顺畅，分工明确
• 严格的质量控制 - 代码质量，测试覆盖
• 规范的开发流程 - 标准化、可重复
• 完善的运维体系 - 监控、告警、应急响应

希望这份指南能够帮助你的团队更好地管理和执行Spring Boot + Vue项目，提高项目成功率和交付质量。

如果你有任何问题或建议，欢迎在评论区留言交流！

最后更新： 2025年08月25日 22:05

原始链接： https://goodgan.github.io/2025/08/25/springboot-vue-development-guide/

mrgan

赏

× 请我吃糖~