——以校园博客论坛系统为案例#

1
╔═══════════════════════════════════════════════════════╗
2
║                                                       ║
3
║           Java Spring Boot 零基础完整学习手册            ║
4
║                                                       ║
5
║           ——从 HelloWorld 到完整后端项目的奇妙之旅        ║
6
║                                                       ║
7
║                                                       ║
8
║            案例项目：校园博客论坛系统 v1.34              ║
9
║            作者：刘畅                                   ║
10
║            发布日期：2026 年 4 月                        ║
11
║                                                       ║
12
╚═══════════════════════════════════════════════════════╝

关于本书#

这是一本真正面向零基础的 Spring Boot 学习手册。它不会假设你已经懂 Java，也不会跳过任何环节。我们会一起从最基础的 Hello World 开始，一步一步走到能独立看懂、修改、甚至从零搭建一个完整的后端项目。

本书的特点：

• ✅ 完全零基础友好：每个新概念都会用生活类比解释一次
• ✅ 真实项目驱动：所有讲解都基于真实可运行的”校园博客论坛系统”
• ✅ 代码来源真实：每一段示例代码都来自项目的真实文件，可以打开 IDE 一一对照
• ✅ 覆盖全栈后端：从 Java 语法 → Maven → Spring Boot → MyBatis Plus → Spring Security → JWT → 项目部署
• ✅ 超过 5 万字：足够详细，但不啰嗦

学完本书你将获得：

1. 能独立读懂任何 Spring Boot 项目的源码
2. 能用 Spring Boot + MyBatis Plus 从零搭建一个 RESTful 后端
3. 理解用户认证、JWT、密码加密、XSS 防护等安全要点
4. 会处理常见的并发问题（点赞重复、阅读量竞态等）
5. 能独立完成项目打包、部署、上线全流程

适合人群#

• 大学生 / 校招生：找后端开发的实习或工作
• 转行学编程：从 0 开始想入门后端开发
• 前端转后端：会 JavaScript 但想学后端
• 培训班学员：想要一份系统化的入门资料
• 代码爱好者：想看懂别人的 GitHub 项目

⚠️ 不适合：已经精通 Spring Boot、想看深入源码分析的高级开发者。本书定位是”入门到能上手”，不是”源码精读”。

学习建议#

案例项目简介#

本书使用的案例项目是一个真实的、可运行的校园博客论坛系统：

• GitHub：https://github.com/Xinghe-0203/Campus_Blog
• 版本：v1.34（最后更新 2026-04-27）
• 代码量：127 个 Java 文件
• 数据表：18 张
• Controller：13 个
• API 接口：67 个 HTTP 端点

包含的功能模块：

为什么选择这个项目作为案例？

1. 功能完整：覆盖了真实业务系统的方方面面，不是玩具项目
2. 代码规范：遵循阿里 Java 开发规范，分层清晰
3. 持续迭代：从 v1.0 → v1.34 经过 30 次迭代，包含大量真实的 Bug 修复
4. 安全加固：经过多轮安全审计，体现工业级实践
5. 学完即用：完全可以二次开发成毕业设计或商业项目

全书结构#

本书分为 4 大部分共 19 章 + 附录，循序渐进：

如何下载本项目代码#

1
# 1. 克隆项目
2
git clone https://github.com/Xinghe-0203/Campus_Blog.git
3

4
# 2. 进入项目目录
5
cd Campus_Blog
6

7
# 3. 复制环境变量模板（重要！）
8
cp .env.example .env
9

10
# 4. 编辑 .env 文件，填入你的数据库密码等
11

12
# 5. 构建项目
13
mvn clean package
14

15
# 6. 运行项目
16
mvn spring-boot:run

详细的环境搭建、IDE 配置、数据库初始化步骤，都在第 2 章中详细讲解。

致谢#

感谢你选择这本书。希望读完这本书的你，能从一个完全的零基础小白，蜕变成一个能独立写出 Spring Boot 项目的后端开发者。

如果你在阅读中遇到任何问题，或者发现书中错误，欢迎在 GitHub 项目中提 Issue。

学习编程没有捷径，但有最适合你的路径。

这本书，就是为零基础的你，定制的那条路径。

让我们开始吧！🚀

第一部分 入门基础#

项目案例：校园博客论坛系统（Campus Blog Forum） 配套代码：D:\MyCode\edu_project 适合人群：零基础完全没接触过 Java 和后端开发的小白

这本书是给谁看的#

这本书是写给完全零基础的同学的。我假设你：

• 没写过一行 Java 代码
• 不知道什么是 IDE、什么是 Maven
• 没听说过 Spring Boot
• 但是会开电脑、会用浏览器、会复制粘贴 😄

如果你已经是有经验的开发者，这本书的前几章对你来说可能会显得啰嗦，可以快速翻过去，直接从后面 Spring Boot 的部分开始读。

学完后你能掌握什么#

读完整本书（包括后续部分），并且亲手把每一个例子敲一遍之后，你将能够：

1. 独立看懂中等规模的 Spring Boot 项目源码
2. 自己从零搭建一个 Spring Boot 后端工程
3. 编写 RESTful API（也就是手机 App、网页前端调用的”接口”）
4. 操作 MySQL 数据库，写出增删改查功能
5. 实现用户登录、权限控制、JWT 认证
6. 看懂我们这个真实的”校园博客论坛系统”项目，并且能在它的基础上继续添加自己的功能

学习路径建议#

⚠️ 请务必遵守这条建议：边读边敲代码！

我知道很多人喜欢把书”看完再说”，看完之后觉得自己懂了，结果一上手就抓瞎。学编程没有捷径，你必须把代码亲手敲一遍——不是复制粘贴，是一个字符一个字符地敲。

为什么？因为你的手指在敲键盘的时候，会犯各种错误：拼错单词、忘记分号、括号不匹配……这些错误就是你成长的养料。每一个 bug 都会教你一个知识点。

建议节奏：

1️⃣ 每天学 1 ~ 2 章，不要贪多 2️⃣ 每个例子都敲一遍并跑起来 3️⃣ 出错了先自己查（先看报错信息），实在不会再问 AI 或同学 4️⃣ 学完一章用自己的话复述一遍

本项目简介#

我们的案例项目叫 校园博客论坛系统（Campus Blog Forum）。它是一个真实可运行、能部署上线的项目，包含以下功能：

• 用户注册、登录、JWT 认证
• 发帖、评论、嵌套回复
• 点赞、收藏、关注
• 通知系统
• 校友圈（类似微博）
• 媒体上传（图片、视频）
• 热度统计、举报管理
• 等等……

