使用 Spring Boot 开发后端的整体流程可以分为 8 大步骤，从环境准备到部署上线，每个步骤都有明确的目标和操作规范。以下是详细流程（以 Maven 项目 + MyBatis-Plus（数据访问）+ MySQL（数据库） 为例，这是最常见的组合）：

一、步骤1：环境准备（前置条件）

目标：确保开发和运行环境正常，避免后续因环境问题导致的异常。
需要准备的工具/环境：

  1. JDK：Spring Boot 3.x 需 JDK 17+，2.x 需 JDK 8+（推荐 JDK 17，LTS 版本更稳定）。
  2. 构建工具：Maven（推荐 3.6+）或 Gradle（本文以 Maven 为例）。
  3. IDE：IntelliJ IDEA（推荐，对 Spring 支持好）或 Eclipse（需安装 Spring Tools 插件）。
  4. 数据库：MySQL 8.0+（提前安装并启动，创建项目专用数据库，如 tool_db）。
  5. 版本控制（可选但推荐）：Git（用于代码管理）。

检查环境：

  • 终端输入 java -version 确认 JDK 版本正确。
  • 输入 mvn -v 确认 Maven 可用。

二、步骤2：初始化 Spring Boot 项目（创建骨架）

目标：生成 Spring Boot 项目的基础结构，包含必要的配置文件和依赖管理。
操作方式：
推荐使用 Spring Initializr 快速生成（有 3 种方式，选一种即可）：

  1. 网页版：访问 start.spring.io，填写信息后下载项目压缩包，导入 IDE。

    • Project：Maven Project
    • Language：Java
    • Spring Boot：3.2.x（最新稳定版）
    • Group：com.example（公司/组织域名反写，自定义）
    • Artifact：tool-backend（项目名，小写）
    • Package name：com.example.tool（默认 Group + Artifact）
    • Java：17
    • Dependencies：勾选核心依赖（根据需求选择）：
      • Spring Web：用于开发 RESTful 接口（必选）。
      • MyBatis-Plus Generator：快速生成 Mapper/Entity 代码（可选，提高效率）。
      • MySQL Driver：连接 MySQL 数据库（必选）。
      • Lombok：简化实体类代码（减少 getter/setter，推荐）。
      • Spring Boot DevTools：热部署（开发时修改代码无需重启，推荐）。
      • Validation：参数校验（如手机号、邮箱格式验证，推荐）。

  2. IDEA 内置工具：

    • 打开 IDEA → New Project → Spring Initializr → 填写上述信息 → 勾选依赖 → 生成项目。

生成的基础目录结构（关键目录/文件）：

tool-backend/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── tool/
│   │   │               └── ToolBackendApplication.java  // 项目入口类（核心）
│   │   └── resources/
│   │       ├── application.properties  // 全局配置文件（初始为空，需手动配置）
│   │       ├── static/  // 静态资源（如图片，后端项目一般不用）
│   │       └── templates/  // 模板文件（如 Thymeleaf，纯后端接口项目不用）
│   └── test/  // 测试代码目录
│       └── java/
│           └── com/
│               └── example/
│                   └── tool/
│                       └── ToolBackendApplicationTests.java  // 测试入口
├── pom.xml  // Maven 依赖配置文件（核心）
└── README.md  // 项目说明（可选）

三、步骤3：配置核心文件（项目基础参数）

目标：配置数据库连接、端口、日志等基础参数，确保项目能正常启动并连接外部资源。
需创建/修改的文件：

  1. 配置文件格式转换（推荐）：
    Spring Boot 支持 .properties 和 .yml 格式，.yml 更易读，建议将 application.properties 改为 application.yml（删除原文件，新建该文件）。

  2. application.yml 核心配置：

    # 服务器配置
server:
  port: 8081  # 项目启动端口（默认8080，避免冲突可改）
  servlet:
    context-path: /api  # 接口统一前缀（如所有接口都带 /api，如 http://localhost:8081/api/tools）

# 数据库配置（MySQL）
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver  # MySQL 8 驱动
    url: jdbc:mysql://localhost:3306/tool_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai  # 数据库地址（tool_db 是提前创建的库名）
    username: root  # 数据库用户名
    password: 123456  # 数据库密码（替换为自己的）