数据库一共 18 张表，技术栈是 Spring Boot 3.0.12 + MyBatis Plus 3.5.5 + Spring Security + JWT + MySQL，JDK 用 21+。是不是听上去很厉害？别怕，等你读完这本书，回过头看会觉得”也就那么回事”。

学习心态#

最后说一句最重要的话：

技术不难，难的是耐心。

你会遇到环境装不上、Maven 下载不动、Lombok 不生效、数据库连不上、莫名其妙的红线……这些都是所有程序员的日常。不要怀疑自己笨，没人天生就会，所有”大佬”都是从看到红色报错就慌张开始的。

放轻松，慢慢来。准备好了？我们开始吧 🚀

1.1 Java 是什么、能做什么#

Java 是一门 编程语言（Programming Language）。所谓编程语言，就是人类用来”指挥”电脑做事的一种特殊语言。中文是用来跟人说话的，Java 是用来跟电脑说话的。

🌰 一个生活类比：

• 你想让一个外国朋友帮你买杯奶茶，你得用他能听懂的语言（比如英语）告诉他怎么走、要点什么。
• 你想让电脑帮你处理数据、显示网页，你也得用电脑能听懂的语言（比如 Java）告诉它步骤。

Java 由 Sun 公司在 1995 年发布，现在归 Oracle 所有。它最大的特点是 “一次编写，到处运行（Write Once, Run Anywhere）” —— 你写的同一段 Java 代码，可以在 Windows、Mac、Linux、安卓手机上都跑起来。这是怎么做到的？因为 Java 不是直接给电脑硬件看的，它是给一个叫 JVM（Java Virtual Machine，Java 虚拟机） 的”翻译官”看的，每个操作系统上都有自己版本的 JVM。

Java 能做什么？非常多：

我们这本书重点讲的是 后端服务器开发，也就是给网页和手机 App 提供数据的”幕后英雄”。

1.2 第一个 Java 程序 HelloWorld#

按照编程界的传统，学任何新语言第一个程序都叫 “Hello World”（你好，世界）。我们也不能免俗：

1
public class HelloWorld {
2
    public static void main(String[] args) {
3
        System.out.println("Hello, World!");
4
    }
5
}

跑起来后屏幕会显示：

1
Hello, World!

看起来简单，其实里面信息量很大。我们一行一行拆解：

⚠️ 几个零基础最容易忽略的细节：

1. Java 严格区分大小写：Main 和 main 是两个完全不同的东西
2. 文件名必须叫 HelloWorld.java，必须和 public class 后面的名字完全一致
3. 每条语句都必须以 ; 结束，少一个就会编译失败
4. 大括号 {} 必须配对，少一个也会失败

为什么必须有 main 方法？因为 JVM 启动时只认它，类似于一栋楼必须有大门口。所有 Java 应用程序都从 main 开始执行。String[] args 是命令行参数（一般用不到），先不用管。

System.out.println 中：

• System 是 Java 自带的一个系统工具类
• out 是它里面的”输出”对象
• println 是”打印一行（print line）“的意思，会自动换行

如果你只想打印不换行，用 System.out.print 就行。

1.3 变量与数据类型#

变量（Variable） 是程序里存数据的”盒子”。盒子上贴个标签（变量名），盒子里放东西（值）。

1
int age = 20;
2
String name = "刘畅";
3
boolean isStudent = true;
4
double price = 19.9;
5
long bigNumber = 99999999999L;

逐行解释：

• int age = 20; —— 我准备一个名叫 age 的盒子，规定只能放整数（int），里面放了 20。
• String name = "刘畅"; —— 一个名叫 name 的盒子，放字符串，内容是 “刘畅”。
• boolean isStudent = true; —— 布尔盒子，只能装 true 或 false（是或否）。
• double price = 19.9; —— 装小数的盒子。
• long bigNumber = 99999999999L; —— 装超大整数的盒子，注意末尾的 L，告诉编译器这是 long 类型。

Java 的常用基本数据类型一览：

⚠️ 注意 String 不是基本类型，它是类（Class），所以首字母大写。我们项目里几乎所有的”文字”都用 String。

类比一下：

• int 像一个小号文件柜（只能放整数文件夹）
• String 像一个大号档案盒（能放各种长度的文字资料）
• 给变量赋值 = 把东西塞进盒子
• 读取变量 = 看盒子里有什么

1.4 控制流：if/else、for、while、switch#

程序如果只是从上往下执行，能做的事情就太少了。控制流（Control Flow） 让程序可以根据条件判断、循环执行。

1
int score = 85;
2
if (score >= 90) {
3
    System.out.println("优秀");
4
} else if (score >= 60) {
5
    System.out.println("及格");
6
} else {
7
    System.out.println("不及格");
8
}

1
for (int i = 1; i <= 5; i++) {
2
    System.out.println("第 " + i + " 次打印");
3
}

1
第 1 次打印
2
第 2 次打印
3
第 3 次打印
4
第 4 次打印
5
第 5 次打印

1
int count = 0;
2
while (count < 3) {
3
    System.out.println("当前 count = " + count);
4
    count++;
5
}

1
int day = 3;
2
switch (day) {
3
    case 1: System.out.println("周一"); break;
4
    case 2: System.out.println("周二"); break;
5
    case 3: System.out.println("周三"); break;
6
    default: System.out.println("其他");
7
}

1.5 类和对象（重点！）#

这是 Java 的核心概念，也是零基础最难的一关。请反复读这一节。

1
public class SysUser {
2
    // 字段（属性）：每个用户都有这些信息
3
    private Long id;
4
    private String username;
5
    private String password;
6
    private Integer age;
7

8
    // 方法（行为）：用户能做的事
9
    public void sayHello() {
10
        System.out.println("大家好，我是 " + username);
11
    }
12

13
    // Getter / Setter（读写字段）
14
    public String getUsername() { return username; }
15
    public void setUsername(String username) { this.username = username; }
16
}

1
public class Test {
2
    public static void main(String[] args) {
3
        // new 关键字 = 用模子铸造一个新对象
4
        SysUser user1 = new SysUser();
5
        user1.setUsername("张三");
6

7
        SysUser user2 = new SysUser();
8
        user2.setUsername("李四");
9

10
        user1.sayHello();  // 输出：大家好，我是 张三
11
        user2.sayHello();  // 输出：大家好，我是 李四
12
    }
13
}

1.6 方法：参数、返回值、重载#

方法（Method） 就是一段可以重复使用的代码块，类似数学里的函数。

1
public int add(int a, int b) {
2
    return a + b;
3
}

拆解：

调用：

1
int sum = add(3, 5);  // sum = 8

1
public void printHello() {
2
    System.out.println("Hello");
3
}

1
public int add(int a, int b) { return a + b; }
2
public double add(double a, double b) { return a + b; }
3
public int add(int a, int b, int c) { return a + b + c; }

1.7 集合：List 和 Map#

集合（Collection） 就是装多个数据的容器。最常用的两种：

1
import java.util.ArrayList;
2
import java.util.List;
3

4
List<String> users = new ArrayList<>();
5
users.add("张三");
6
users.add("李四");
7
users.add("王五");
8

9
System.out.println(users.get(0));  // 张三
10
System.out.println(users.size());  // 3

1
import java.util.HashMap;
2
import java.util.Map;
3

4
Map<String, Object> userInfo = new HashMap<>();
5
userInfo.put("username", "张三");
6
userInfo.put("age", 20);
7
userInfo.put("isStudent", true);
8

9
System.out.println(userInfo.get("username"));  // 张三

1.8 异常处理 try-catch#

程序运行时可能会出错，比如：除以 0、读取一个不存在的文件、网络断开。这些情况叫 异常（Exception）。

🌰 类比：你正在烧开水，突然停电了。如果不处理，整个程序会”崩溃退出”。处理它的方式就是 try-catch：

1
try {
2
    int result = 10 / 0;  // 这行会抛异常
3
    System.out.println("永远不会执行到这里");
4
} catch (ArithmeticException e) {
5
    System.out.println("出错了：" + e.getMessage());
6
} finally {
7
    System.out.println("不管出不出错，这里都会执行");
8
}

我们项目里有个 全局异常处理器 GlobalExceptionHandler，所有 Controller 抛出的异常都会被它统一捕获并返回友好的错误信息。这样我们 Controller 里只管写正常逻辑，出错的事交给它就行。

1.9 注解（Annotation）是什么#

注解（Annotation） 是一种”标签”，放在类、方法、字段头上，告诉编译器或框架”我有特殊用途”。

最常见的内置注解 @Override：

1
@Override
2
public String toString() {
3
    return "我是一个用户对象";
4
}

@Override 表示”我重写了父类的方法”。如果你拼错了方法名，编译器会报错提醒你。

Spring Boot 大量使用注解，看一眼我们项目的启动类（来自 EduProjectApplication.java）：

1
@SpringBootApplication(exclude = {
2
    SecurityAutoConfiguration.class,
3
    UserDetailsServiceAutoConfiguration.class
4
})
5
@Import(SecurityConfig.class)
6
@EnableScheduling
7
public class EduProjectApplication {
8
    ...
9
}

这里就有 @SpringBootApplication、@Import、@EnableScheduling 三个注解，每个都对应一种”功能开关”。第 4 章会详细讲。

🎯 现在你只要记住一句话：注解 = 框架用的标签，告诉框架”我是个特殊角色”。

1.10 包和导入 import#

当代码量多了，几百个 Java 文件挤在一起会乱套，所以 Java 用 包（Package） 来分组，类似文件夹。

1
package com.example.edu_project.entity;

这一行说”我这个文件属于 com.example.edu_project.entity 包”。对应到磁盘上的目录就是：

1
src/main/java/com/example/edu_project/entity/

要使用别的包里的类，得先 import：

1
import java.util.List;
2
import java.util.ArrayList;
3
import com.example.edu_project.entity.SysUser;

⚠️ 包名习惯用全小写，并且采用”反向域名”风格（com.公司.项目.模块），保证全球唯一。我们项目所有代码都在 com.example.edu_project 这个根包下。

学完第 1 章，你已经掌握了 Java 语言的基本骨架。接下来我们要把”工具”装到电脑上，让代码能跑起来。

2.1 安装 JDK 21#

JDK（Java Development Kit） 是 Java 开发工具包，包含编译器、JVM 等。我们项目要求 JDK 21（在 pom.xml 里看到 <java.version>21</java.version>）。

1
java -version
2
javac -version

1
java version "21.0.2" 2024-01-16 LTS
2
javac 21.0.2

2.2 安装 IntelliJ IDEA#

IDE（Integrated Development Environment，集成开发环境） 是写代码的”超级记事本”，自带智能提示、自动补全、调试器等。Java 后端开发首选 IntelliJ IDEA。

下载地址：https://www.jetbrains.com/idea/download/

2.3 安装 Lombok 插件#

Lombok 是一个神奇的工具，能自动帮你生成 getter / setter / 构造函数等”模板代码”。我们项目大量使用它（pom.xml 里能看到 lombok 1.18.40 依赖）。

IDEA 在新版本里已经内置 Lombok 插件，无需手动安装。但你需要确保它启用了：

1. File → Settings → Plugins
2. 搜索 “Lombok”，确认状态是 Enabled

2.4 启用注解处理器（关键！）#

⚠️ 这一步如果忘了，整个项目会爆红，所有 @Data、@Getter 都不生效！

操作步骤：

1️⃣ File → Settings 2️⃣ 搜索 “Annotation Processors” 3️⃣ 找到 “Build, Execution, Deployment → Compiler → Annotation Processors” 4️⃣ 勾选 ✅ Enable annotation processing 5️⃣ 点 OK 保存

这一步告诉 IDEA：“请在编译时运行 Lombok 的注解处理器，自动帮我生成代码。“

2.5 安装并配置 Maven#

IDEA 自带了 Maven，可以先用着。如果你想自己装：

1. 下载 Maven：https://maven.apache.org/download.cgi
2. 解压到 D:\apache-maven-3.9.x
3. 配置环境变量 MAVEN_HOME = D:\apache-maven-3.9.x
4. 在 Path 里添加 %MAVEN_HOME%\bin
5. 验证：mvn -version

1
<settings>
2
  <mirrors>
3
    <mirror>
4
      <id>aliyunmaven</id>
5
      <mirrorOf>*</mirrorOf>
6
      <name>阿里云公共仓库</name>
7
      <url>https://maven.aliyun.com/repository/public</url>
8
    </mirror>
9
  </mirrors>
10
</settings>

2.6 安装 MySQL 8 + 创建数据库#

我们项目用的是 MySQL 8.x。

1
mysql -u root -p

1
CREATE DATABASE campus_blog DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
2
CREATE USER 'campus_blog'@'%' IDENTIFIED BY 'your_password_here';
3
GRANT ALL PRIVILEGES ON campus_blog.* TO 'campus_blog'@'%';
4
FLUSH PRIVILEGES;

2.7 安装数据库可视化工具#

光用命令行操作 MySQL 太累，我们要装个可视化工具：

如果你用 IDEA 专业版，直接用右侧的 “Database” 面板：

1. 点 + → Data Source → MySQL
2. 填 Host、Port (3306)、User、Password、Database (campus_blog)
3. 点 Test Connection
4. 第一次会让你下载 driver，点 Download

成功后你能在面板里看到所有表、字段，能直接写 SQL 查询。