# MyBatis-Plus 配置（若用 MyBatis-Plus）
mybatis-plus:
  mapper-locations: classpath:mapper/*.xml  # Mapper XML 文件存放路径（后续会创建）
  type-aliases-package: com.example.tool.entity  # 实体类包路径（简化 XML 中的类名）
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 打印 SQL 日志（开发时方便调试）

# 日志配置（可选，控制日志输出级别）
logging:
  level:
    com.example.tool.mapper: debug  # Mapper 接口的日志级别为 debug（方便看 SQL）
    root: info  # 全局日志级别

  3. pom.xml 补充依赖（若初始化时漏选，手动添加）：
    例如，若需要 MyBatis-Plus 核心功能，添加：

    <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.5</version>  <!-- 最新稳定版 -->
</dependency>

四、步骤4：设计数据库与创建实体类（数据模型）

目标：定义业务数据的存储结构（数据库表）和 Java 中对应的数据模型（实体类），这是整个后端的“数据基础”。

1. 设计数据库表（以“管理员表”为例）

先在 MySQL 中创建表（可手动执行 SQL 或用工具生成）：

-- 管理员表（admin）
CREATE TABLE `admin` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `username` varchar(50) NOT NULL COMMENT '用户名',
  `password` varchar(100) NOT NULL COMMENT '密码（加密存储）',
  `nickname` varchar(50) DEFAULT NULL COMMENT '昵称',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_username` (`username`)  -- 用户名唯一
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='管理员表';
2. 创建实体类（Entity）

实体类是数据库表的“镜像”，每个字段对应表中的一列，用于在 Java 代码中操作数据。
目录：src/main/java/com/example/tool/entity/（需手动创建 entity 包）
文件：Admin.java

package com.example.tool.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;  // Lombok 注解，自动生成 getter/setter

import java.time.LocalDateTime;

@Data  // Lombok：替代手动编写 getter/setter/toString 等方法
@TableName("admin")  // MyBatis-Plus：指定对应的数据表名（必须与数据库表名一致）
public class Admin {
    @TableId(type = IdType.AUTO)  // 主键策略：自增（与数据库表的 AUTO_INCREMENT 对应）
    private Long id;

    private String username;  // 用户名（与表中 username 列对应）

    private String password;  // 密码

    private String nickname;  // 昵称

    private LocalDateTime createTime;  // 创建时间（Java 8 新时间类型，对应数据库 datetime）

    private LocalDateTime updateTime;  // 更新时间
}

为什么先创建实体类？
后续的数据访问层（Mapper）、服务层（Service）都依赖实体类进行数据传递，是整个数据流程的“载体”。

五、步骤5：创建数据访问层（Mapper）

目标：定义与数据库交互的接口，负责执行 SQL 操作（如增删改查），是 Java 代码与数据库之间的“桥梁”。

1. 创建 Mapper 接口

目录：src/main/java/com/example/tool/mapper/（手动创建 mapper 包）
文件：AdminMapper.java

package com.example.tool.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.tool.entity.Admin;

// @Mapper：MyBatis 注解，标记这是一个 Mapper 接口，Spring 会自动扫描并创建实现类
@Mapper
public interface AdminMapper extends BaseMapper<Admin> {
    // 继承 BaseMapper<Admin> 后，自动拥有常用方法：
    // insert(Admin)：新增
    // selectById(Long)：根据ID查询
    // updateById(Admin)：根据ID更新
    // deleteById(Long)：根据ID删除
    // 等 17 个通用方法（无需手动写 SQL）

    // 若有复杂查询（如多表联查），可在此定义方法，然后在 XML 中写 SQL
}
2. 创建 Mapper XML 文件（复杂 SQL 用）

如果需要自定义 SQL（如多表查询），需创建 XML 文件（简单操作依赖 BaseMapper 即可，可跳过）。
目录：src/main/resources/mapper/（手动创建 mapper 文件夹，与 application.yml 中 mapper-locations 配置一致）
文件：AdminMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace 必须与 Mapper 接口的全类名一致 -->
<mapper namespace="com.example.tool.mapper.AdminMapper">

    <!-- 示例：自定义查询（根据用户名查询管理员） -->
    <select id="selectByUsername" resultType="com.example.tool.entity.Admin">
        SELECT * FROM admin WHERE username = #{username}
    </select>
</mapper>

然后在 AdminMapper.java 中添加对应方法：

Admin selectByUsername(String username);  // 与 XML 中 id 一致

六、步骤6：创建服务层（Service）

目标：封装业务逻辑（如密码加密、权限校验），协调 Mapper 层进行数据操作，是整个后端的“业务核心”。

1. 创建 Service 接口

目录：src/main/java/com/example/tool/service/（手动创建 service 包）
文件：AdminService.java

package com.example.tool.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.tool.entity.Admin;

// 继承 IService<Admin>：MyBatis-Plus 提供的通用服务接口，封装了更丰富的业务方法
public interface AdminService extends IService<Admin> {
    // 通用方法已包含（如 save、getById 等），在此定义自定义业务方法
    Admin login(String username, String password);  // 登录业务（示例）
}
2. 创建 Service 实现类

目录：src/main/java/com/example/tool/service/impl/（手动创建 impl 子包，存放实现类）
文件：AdminServiceImpl.java

package com.example.tool.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.tool.entity.Admin;
import com.example.tool.mapper.AdminMapper;
import com.example.tool.service.AdminService;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;  // Spring 提供的加密工具

// @Service：Spring 注解，标记这是服务层组件，会被自动扫描并注入到 Spring 容器
@Service
public class AdminServiceImpl extends ServiceImpl<AdminMapper, Admin> implements AdminService {

    // 登录业务实现（示例：校验用户名密码）
    @Override
    public Admin login(String username, String password) {
        // 1. 根据用户名查询管理员（调用 Mapper 方法）
        Admin admin = baseMapper.selectByUsername(username);  // baseMapper 是父类提供的 Mapper 实例
        if (admin == null) {
            throw new RuntimeException("用户名不存在");
        }

        // 2. 校验密码（假设数据库密码是 MD5 加密存储的）
        String encryptedPassword = DigestUtils.md5DigestAsHex(password.getBytes());  // 对输入密码加密
        if (!encryptedPassword.equals(admin.getPassword())) {
            throw new RuntimeException("密码错误");
        }

        // 3. 登录成功，返回管理员信息（可脱敏，如隐藏密码）
        admin.setPassword(null);  // 清除密码，避免泄露
        return admin;
    }
}

Service 层的作用：

  • 隔离业务逻辑与数据访问，避免 Controller 直接操作数据库（符合“分层架构”原则）。
  • 集中处理复杂业务（如事务管理、数据校验），例如：转账业务需要同时操作两个账户，Service 层可通过 @Transactional 注解保证事务一致性。

七、步骤7：创建控制层（Controller）

目标：接收前端 HTTP 请求（如 GET/POST），调用 Service 层处理业务，返回响应结果（如 JSON），是前后端交互的“入口”。

目录：src/main/java/com/example/tool/controller/（手动创建 controller 包）
文件：AdminController.java

package com.example.tool.controller;

import com.example.tool.entity.Admin;
import com.example.tool.service.AdminService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

// @RestController：组合注解（@Controller + @ResponseBody），表示这是控制器，且返回 JSON 数据
@RestController
// @RequestMapping：指定接口的统一前缀（如所有管理员接口都带 /admin）
@RequestMapping("/admin")
public class AdminController {

    // @Autowired：Spring 自动注入 AdminService 实例（无需手动 new）
    @Autowired
    private AdminService adminService;

    // 登录接口（POST 请求，接收 JSON 参数）
    @PostMapping("/login")
    public Result<Admin> login(@RequestBody LoginDTO loginDTO) {  // @RequestBody：接收 JSON 格式参数
        Admin admin = adminService.login(loginDTO.getUsername(), loginDTO.getPassword());
        return Result.success(admin);  // 返回统一响应格式（需自定义 Result 类）
    }

    // 示例：根据 ID 查询管理员（GET 请求，路径传参）
    @GetMapping("/{id}")
    public Result<Admin> getById(@PathVariable Long id) {  // @PathVariable：接收路径中的参数
        Admin admin = adminService.getById(id);  // 调用 Service 通用方法
        return Result.success(admin);
    }
}
补充：创建通用响应类（Result）和 DTO

  • 通用响应类（Result）：统一接口返回格式（方便前端处理），目录 src/main/java/com/example/tool/common/Result.java：

    package com.example.tool.common;

import lombok.Data;

@Data
public class Result<T> {
    private Integer code;  // 状态码：200 成功，500 失败
    private String msg;    // 提示信息
    private T data;        // 响应数据

    // 成功响应（带数据）
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMsg("success");
        result.setData(data);
        return result;
    }

    // 失败响应
    public static <T> Result<T> error(String msg) {
        Result<T> result = new Result<>();
        result.setCode(500);
        result.setMsg(msg);
        return result;
    }
}

  • DTO（数据传输对象）：用于接收前端传递的参数（避免直接使用实体类暴露数据库字段），目录 src/main/java/com/example/tool/dto/LoginDTO.java：

    package com.example.tool.dto;

import lombok.Data;

@Data
public class LoginDTO {
    private String username;  // 仅接收登录所需的用户名
    private String password;  // 仅接收登录所需的密码
}

八、步骤8：测试、运行与部署

1. 编写单元测试（确保功能正确）

目录：src/test/java/com/example/tool/service/impl/AdminServiceImplTest.java

package com.example.tool.service.impl;

import com.example.tool.entity.Admin;
import com.example.tool.service.AdminService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest  // 启动 Spring 容器，加载所有组件
class AdminServiceImplTest {

    @Autowired
    private AdminService adminService;

    @Test
    void login() {
        // 测试登录功能（假设数据库中有 username=admin, password=MD5(123456) 的数据）
        Admin admin = adminService.login("admin", "123456");
        assertNotNull(admin);  // 断言登录成功（admin 不为 null）
        assertEquals("admin", admin.getUsername());  // 断言用户名正确
    }
}
2. 启动项目（验证接口可访问）

运行 ToolBackendApplication.java 的 main 方法，控制台出现 Started ToolBackendApplication in x seconds 表示启动成功。

用 Postman 或浏览器测试接口：

  • 测试查询接口：GET http://localhost:8081/api/admin/1（假设 ID=1 的管理员存在）。
  • 测试登录接口：POST http://localhost:8081/api/admin/login，请求体 JSON：{"username":"admin","password":"123456"}。
3. 打包部署（上线运行）
  • 打包：终端执行 mvn clean package -Dmaven.test.skip=true（跳过测试），在 target 目录生成 tool-backend-0.0.1-SNAPSHOT.jar。
  • 部署：将 Jar 包上传到服务器，执行 java -jar tool-backend-0.0.1-SNAPSHOT.jar 启动（生产环境推荐用 nohup 后台运行：nohup java -jar ... &）。

总结：整体流程与目录结构回顾

  1. 流程顺序：环境准备 → 项目初始化 → 配置文件 → 实体类 → Mapper → Service → Controller → 测试部署。
  2. 核心目录（按依赖关系排序）：
    • entity：数据模型（基础）。
    • mapper：数据访问（依赖 entity）。
    • service：业务逻辑（依赖 mapper）。
    • controller：接口交互（依赖 service）。
    • common/dto：通用组件（被 controller/service 依赖）。
  3. 各层目的：分层架构使代码职责清晰，便于维护（例如：修改业务逻辑只需改 Service，无需动 Controller）。

按照这个流程，即使是复杂项目，也能保证代码结构清晰、逻辑有序。

# spring boot # 后端 # java
Logo
魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

cover

替你试过了，消费级显卡可以跑的开源文生图SOTA模型，顶级渲染、高密度文本绘图

avatar 魔乐社区
cover

量化挑战赛冠军专访：4小时啃下W4A8量化，我靠的是这些经验

avatar 魔乐社区

小参数・大码力・易部署 | Qwen3.6-27B上线魔乐社区，基于昇腾的部署教程来了

继一周前模型开源发布后，千问再度开源Qwen3.6-27B —— 一个拥有270亿参数的稠密多模态模型，也是社区呼声最高的模型规格。Qwen3.6-27B 依然支持多模态思考与非思考模式，在智能体编程方面达到了旗舰级表现，全面超越前代开源旗舰 Qwen3.5-397B-A17B（总参数397B / 激活参数17B的MoE模型）。作为稠密架构，它无需MoE路由即可部署，是开发者在实用、可广泛部署规模

avatar 魔乐社区