2.8 验证整套环境#

我们用一个最小项目把流程跑通。打开 IDEA：

1️⃣ New Project → 选 Maven，JDK 选 21 2️⃣ GroupId: com.test, ArtifactId: hello-test 3️⃣ 创建后等 Maven 下载完依赖 4️⃣ 在 src/main/java 下新建 com.test.HelloApp 类：

1
package com.test;
2

3
public class HelloApp {
4
    public static void main(String[] args) {
5
        System.out.println("环境装好啦！🎉");
6
    }
7
}

5️⃣ 右键 → Run ‘HelloApp.main()’ 6️⃣ 看到底部控制台输出 “环境装好啦！🎉” 就成功了

2.9 常见环境问题排查#

零基础最容易踩的坑：

环境装好了，恭喜你迈过最痛苦的一关 💪 接下来我们认识 Maven 和项目结构。

3.1 Maven 是什么#

Maven 是一个 项目构建和依赖管理工具。这句话翻译成人话：

• 依赖管理：你想用别人写好的库（比如 Spring Boot、MySQL 驱动），不用自己去网上找 jar 包，只要在 pom.xml 里写一行配置，Maven 自动帮你下载。
• 项目构建：编译、打包、运行测试，一行命令搞定。

🌰 类比：

它们都在做同一件事：管理项目用到的”积木块”。

3.2 pom.xml 文件结构详解#

pom.xml 是 Maven 项目的”身份证”，POM = Project Object Model（项目对象模型）。我们看一下我们项目的实际 pom.xml（节选）：

1
<project xmlns="http://maven.apache.org/POM/4.0.0" ...>
2
    <modelVersion>4.0.0</modelVersion>
3

4
    <parent>
5
        <groupId>org.springframework.boot</groupId>
6
        <artifactId>spring-boot-starter-parent</artifactId>
7
        <version>3.0.12</version>
8
        <relativePath/>
9
    </parent>
10

11
    <groupId>com.example</groupId>
12
    <artifactId>edu_project</artifactId>
13
    <version>0.0.1-SNAPSHOT</version>
14
    <name>edu_project</name>
15
    <description>校园博客论坛系统 - 后端</description>
16

17
    <properties>
18
        <java.version>21</java.version>
19
        <mybatis-plus.version>3.5.5</mybatis-plus.version>
20
        ...
21
    </properties>
22

23
    <dependencies>
24
        ...
25
    </dependencies>
26
</project>

骨架解读：

3.3 依赖管理：groupId / artifactId / version#

每个 Java 库都用三个坐标唯一标识，叫 GAV（GroupId-ArtifactId-Version）：

1
<dependency>
2
    <groupId>com.baomidou</groupId>
3
    <artifactId>mybatis-plus-boot-starter</artifactId>
4
    <version>3.5.5</version>
5
</dependency>

这三行说：“我要 baomidou 公司开发的、名为 mybatis-plus-boot-starter 的、3.5.5 版本的库。”

Maven 拿到这个坐标后，会去仓库（阿里云镜像）找对应的 jar 包，下载到你电脑的 ~/.m2/repository/ 目录里。

🌰 类比：GAV 就像快递地址：

• groupId = 城市
• artifactId = 街道+门牌号
• version = 具体楼层

3.4 父工程 spring-boot-starter-parent#

1
<parent>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-parent</artifactId>
4
    <version>3.0.12</version>
5
</parent>

这一段表示我们继承了 Spring Boot 的父工程。继承的好处是：

1. 版本统一：父工程已经规定好了几百个常用库的版本，我们写依赖时可以省略 version，直接用父工程的版本。
2. 配置统一：编码、JDK 版本、插件版本都已经默认好了。

类比一下：父工程像”一份大礼包套餐”，里面所有东西都已经搭配好。你只要从套餐里”挑你想要的”，不用自己一个个调味。

3.5 starter 启动器#

Spring Boot 有一个超棒的发明叫 starter（启动器）。

看我们项目里的：

1
<dependency>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-web</artifactId>
4
</dependency>

这个 spring-boot-starter-web 实际上是个 “全家桶”：

• Spring MVC
• Tomcat（内置 Web 服务器）
• Jackson（JSON 处理）
• 几十个常用 Web 依赖

只引一个 starter，就把做 Web 开发的所有东西都备齐了，太爽了。

我们项目用到的主要 starter：

3.6 标准的 Maven 项目目录结构#

1
edu_project/
2
├── pom.xml                  ← Maven 配置
3
├── src/
4
│   ├── main/
5
│   │   ├── java/            ← Java 源代码
6
│   │   │   └── com/example/edu_project/
7
│   │   └── resources/       ← 配置文件、静态资源
8
│   │       ├── application.yml
9
│   │       └── mapper/      ← MyBatis XML
10
│   └── test/
11
│       └── java/            ← 测试代码
12
└── target/                  ← 编译输出（自动生成，不要手动改）

牢记 3 大区域：

3.7 解读本项目的目录结构#

打开 D:\MyCode\edu_project\src\main\java\com\example\edu_project\ 你会看到：

1
edu_project/
2
├── controller/   ← 控制器层（接收 HTTP 请求）
3
├── service/      ← 业务逻辑层
4
│   └── impl/
5
├── mapper/       ← 数据库访问层
6
├── entity/       ← 实体类（对应数据库表）
7
├── dto/          ← Data Transfer Object（接收前端传来的数据）
8
├── vo/           ← View Object（返回给前端的数据）
9
├── config/       ← 配置类
10
├── common/       ← 公共类（Result、异常等）
11
├── filter/       ← 过滤器
12
├── utils/        ← 工具类
13
└── EduProjectApplication.java  ← 启动入口

这是经典的 分层架构（Layered Architecture）。请求流向：

1
浏览器 → Controller → Service → Mapper → MySQL

各层职责一句话总结：

3.8 常用 Maven 命令#

在项目根目录打开终端，可以用这些命令：

我们项目实际上线时通常是：

1
mvn clean package -DskipTests
2
java -jar target/edu_project-0.0.1-SNAPSHOT.jar

第一行打成 jar（跳过测试节省时间），第二行用 java 启动。

讲完了 Maven，你应该对”项目”有了整体感。最后一章我们正式见识 Spring Boot。

4.1 Spring 框架家族介绍#

我们经常听到的几个名字，关系是这样的：

1
Spring Framework （地基）
2
   └─ Spring Boot （脚手架，让搭楼变快）
3
        └─ Spring Cloud （微服务集群方案）

我们这本书学的是 Spring Boot，因为它已经够用并且最受欢迎。

4.2 Spring Boot 的”约定大于配置”理念#

老 Spring 时代，要做一个 Web 项目你得写几百行 XML 配置：哪个文件夹放代码、用什么数据库连接池、JSON 怎么序列化……非常痛苦。

Spring Boot 提出了 “约定大于配置（Convention over Configuration）”：

我们已经帮你想好了 99% 场景的最佳实践，你啥都不写就能用；只有特殊需求时再覆盖默认值。

举个例子：你引了 spring-boot-starter-web，Spring Boot 自动：

• 启动一个 Tomcat 服务器（端口 8080）
• 配置 JSON 序列化
• 配置静态资源目录
• 配置错误页面

你只要写 Controller 就行了，相比老 Spring 节省了 90% 的配置工作。

4.3 启动类 EduProjectApplication 详解#

打开 D:\MyCode\edu_project\src\main\java\com\example\edu_project\EduProjectApplication.java：

1
package com.example.edu_project;
2

3
import com.example.edu_project.config.DotenvConfig;
4
import org.slf4j.Logger;
5
import org.slf4j.LoggerFactory;
6
import org.springframework.boot.SpringApplication;
7
import org.springframework.boot.autoconfigure.SpringBootApplication;
8
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
9
import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration;
10
import org.springframework.context.annotation.Import;
11
import org.springframework.scheduling.annotation.EnableScheduling;
12
import com.example.edu_project.config.SecurityConfig;
13

14
@SpringBootApplication(exclude = {
15
    SecurityAutoConfiguration.class,
16
    UserDetailsServiceAutoConfiguration.class
17
})
18
@Import(SecurityConfig.class)
19
@EnableScheduling
20
public class EduProjectApplication {
21

22
    private static final Logger log = LoggerFactory.getLogger(EduProjectApplication.class);
23

24
    public static void main(String[] args) {
25
        DotenvConfig.load();
26
        log.info("========================================");
27
        SpringApplication.run(EduProjectApplication.class, args);
28
        log.info("   校园博客论坛系统启动成功！");
29
        log.info("   API文档地址：http://localhost:8825/api/doc.html");
30
        log.info("========================================");
31
    }
32
}

逐段解读：

1
DotenvConfig.load();
2
SpringApplication.run(EduProjectApplication.class, args);

4.4 application.yml 配置文件解读#

src/main/resources/application.yml 是 Spring Boot 主配置文件。我们的实际配置（节选）：

1
spring:
2
  application:
3
    name: campus-blog-forum
4

5
  datasource:
6
    driver-class-name: com.mysql.cj.jdbc.Driver
7
    url: jdbc:mysql://${DB_HOST}:${DB_PORT}/${DB_NAME}?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
8
    username: ${DB_USERNAME}
9
    password: ${DB_PASSWORD}
10
    hikari:
11
      minimum-idle: 5
12
      maximum-pool-size: 20
13
      pool-name: CampusBlogHikariCP
14

15
mybatis-plus:
16
  mapper-locations: classpath*:/mapper/**/*.xml
17
  global-config:
18
    db-config:
19
      id-type: auto
20
      logic-delete-field: isDeleted
21
      logic-delete-value: 1
22
      logic-not-delete-value: 0
23

24
server:
25
  port: ${SERVER_PORT:8825}
26
  servlet:
27
    context-path: /api
28

29
jwt:
30
  secret: ${JWT_SECRET}
31
  expiration: ${JWT_EXPIRATION}
32
  refresh-expiration: ${JWT_REFRESH_EXPIRATION}

关键点表格：

⚠️ 注意 YAML 格式：

• 用 空格 缩进，绝对不能用 Tab！
• 冒号后面要有 一个空格
• 同一层级的字段缩进要一致

1
DB_HOST=IP
2
DB_PORT=3306
3
DB_NAME=campus_blog
4
DB_USERNAME=campus_blog
5
DB_PASSWORD=your_database_password_here
6
JWT_SECRET=your_jwt_secret_key_here_minimum_32_characters
7
JWT_EXPIRATION=86400000
8
JWT_REFRESH_EXPIRATION=604800000
9
SERVER_PORT=8825

4.5 第一个 RestController 示例#

让我们写一个简单接口感受 Spring Boot 的魅力：

1
package com.example.edu_project.controller;
2

3
import org.springframework.web.bind.annotation.GetMapping;
4
import org.springframework.web.bind.annotation.RequestParam;
5
import org.springframework.web.bind.annotation.RestController;
6

7
@RestController
8
public class HelloController {
9

10
    @GetMapping("/hello")
11
    public String hello(@RequestParam(defaultValue = "World") String name) {
12
        return "Hello, " + name + "! 欢迎来到校园博客论坛 🎉";
13
    }
14
}

代码解析：

启动项目后，浏览器访问：

1
http://localhost:8825/api/hello
2
http://localhost:8825/api/hello?name=刘畅

注意路径是 /api/hello 而不是 /hello，因为我们在 yml 里设了 context-path: /api。

4.6 项目运行：mvn spring-boot vs java -jar#

两种运行方式对比：

打包后的 jar 文件叫 fat jar（胖 jar），里面已经把 Tomcat 都打进去了，部署到任何装了 Java 21 的机器上都能跑：

1
java -jar edu_project-0.0.1-SNAPSHOT.jar

✨ 这就是 Spring Boot 最爽的特性：不需要单独装 Tomcat！

4.7 访问地址 & Knife4j 文档#

启动成功后，你能访问以下地址：

1
浏览器访问 http://localhost:8825/api/posts
2
   ↓
3
Tomcat 接收请求
4
   ↓
5
Spring 路由到 PostController
6
   ↓
7
PostController 调 PostService
8
   ↓
9
PostService 调 PostMapper
10
   ↓
11
MyBatis Plus 生成 SQL，访问 MySQL
12
   ↓
13
查到数据 → 一路返回 → 序列化成 JSON
14
   ↓
15
前端拿到结果显示

第一部分小结#

🎉 恭喜你读完了第一部分！让我们回顾一下：

1️⃣ 第 1 章 学了 Java 语言基础：变量、控制流、类与对象、集合、异常、注解、包 2️⃣ 第 2 章 装好了开发环境：JDK 21、IDEA、Lombok、Maven、MySQL 3️⃣ 第 3 章 认识了 Maven 和我们项目的目录结构 4️⃣ 第 4 章 第一次接触 Spring Boot：启动类、yml 配置、写了一个 hello 接口

到这里你应该能：

• 看懂 Java 基本语法
• 把项目跑起来
• 写出最简单的 GET 接口
• 看懂项目的整体架构

接下来在第二部分，我们会深入 Controller、Service、Mapper 的写法，开始真正动手开发”用户注册登录”这样的实际功能。

请休息一下，喝杯水，做几个深呼吸，然后我们继续 💪

记住开发荣耻第一条：以瞎清接口为耻，以认真查询为荣。 写代码不是在炫技，是在认真解决问题。慢就是快。

下一部分见！

第二部分 框架核心#

案例项目：校园博客论坛系统（Campus Blog） 适合人群：完全没有 Java Web 经验的初学者 写作原则：每个概念都有比喻、每段代码都来自真实项目

5.1 ORM 思想：类↔表，对象↔行#

刚开始接触 Java Web 的朋友，最容易卡住的地方就是”数据库 SQL”和”Java 代码”之间的鸿沟。数据库里有一张表，比如 sys_user，它有 id、username、password 这些列。Java 程序里有一个类，比如 SysUser，它有 id、username、password 这些字段。它们看起来是一回事，但底层完全不同：一个是关系型数据库的二维表，一个是 JVM 内存里的对象。

ORM（Object-Relational Mapping，对象关系映射）就是把这两个世界连起来的”翻译官”。它的核心思想可以用一个比喻来理解：

把数据库表想象成一个 Excel 表格。 表的”表头”（列名）= Java 类里的”字段名”。 表的”每一行”= Java 里的”一个对象”。 你在 Java 里 new SysUser()，就好比在 Excel 里新增一行；你给对象的字段赋值，就好比往单元格里填数据；最后你保存对象到数据库，就好比把这一行写到 Excel 里。

有了 ORM，你就不用一直手写 INSERT INTO sys_user (username, password) VALUES (?, ?) 这种 SQL 了。框架会替你拼 SQL、执行、把结果集映射回 Java 对象。

ORM 的三组对应关系一定要牢记：

5.2 MyBatis 与 MyBatis Plus 的区别#

MyBatis 是国内最流行的 ORM 框架之一，特点是”半自动”：你写 SQL，它帮你映射结果。但即便是简单的 CRUD（增删改查），也得写一堆 XML 或注解 SQL，重复且枯燥。

MyBatis Plus（简称 MP）是在 MyBatis 之上做的”增强工具”，特点是”全自动 + 可扩展”：

• 简单的 CRUD（按 ID 查、新增、更新、删除、分页）：完全不用写 SQL，框架自动生成。
• 复杂的业务 SQL：你照样可以用 MyBatis 的 @Select、XML 写自定义 SQL，两种方式无缝共存。

形象比喻：MyBatis 像一台手动挡汽车，所有挡位都得自己换；MyBatis Plus 则像自动挡，普通路况自动操作，遇到山路你可以切手动模式。

本项目的 pom.xml 里引入的就是 MyBatis Plus 3.5.5，整个项目几乎所有简单 CRUD 都没有写一行 SQL，全靠框架生成。

5.3 实体类的关键注解（基于真实代码）#

实体类（Entity）是 ORM 里”表”的 Java 化身。我们以本项目的 SysUser.java 为例（路径：src/main/java/com/example/edu_project/entity/SysUser.java）：

1
@Data
2
@TableName("sys_user")
3
public class SysUser implements Serializable {
4

5
    @TableId(type = IdType.AUTO)
6
    private Long id;
7

8
    private String username;
9

10
    @JsonIgnore
11
    private String password;
12

13
    private String nickname;
14
    private String avatar;
15
    private String email;
16
    private String role;
17
    private Integer status;
18

19
    @TableField(fill = FieldFill.INSERT)
20
    private Integer loginFailCount;
21

22
    private LocalDateTime lockUntil;
23

24
    @TableField(fill = FieldFill.INSERT)
25
    private LocalDateTime createTime;
26

27
    @TableField(fill = FieldFill.INSERT_UPDATE)
28
    private LocalDateTime updateTime;
29

30
    @TableLogic
31
    private Integer isDeleted;
32
}

这里出现的注解，是你今后每写一个实体类都会用到的”四大金刚”：

1
@Data
2
@TableName("blog_post")
3
public class BlogPost implements Serializable {
4
    @TableId(type = IdType.AUTO)
5
    private Long id;
6
    private Long userId;
7
    private String title;
8
    private String content;
9
    private Integer viewCount;
10
    private Integer likeCount;
11
    @TableField(fill = FieldFill.INSERT)
12
    private LocalDateTime createTime;
13
    @TableField(fill = FieldFill.INSERT_UPDATE)
14
    private LocalDateTime updateTime;
15
    @TableLogic
16
    private Integer isDeleted;
17
}

5.4 BaseMapper 内置方法#

写好实体类后，下一步就是 Mapper 接口。看本项目的 SysUserMapper.java：

1
@Mapper
2
public interface SysUserMapper extends BaseMapper<SysUser> {
3
    // 自定义 SQL 方法...
4
}

@Mapper 告诉 MyBatis 这是一个 Mapper 接口，需要被扫描；extends BaseMapper<SysUser> 一句话就让你”白嫖”了所有 CRUD 方法。BaseMapper 里到底有哪些方法？常用的有：

⚠️ 看清楚：你只是写了一个继承 BaseMapper 的空接口，就拥有了上面所有方法！这就是 MP 让人爱不释手的地方。

5.5 自动填充机制#

新增和更新数据时，每次都要手动 setCreateTime(LocalDateTime.now())、setUpdateTime(LocalDateTime.now()) 吗？太累。MP 提供了”自动填充”机制，本项目里通过 MyMetaObjectHandler.java 实现：

1
@Slf4j
2
@Component
3
public class MyMetaObjectHandler implements MetaObjectHandler {
4

5
    @Override
6
    public void insertFill(MetaObject metaObject) {
7
        log.info("开始插入填充...");
8
        this.strictInsertFill(metaObject, "createTime", LocalDateTime::now, LocalDateTime.class);
9
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
10
    }
11

12
    @Override
13
    public void updateFill(MetaObject metaObject) {
14
        log.info("开始更新填充...");
15
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
16
    }
17
}

它的工作原理：

1. 任何实体类的字段加上 @TableField(fill = FieldFill.INSERT)，新增时框架会触发 insertFill 方法。
2. 任何字段加上 @TableField(fill = FieldFill.INSERT_UPDATE)，新增和更新时都会触发 updateFill 方法。
3. strictInsertFill 是”严格模式”，只在字段为 null 时才填，已经有值则不覆盖。
4. LocalDateTime::now 是 Java 的方法引用，等价于 () -> LocalDateTime.now()。

效果就是：你 service 层写 userService.save(user) 时根本不用管时间，MP 会自动给 createTime 和 updateTime 塞值。

5.6 逻辑删除：@TableLogic + isDeleted#

前面已经提过，这里再深入一点。本项目所有业务表都有 isDeleted 字段（0=正常，1=已删除），加了 @TableLogic。它的好处：

• 误删可恢复：把 is_deleted 改回 0 即可。
• 历史可追溯：删除的数据仍在表里，可用于审计。
• 软删 + 关联表保护：避免外键级联删除带来的不可控影响。

application.yml 里通常会有全局配置：

1
mybatis-plus:
2
  global-config:
3
    db-config:
4
      logic-delete-field: isDeleted   # 全局逻辑删除字段
5
      logic-delete-value: 1           # 已删除值
6
      logic-not-delete-value: 0       # 未删除值

这样后续就算不在每个实体类上写 @TableLogic，只要字段名叫 isDeleted，也会自动生效。

5.7 分页插件（基于 MybatisPlusConfig.java）#

MP 默认没开启分页，需要手动注册一个分页拦截器。本项目的配置类：

1
@Configuration
2
@MapperScan("com.example.edu_project.mapper")
3
public class MybatisPlusConfig {
4

5
    @Bean
6
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
7
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
8
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
9
        return interceptor;
10
    }
11
}

两个关键点：

1. @MapperScan("com.example.edu_project.mapper")：告诉 Spring 扫描这个包下所有 Mapper 接口，自动生成代理实现。
2. PaginationInnerInterceptor(DbType.MYSQL)：为 MySQL 注入分页 SQL 改写能力。

启用后你就能这样写：

1
Page<SysUser> page = new Page<>(1, 10); // 第 1 页，每页 10 条
2
IPage<SysUser> result = userMapper.selectPage(page, wrapper);
3
result.getRecords();    // 当前页数据
4
result.getTotal();      // 总记录数
5
result.getPages();      // 总页数

底层 SQL 框架会自动给你拼成：SELECT ... FROM sys_user ... LIMIT 0, 10，并额外执行 SELECT count(*) ... 求总数。

本项目 SysUserServiceImpl.searchUsers 方法就是这样用的：

1
Page<SysUser> page = new Page<>(request.getPage(), request.getPageSize());
2
LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
3
if (request.getKeyword() != null && !request.getKeyword().trim().isEmpty()) {
4
    String keyword = request.getKeyword().trim();
5
    wrapper.and(w -> w.like(SysUser::getUsername, keyword)
6
            .or()
7
            .like(SysUser::getNickname, keyword));
8
}
9
wrapper.orderByDesc(SysUser::getCreateTime);
10
IPage<SysUser> userPage = this.page(page, wrapper);

5.8 LambdaQueryWrapper 条件构造器#

Wrapper 是 MP 用来构造 WHERE 条件的工具，相当于”用 Java 写 SQL 的 WHERE 部分”。最推荐的版本是 LambdaQueryWrapper，因为它用方法引用 SysUser::getUsername 代替字符串 "username"，编译期能检查字段名拼写错误。

常见 API：

在本项目登录接口里就有典型用法：

1
LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
2
wrapper.eq(SysUser::getUsername, request.getUsername());
3
SysUser user = this.getOne(wrapper);

5.9 自定义 SQL：@Update 注解或 XML#

简单 CRUD 用 BaseMapper 就够了，但有些场景需要”原子操作”，比如：

• 计数器自增：UPDATE sys_user SET follower_count = follower_count + 1 WHERE id = ?
• 复杂条件更新

本项目的 SysUserMapper 就有大量这样的注解 SQL：

1
@Update("UPDATE sys_user SET login_fail_count = login_fail_count + 1, " +
2
        "lock_until = CASE WHEN login_fail_count + 1 >= #{maxFailCount} " +
3
        "THEN DATE_ADD(NOW(), INTERVAL #{lockMinutes} MINUTE) ELSE lock_until END " +
4
        "WHERE id = #{userId} AND (lock_until IS NULL OR lock_until <= NOW())")
5
int incrementLoginFailCount(@Param("userId") Long userId,
6
                             @Param("maxFailCount") int maxFailCount,
7
                             @Param("lockMinutes") int lockMinutes);
8

9
@Update("UPDATE sys_user SET follower_count = follower_count + 1 WHERE id = #{userId}")
10
int incrementFollowerCount(@Param("userId") Long userId);

#{xxx} 是 MyBatis 的占位符，会自动 PreparedStatement 化，防止 SQL 注入。@Param 给参数命名以便 SQL 里引用。

⚠️ 这些自增 SQL 在数据库层就保证了原子性，不会出现”100 个人同时点赞，结果计数器只 +1”的并发 Bug。这是数据库层的并发安全，比 Java 层的锁更可靠。

6.1 为什么要分层（饭店比喻）#

想象你去饭店吃饭：

• 服务员（Controller）：接你的菜单订单，告诉厨房要做什么，最后把菜端给你。他不会做菜，只负责沟通。
• 厨师（Service）：真正炒菜的人。他会根据菜单决定先切菜还是先开火，把”做菜”的复杂逻辑封装起来。
• 采购员（Mapper）：去仓库取原料、把原料带回厨房。他不关心怎么烹饪，只管”从数据库拿数据”。
• 食材（Entity）：摆在仓库里的牛肉、青菜，对应数据库表里的一行。

如果让一个人同时干这三件事，会乱套：服务员一边记单一边切菜一边搬蔬菜。所以企业级项目都强制分层，每一层只做自己的事，便于维护、便于测试、便于团队协作。

Spring Boot 项目的标准分层：

1
浏览器 / 前端
2
    ↓ HTTP
3
Controller（控制器）  ← 接请求、返响应
4
    ↓ Java 调用
5
Service（业务层）     ← 业务规则、事务
6
    ↓ Java 调用
7
Mapper（持久层）      ← SQL、与数据库交互
8
    ↓ JDBC
9
MySQL

6.2 Controller 层（基于真实 SysUserController.java）#

Controller 是”接待大厅”。看看本项目的注册接口长什么样：

1
@Tag(name = "用户管理", description = "用户相关接口")
2
@RestController
3
@RequestMapping("/user")
4
public class SysUserController {
5

6
    @Autowired
7
    private SysUserService sysUserService;
8

9
    @Operation(summary = "用户注册")
10
    @PostMapping("/register")
11
    public Result<UserRegisterResponse> register(@Valid @RequestBody UserRegisterRequest request) {
12
        UserRegisterResponse response = sysUserService.register(request);
13
        return Result.success(response);
14
    }
15
}

逐行解读：

• @RestController：等于 @Controller + @ResponseBody，意思是这个类的所有方法直接返回 JSON，不走视图模板。
• @RequestMapping("/user")：这个类下的所有接口都以 /user 开头。
• @PostMapping("/register")：完整路径就是 POST /user/register。
• @RequestBody：把请求体的 JSON 反序列化为 UserRegisterRequest 对象。
• @Valid：触发参数校验（详见 7.5 节）。
• @Autowired：把 SysUserService 这个 Bean 自动注入进来（详见 6.6 节）。
• Result.success(response)：把业务结果包成统一响应格式（详见第 7 章）。

⚠️ 控制器里不要写业务逻辑，只做三件事：接参 → 调 service → 返结果。

6.3 Service 层（接口 + 实现类）#

Service 层是”厨房”，是业务规则的核心。本项目用 接口 + 实现类 的方式分离：

接口 SysUserService.java：

1
public interface SysUserService extends IService<SysUser> {
2
    UserRegisterResponse register(UserRegisterRequest request);
3
    UserLoginResponse login(UserLoginRequest request);
4
    SysUser getUserById(Long id);
5
    void changePassword(Long userId, String oldPassword, String newPassword);
6
    IPage<UserVO> searchUsers(UserSearchRequest request);
7
}

实现类 SysUserServiceImpl.java：

1
@Slf4j
2
@Service
3
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser>
4
        implements SysUserService {
5

6
    @Override
7
    @Transactional(rollbackFor = Exception.class)
8
    public UserRegisterResponse register(UserRegisterRequest request) {
9
        // ... 一堆业务逻辑
10
    }
11
}

为什么要”接口 + 实现”？

1. 解耦：Controller 依赖接口而不是具体实现，将来想换实现（比如对接其他数据源）只需新写一个实现类。
2. AOP 友好：Spring 的事务、日志、缓存代理需要接口才能用 JDK 动态代理。
3. 易测试：写单元测试时可以方便地 Mock 接口。

注意几个关键点：

• extends ServiceImpl<SysUserMapper, SysUser>：MP 提供的通用 Service 实现，让你在 service 里直接用 this.save()、this.getById() 等方法，免去写 userMapper.insert() 的麻烦。
• @Service：告诉 Spring “我是一个 service Bean，请管理我”。
• @Transactional(rollbackFor = Exception.class)：所有写操作都加事务，遇到异常自动回滚，保证数据一致性。
• @Transactional(readOnly = true)：只读事务可以让数据库做优化（比如只读副本路由），本项目 getUserById、searchUsers 都加了。

6.4 Mapper 层#

Mapper 层是”采购员”，只做一件事：和数据库说话。看本项目的 SysUserMapper：

1
@Mapper
2
public interface SysUserMapper extends BaseMapper<SysUser> {
3
    @Update("UPDATE sys_user SET login_fail_count = login_fail_count + 1, ... ")
4
    int incrementLoginFailCount(@Param("userId") Long userId,
5
                                 @Param("maxFailCount") int maxFailCount,
6
                                 @Param("lockMinutes") int lockMinutes);
7
}

它就是一个接口，没有方法体。简单 CRUD 由 BaseMapper 提供，复杂 SQL 用注解或 XML。框架启动时会用动态代理生成实现类。

⚠️ Service 层可以调 Mapper，但 Controller 层禁止直接调 Mapper！否则就破坏了分层架构。

6.5 Entity / DTO / VO 区别#

这三个东西看起来都是”装数据的盒子”，但用途完全不同。本项目里非常清晰：

为什么要分？看一个例子。

数据库表 sys_user 有 password、isDeleted、lockUntil 这些敏感/无关字段。

• 注册时，前端只该传 username、password、nickname、email，所以本项目定义了 UserRegisterRequest：

  1
  @Data
  2
  public class UserRegisterRequest {
  3
      @NotBlank(message = "用户名不能为空")
  4
      @Size(min = 3, max = 20)
  5
      private String username;
  6
      @NotBlank @Size(min = 8, max = 50)
  7
      private String password;
  8
      @Size(max = 30)
  9
      private String nickname;
  10
      @Email
  11
      private String email;
  12
  }

  这就是 DTO，只有前端会传的字段。

• 查询用户时，给前端返回的对象不能包含 password、isDeleted，所以另定义了 UserVO，只放可公开的字段（id、username、nickname、avatar 等）。

如果直接把 SysUser 实体类返回给前端：

1. 密码会泄露（虽然 @JsonIgnore 能挡一下）。
2. 数据库字段一变，前端契约就跟着崩。
3. 没法精细控制权限（比如本项目里”只有本人或管理员能看到 email、role”）。

⚠️ 一条铁律：Controller 入参用 DTO，出参用 VO，Entity 只在 service / mapper 内部流转。

6.6 IoC / DI 速通#

Spring 最核心的概念是 IoC（控制反转） 和 DI（依赖注入）。听起来玄乎，其实一个比喻就懂：

老式做法：你想喝水，自己走到饮水机接水（自己 new 对象）。 Spring 做法：你举手喊”我要水”，服务员自动送过来（容器自动注入）。

控制反转 = 把”创建对象”的权力从你手里反转给 Spring 容器。 依赖注入 = 容器把你需要的对象塞给你。

本项目里到处可见：

1
@Service
2
public class SysUserServiceImpl ... {
3
    @Autowired
4
    private JwtUtils jwtUtils;
5
    @Autowired
6
    private BCryptPasswordEncoder passwordEncoder;
7
}

@Autowired 告诉 Spring：“请把已经创建好的 JwtUtils Bean 塞给我”。Spring 启动时会扫描所有 @Component / @Service / @Controller / @Repository / @Configuration，把它们都注册进容器，然后按需注入。

常见 Bean 注解：

⚠️ 推荐用构造器注入而不是字段注入（更利于测试和不可变性），但小型项目用 @Autowired 字段注入也很常见。

6.7 项目实际调用链：注册接口#

最后我们走一遍”注册接口”的完整调用链，把所有层串起来：

1
前端
2
  ↓ POST /api/user/register  body: {username, password, nickname, email}
3
SysUserController.register(...)
4
  ↓ @Valid 触发参数校验
5
  ↓ 调用
6
SysUserService.register(request)
7
  ↓ 实现是
8
SysUserServiceImpl.register(...)
9
    1. 校验密码复杂度（至少 8 位、含 3 类字符）
10
    2. LambdaQueryWrapper 检查 username 是否已存在
11
    3. LambdaQueryWrapper 检查 email 是否已存在
12
    4. BCryptPasswordEncoder.encode(password) 加密密码
13
    5. this.save(user) → 调用 BaseMapper.insert
14
       ↓
15
SysUserMapper（BaseMapper）
16
    INSERT INTO sys_user (...) VALUES (...)
17
       ↓
18
MySQL
19
       ↓ 返回新增 id
20
回到 service：log.info("用户注册成功")
21
回到 controller：Result.success(new UserRegisterResponse(id, username))
22
       ↓ 序列化为 JSON
23
前端收到：{"code":200,"message":"操作成功","data":{"id":1,"username":"..."}}