Spring Boot 快速入门：从零构建 CRUD 后台管理系统-开发者社区

Spring Boot 应该怎么学？如果你正在寻找一条能快速上手、直击核心、并能立刻产出可运行项目的学习路径，这篇文章就是为你准备的。我们不会从冗长的历史背景讲起，而是直接切入主题：Spring Boot 的核心价值在于它能让你“直接运行”一个生产级的、独立的 Spring 应用，极大地简化了传统 Spring 应用的配置和部署复杂度。对于初学者或希望快速构建原型的开发者来说，这意味着你可以把精力集中在业务逻辑上，而不是繁琐的 XML 配置和服务器部署上。

这篇文章将采用一种“直男式”的实践教学法，目标是在短时间内让你掌握 Spring Boot 的核心用法。我们将重点关注几个关键问题：如何从零开始创建一个 Spring Boot 项目？如何集成数据库和前端模板？如何打包部署？以及如何理解其核心的“自动装配”原理。整个过程将围绕一个具体的、可运行的示例项目展开，确保你每一步都有代码可写，有结果可看。

本文适合有一定 Java 基础，但对 Spring 框架感到陌生或畏惧，希望快速上手 Spring Boot 进行 Web 开发的开发者。我们将使用当前主流的工具链：IntelliJ IDEA、Maven、Spring Boot 2.7.x/3.x、MySQL、MyBatis-Plus 和 Thymeleaf，这些都是企业级开发中的常见组合。通过本文，你将能独立搭建一个具备基础 CRUD 功能的后台管理系统骨架。

1. Spring Boot 核心能力速览

在深入细节之前，我们先通过一个表格快速了解 Spring Boot 能为你做什么，以及它的技术门槛。

能力项	说明
项目类型	用于快速构建独立的、生产级的 Spring 应用程序的框架。
核心特点	约定大于配置，提供大量“Starter”依赖简化构建；内嵌 Web 服务器（Tomcat/Jetty/Undertow），无需部署 WAR 包；自动装配，根据类路径自动配置 Bean。
学习门槛	要求具备 Java SE 基础，了解 Servlet、MVC 基本概念更佳。无需预先精通 Spring Framework 的全部细节。
开发环境	JDK 8 或更高版本（Spring Boot 2.x 支持 JDK 8-19，3.x 需 JDK 17+）；推荐使用 IntelliJ IDEA 或 Eclipse STS；构建工具 Maven 或 Gradle。
硬件门槛	无特殊要求。普通开发电脑即可，内存建议 8GB 以上，用于同时运行 IDE、数据库和多个服务。
启动方式	通过运行`main`方法直接启动内嵌服务器；或使用`mvn spring-boot:run`命令；亦可打包成可执行的 JAR 文件运行。
是否支持 API	是。原生支持构建 RESTful API，是微服务架构中的核心组件。
是否适合批量任务	是。通过 Spring Batch 模块可以方便地处理批处理任务。
适合场景	快速原型开发、微服务、前后端分离的后端服务、传统单体 Web 应用、批处理应用等。

从上表可以看出，Spring Boot 的设计初衷就是降低 Spring 的使用门槛，让开发者能快速启动和运行项目。接下来，我们将从环境准备开始，一步步验证这些能力。

2. 适用场景与使用边界

Spring Boot 并非万能钥匙，理解其适用场景和边界能帮助你更好地进行技术选型。

它非常适合以下场景：

快速启动新项目：无论是毕业设计、课程作业还是内部工具，Spring Initializr 能在几分钟内生成一个可运行的项目骨架。
微服务开发：作为独立的、轻量级的服务单元，Spring Boot 是构建微服务架构的事实标准之一，易于容器化（Docker）和编排（Kubernetes）。
构建 RESTful API：对于移动端、前端（Vue/React）提供数据接口的后端服务，Spring Boot 的 Web 模块和注解驱动开发效率极高。
集成各类中间件：通过对应的 Starter（如spring-boot-starter-data-redis,spring-boot-starter-kafka），可以几乎零配置地集成 Redis、Kafka、Elasticsearch 等流行组件。
传统 Web 应用：配合 Thymeleaf、Freemarker 等模板引擎，快速开发服务端渲染的管理后台。

它可能不是最佳选择，或需要额外注意的边界：

极度轻量级的场景：如果项目极其简单，只是一个命令行工具或简单的脚本，引入 Spring Boot 可能会显得臃肿，可以考虑更轻量的框架如 Micronaut 或 Quarkus。
对启动时间极度敏感：传统的 Spring Boot 应用启动时间相对于原生编译应用较长。虽然 Spring Boot 3 的 Native Image（GraalVM）特性可以极大改善，但增加了构建复杂性。
高度定制化的遗留系统集成：如果需要与大量使用非标准配置或老旧技术的系统深度集成，Spring Boot 的“约定”有时会成为束缚，需要花费精力覆盖自动配置。
学习边界：Spring Boot 简化了配置，但并未简化 Spring 的核心概念（如IoC、AOP）。若要深入排查问题或进行高级定制，仍需理解 Spring Framework 的基础。

3. 环境准备与前置条件

开始实战前，请确保你的开发环境满足以下要求。这是后续所有操作能顺利进行的基础。

3.1 基础软件安装

JDK：这是必须的。Spring Boot 2.7.x 推荐使用 JDK 8 或 11；Spring Boot 3.x 必须使用 JDK 17 或更高版本。建议安装 JDK 17，以兼顾新特性和广泛兼容性。在终端输入java -version验证。
```
java -version # 预期输出类似：openjdk version "17.0.10" 2024-01-16
```
Maven：项目管理工具。用于下载依赖、编译和打包。安装后，在终端输入mvn -v验证。
```
mvn -v # 预期输出包含 Apache Maven 版本号和 Java 版本信息。
```
IntelliJ IDEA：推荐使用社区版或旗舰版。确保已安装并配置好 JDK 和 Maven。在File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven中检查 Maven 路径。

3.2 数据库准备（可选，但推荐）我们将集成 MySQL 数据库。你需要：

安装 MySQL（5.7 或 8.0 版本）。
启动 MySQL 服务。
使用命令行或图形化工具（如 Navicat, DBeaver）创建一个新的数据库，例如springboot_demo。
```
CREATE DATABASE IF NOT EXISTS `springboot_demo` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
```

3.3 检查端口占用Spring Boot 默认使用8080端口。确保该端口未被其他程序（如其他 Tomcat 实例、某些开发服务器）占用。在 Windows 上，可以使用netstat -ano | findstr :8080查看；在 Linux/Mac 上，使用lsof -i:8080查看。

4. 创建第一个 Spring Boot 项目

我们将使用 IntelliJ IDEA 内置的 Spring Initializr 来创建项目，这是最直观的方式。

4.1 通过 Spring Initializr 创建项目

打开 IntelliJ IDEA，选择New Project。
在左侧选择Spring Initializr。
Project SDK：选择你安装的 JDK 17。
选择 Initializr Service URL：默认使用官方的https://start.spring.io即可。
项目元数据（Project Metadata）：
- Group：通常为公司或组织域名倒写，例如com.example。
- Artifact：项目名称，例如demo。
- Type：选择Maven。
- Language：选择Java。
- Packaging：选择Jar。
- Java Version：选择17。
- Version：默认即可。
选择依赖（Dependencies）：这是关键步骤，我们一次性添加常用依赖。点击Add Dependencies按钮，搜索并添加：
- Spring Web：用于构建 Web 应用和 RESTful API。
- Thymeleaf：模板引擎，用于服务端渲染 HTML。
- MyBatis Framework：或直接搜索并添加MyBatis Plus（如果 Initializr 支持）。这里我们先添加MyBatis Framework，后续再手动改为 MyBatis-Plus。
- MySQL Driver：MySQL 数据库驱动。
- Lombok：通过注解简化 Java Bean 的 Getter/Setter 等方法，强烈推荐。
点击Next，选择项目存储位置，然后点击Finish。IDEA 会自动下载项目模板和依赖，这可能需要一些时间。

4.2 项目结构解析创建完成后，你会看到类似如下的项目结构：

demo ├── src │ ├── main │ │ ├── java │ │ │ └── com │ │ │ └── example │ │ │ └── demo │ │ │ └── DemoApplication.java // 主启动类 │ │ └── resources │ │ ├── static // 存放静态资源（CSS, JS, 图片） │ │ ├── templates // 存放 Thymeleaf 模板文件 │ │ └── application.properties // 配置文件 │ └── test // 测试代码目录 └── pom.xml // Maven 项目对象模型文件

DemoApplication.java中的main方法就是整个应用的入口。application.properties是核心配置文件。

5. 配置与基础功能测试

项目创建好后，我们先进行最小化配置和测试，确保基础环境是通的。

5.1 配置数据库连接打开src/main/resources/application.properties文件，添加以下配置：

# 应用服务端口（如果8080被占用，可修改） server.port=8080 # 数据库连接配置 spring.datasource.url=jdbc:mysql://localhost:3306/springboot_demo?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai spring.datasource.username=root # 你的数据库用户名 spring.datasource.password=123456 # 你的数据库密码 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver # 配置 MyBatis（使用 MyBatis-Plus 后部分配置会覆盖） mybatis.mapper-locations=classpath:mapper/*.xml mybatis.type-aliases-package=com.example.demo.entity # Thymeleaf 配置（非必须，但建议关闭缓存以便开发时实时预览） spring.thymeleaf.cache=false spring.thymeleaf.mode=HTML spring.thymeleaf.encoding=UTF-8

注意：请将username和password替换为你自己 MySQL 的凭据。

5.2 将 MyBatis 替换为 MyBatis-PlusMyBatis-Plus 是 MyBatis 的增强工具，能极大简化 CRUD 操作。在pom.xml中，找到mybatis-spring-boot-starter依赖，将其替换为 MyBatis-Plus 的依赖：

<!-- 移除或注释掉原有的 MyBatis 依赖 --> <!-- <dependency> --> <!-- <groupId>org.mybatis.spring.boot</groupId> --> <!-- <artifactId>mybatis-spring-boot-starter</artifactId> --> <!-- <version>2.3.0</version> --> <!-- </dependency> --> <!-- 添加 MyBatis-Plus 依赖 --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.5</version> <!-- 请使用当前最新稳定版 --> </dependency>

同时，在application.properties中，可以添加 MyBatis-Plus 的配置（它会兼容大部分 MyBatis 配置）：

# MyBatis-Plus 配置 mybatis-plus.mapper-locations=classpath:mapper/*.xml mybatis-plus.type-aliases-package=com.example.demo.entity # 控制台打印 SQL 日志（开发环境非常有用） mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

5.3 创建第一个 REST 接口进行测试在com.example.demo包下新建一个controller包，并在其中创建HelloController.java：

package com.example.demo.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController // 表示这是一个 REST 风格的控制器，返回 JSON 数据 @RequestMapping("/api") // 为这个控制器下的所有接口添加统一前缀 /api public class HelloController { @GetMapping("/hello") public String sayHello() { return "Hello, Spring Boot!"; } }

5.4 启动并验证找到DemoApplication.java，右键点击Run ‘DemoApplication.main()‘。观察控制台日志，如果没有报错，并看到类似Tomcat started on port(s): 8080 (http)的日志，说明启动成功。

打开浏览器或使用curl命令访问http://localhost:8080/api/hello。你应该能看到页面显示Hello, Spring Boot!。

curl http://localhost:8080/api/hello # 预期输出：Hello, Spring Boot!

至此，你的第一个 Spring Boot 应用已经成功运行并对外提供了 API 服务。

6. 集成 MyBatis-Plus 实现 CRUD

接下来，我们实现一个完整的用户管理模块，涵盖实体类、Mapper、Service、Controller 和页面。

6.1 创建实体类（Entity）在com.example.demo包下新建entity包，创建User.java：

package com.example.demo.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import java.time.LocalDateTime; @Data // Lombok 注解，自动生成 getter, setter, toString 等方法 @TableName("sys_user") // 指定对应的数据库表名 public class User { @TableId(type = IdType.AUTO) // 主键，自增 private Long id; private String username; private String password; private String email; private String phone; private LocalDateTime createTime; private LocalDateTime updateTime; }

6.2 创建数据库表在 MySQL 的springboot_demo数据库中执行以下 SQL：

CREATE TABLE `sys_user` ( `id` bigint NOT NULL AUTO_INCREMENT, `username` varchar(50) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '用户名', `password` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '密码', `email` varchar(100) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '邮箱', `phone` varchar(20) COLLATE utf8mb4_unicode_ci 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 COLLATE=utf8mb4_unicode_ci COMMENT='用户表';

6.3 创建 Mapper 接口在com.example.demo包下新建mapper包，创建UserMapper.java：

package com.example.demo.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.example.demo.entity.User; import org.apache.ibatis.annotations.Mapper; @Mapper // 标记为 MyBatis 的 Mapper，Spring 会自动扫描并注入 public interface UserMapper extends BaseMapper<User> { // 继承 BaseMapper 后，已经拥有了基础的 CRUD 方法，无需编写 XML }

MyBatis-Plus 的强大之处在于，通过继承BaseMapper，你无需编写任何 SQL，即可拥有insert,deleteById,updateById,selectById,selectList等方法。

6.4 创建 Service 层在com.example.demo包下新建service包，创建UserService.java接口及其实现类。

UserService.java(接口):

package com.example.demo.service; import com.baomidou.mybatisplus.extension.service.IService; import com.example.demo.entity.User; public interface UserService extends IService<User> { // 可以在此定义业务特有的方法 boolean checkUserExists(String username); }

UserServiceImpl.java(实现类):

package com.example.demo.service.impl; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.example.demo.entity.User; import com.example.demo.mapper.UserMapper; import com.example.demo.service.UserService; import org.springframework.stereotype.Service; @Service // 标记为 Spring 的 Service 组件 public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { @Override public boolean checkUserExists(String username) { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>(); wrapper.eq(User::getUsername, username); return this.count(wrapper) > 0; } }

同样，继承ServiceImpl后，也自动拥有了基础的 CRUD 能力。

6.5 创建 Controller 和页面在controller包下创建UserController.java，用于处理 Web 请求。

package com.example.demo.controller; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.example.demo.entity.User; import com.example.demo.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; @Controller // 注意这里是 @Controller，不是 @RestController，因为要返回视图 @RequestMapping("/user") public class UserController { @Autowired private UserService userService; // 用户列表页 @GetMapping("/list") public String list(@RequestParam(defaultValue = "1") Integer pageNum, @RequestParam(defaultValue = "10") Integer pageSize, Model model) { Page<User> page = new Page<>(pageNum, pageSize); LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>(); wrapper.orderByDesc(User::getCreateTime); Page<User> userPage = userService.page(page, wrapper); model.addAttribute("page", userPage); return "user/list"; // 对应 templates/user/list.html } // 跳转到新增用户页面 @GetMapping("/add") public String toAdd() { return "user/add"; } // 执行新增用户操作 @PostMapping("/add") public String add(User user) { user.setCreateTime(LocalDateTime.now()); user.setUpdateTime(LocalDateTime.now()); userService.save(user); return "redirect:/user/list"; // 重定向到列表页 } // 跳转到编辑用户页面 @GetMapping("/edit/{id}") public String toEdit(@PathVariable Long id, Model model) { User user = userService.getById(id); model.addAttribute("user", user); return "user/edit"; } // 执行更新用户操作 @PostMapping("/update") public String update(User user) { user.setUpdateTime(LocalDateTime.now()); userService.updateById(user); return "redirect:/user/list"; } // 删除用户 @GetMapping("/delete/{id}") public String delete(@PathVariable Long id) { userService.removeById(id); return "redirect:/user/list"; } }

6.6 创建 Thymeleaf 模板页面在src/main/resources/templates下新建user文件夹，并创建三个 HTML 文件。

list.html(用户列表页):

<!DOCTYPE html> <html xmlns:th="http://www.thymeleaf.org"> <head> <meta charset="UTF-8"> <title>用户列表</title> <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css"> </head> <body> <div class="container mt-4"> <h2>用户管理</h2> <a th:href="@{/user/add}" class="btn btn-primary mb-3">新增用户</a> <table class="table table-bordered table-striped"> <thead> <tr> <th>ID</th> <th>用户名</th> <th>邮箱</th> <th>手机号</th> <th>创建时间</th> <th>操作</th> </tr> </thead> <tbody> <tr th:each="user : ${page.records}"> <td th:text="${user.id}"></td> <td th:text="${user.username}"></td> <td th:text="${user.email}"></td> <td th:text="${user.phone}"></td> <td th:text="${#temporals.format(user.createTime, 'yyyy-MM-dd HH:mm:ss')}"></td> <td> <a th:href="@{/user/edit/{id}(id=${user.id})}" class="btn btn-sm btn-warning">编辑</a> <a th:href="@{/user/delete/{id}(id=${user.id})}" class="btn btn-sm btn-danger" onclick="return confirm('确定删除吗？')">删除</a> </td> </tr> </tbody> </table> <!-- 分页组件 --> <nav> <ul class="pagination"> <li class="page-item" th:classappend="${page.current == 1} ? 'disabled' : ''"> <a class="page-link" th:href="@{/user/list(pageNum=${page.current-1}, pageSize=${page.size})}">上一页</a> </li> <li class="page-item" th:each="i : ${#numbers.sequence(1, page.pages)}" th:classappend="${i == page.current} ? 'active' : ''"> <a class="page-link" th:href="@{/user/list(pageNum=${i}, pageSize=${page.size})}" th:text="${i}"></a> </li> <li class="page-item" th:classappend="${page.current == page.pages} ? 'disabled' : ''"> <a class="page-link" th:href="@{/user/list(pageNum=${page.current+1}, pageSize=${page.size})}">下一页</a> </li> </ul> </nav> </div> </body> </html>

add.html和edit.html类似，是表单页面，用于新增和编辑用户，代码结构相似，此处省略。

6.7 功能验证

重启DemoApplication。
访问http://localhost:8080/user/list。首次访问列表为空。
点击“新增用户”，填写表单并提交。
返回列表页，查看新增的用户数据，并测试编辑和删除功能。
观察 IDEA 控制台，MyBatis-Plus 打印的 SQL 日志会清晰展示执行的INSERT、SELECT、UPDATE、DELETE语句。

至此，一个具备完整 CRUD 功能的 Spring Boot + MyBatis-Plus + Thymeleaf 的 Web 应用就完成了。这个过程几乎没有手写 SQL，极大地提升了开发效率。

7. 核心原理：自动装配浅析

Spring Boot 的魔力很大程度上来源于“自动装配”（Auto-Configuration）。理解它，能帮你更好地驾驭和定制框架。

7.1 自动装配是什么？简单说，Spring Boot 在启动时，会根据你项目中引入的依赖（jar 包），自动推断并创建你需要的 Spring Bean，并完成相应的配置。例如，当你引入了spring-boot-starter-web，它会自动：

配置一个内嵌的 Tomcat 服务器。
注册DispatcherServlet（Spring MVC 的核心控制器）。
配置默认的视图解析器、消息转换器等。

7.2 如何工作？关键在@SpringBootApplication注解和spring.factories文件。

@SpringBootApplication是一个组合注解，它包含了@EnableAutoConfiguration。
@EnableAutoConfiguration会触发 Spring Boot 去扫描所有 jar 包中META-INF/spring.factories文件里org.springframework.boot.autoconfigure.EnableAutoConfiguration键对应的配置类。
这些配置类（如WebMvcAutoConfiguration,DataSourceAutoConfiguration）使用@ConditionalOnClass,@ConditionalOnMissingBean等条件注解来判断是否生效。例如，DataSourceAutoConfiguration只有在类路径下存在DataSource.class且你没有自己定义DataSourceBean 时，才会自动配置一个基于application.properties的DataSource。

7.3 如何查看和调试？在application.properties中开启调试日志，可以查看自动装配的详细报告：

debug=true

启动应用后，控制台会打印出Positive matches（生效的配置）和Negative matches（未生效的配置），这对于排查“为什么我的配置没生效”非常有帮助。

7.4 如何覆盖自动配置？自动配置不是强制性的。如果你想自定义，只需自己声明一个同类型的 Bean 即可。Spring Boot 的条件注解@ConditionalOnMissingBean会检测到已存在的 Bean，从而跳过自动配置。例如，你想自定义一个DataSource：

@Configuration public class DataSourceConfig { @Bean @ConfigurationProperties(prefix = "spring.datasource.hikari") // 使用 HikariCP 连接池 public DataSource dataSource() { return DataSourceBuilder.create().build(); } }

8. 打包与部署

开发完成后，我们需要将应用打包，以便在其他环境运行。

8.1 使用 Maven 打包在项目根目录下执行 Maven 命令：

mvn clean package -DskipTests

命令执行成功后，会在target目录下生成一个以项目名和版本命名的.jar文件，例如demo-0.0.1-SNAPSHOT.jar。这个 JAR 包是“可执行的”（Executable JAR），因为它内嵌了 Tomcat 服务器和所有依赖。

8.2 运行 JAR 包在命令行中，进入target目录，直接使用java -jar命令运行：

cd target java -jar demo-0.0.1-SNAPSHOT.jar

应用会以与在 IDEA 中相同的方式启动。你可以通过--server.port=8081参数来修改运行端口：

java -jar demo-0.0.1-SNAPSHOT.jar --server.port=8081

8.3 部署到外部 Tomcat（传统 WAR 包方式）虽然 Spring Boot 推荐使用内嵌服务器，但有时也需要部署到外部 Tomcat。

修改pom.xml中的打包方式：
```
<packaging>war</packaging>
```

修改主启动类，继承SpringBootServletInitializer：

@SpringBootApplication public class DemoApplication extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(DemoApplication.class); } public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }

重新打包：mvn clean package -DskipTests，生成demo-0.0.1-SNAPSHOT.war。
将 WAR 包部署到外部 Tomcat 的webapps目录下即可。

9. 常见问题与排查方法

在学习和使用 Spring Boot 过程中，你可能会遇到以下典型问题。

问题现象	可能原因	排查方式	解决方案
启动失败，端口被占用	默认端口 8080 被其他进程占用。	控制台日志会明确提示`Port 8080 was already in use`。使用`netstat -ano \| findstr :8080`或`lsof -i:8080`查找占用进程。	1. 终止占用进程。2. 在`application.properties`中修改`server.port`。3. 启动时指定参数`--server.port=新端口`。
无法连接到数据库	数据库配置错误、服务未启动、网络不通、驱动版本不匹配。	检查控制台启动日志，通常会有详细的连接错误信息。核对`application.properties`中的`url`,`username`,`password`。	1. 确保 MySQL 服务已启动。2. 检查连接字符串和凭据。3. 对于高版本 MySQL，驱动类名应为`com.mysql.cj.jdbc.Driver`，URL 中需指定时区`serverTimezone`。
访问页面报 404	请求路径错误、Controller 未扫描到、静态资源位置不对。	1. 检查浏览器地址栏 URL 与`@RequestMapping`定义的路径是否匹配。2. 检查启动类是否在 Controller 的上级包中（组件扫描范围）。	1. 确保 Controller 类上有`@Controller`或`@RestController`注解。2. 确保启动类位于项目根包下，或使用`@ComponentScan`手动指定扫描包。3. 静态资源放于`src/main/resources/static`下。
MyBatis-Plus 的 BaseMapper 方法不生效	Mapper 接口未被 Spring 管理。	检查 Mapper 接口上是否有`@Mapper`注解或在启动类上添加了`@MapperScan`。	1. 在 Mapper 接口上添加`@Mapper`。2. 或在启动类上添加`@MapperScan("com.example.demo.mapper")`。
Lombok 注解不生效，找不到 getter/setter	IDE 未启用 Lombok 插件或注解处理未开启。	编译时报错`cannot find symbol`。	1. 在 IntelliJ IDEA 中安装 Lombok 插件并重启。2. 在`Settings -> Build, Execution, Deployment -> Compiler -> Annotation Processors`中勾选`Enable annotation processing`。
修改代码后热部署不生效	未开启 DevTools 或 IDE 配置问题。	每次修改都需要手动重启应用。	1. 在`pom.xml`中添加`spring-boot-devtools`依赖。2. 在 IDEA 中，`Settings -> Build, Execution, Deployment -> Compiler`，勾选`Build project automatically`。然后按`Ctrl+Shift+Alt+/`，选择`Registry`，勾选`compiler.automake.allow.when.app.running`。
打包后运行，找不到主清单属性	打包时未包含 Spring Boot 的 Maven 插件。	执行`java -jar`时报错`no main manifest attribute`。	确保`pom.xml`中包含了`spring-boot-maven-plugin`。
配置文件属性不生效	属性名拼写错误、配置位置优先级问题、未刷新。	使用`@Value`注入时值为`null`或默认值。	1. 检查属性名是否正确，注意中划线和下划线。2. 了解配置优先级：命令行参数 >`application-{profile}.properties`>`application.properties`> 默认配置。3. 使用`@ConfigurationProperties`进行类型安全的绑定。

10. 最佳实践与进阶方向

掌握了基础之后，遵循一些最佳实践能让你的项目更健壮、更易维护。

10.1 配置管理

多环境配置：使用application-{profile}.properties文件。例如application-dev.properties（开发环境），application-prod.properties（生产环境）。通过启动参数--spring.profiles.active=prod来激活。
配置外化：敏感信息（如数据库密码）不应硬编码在配置文件中。可以使用环境变量或配置中心（如 Spring Cloud Config, Nacos, Apollo）。
使用 YAML：YAML 格式（application.yml）比 Properties 格式更清晰，支持层级结构。

10.2 代码结构

分层清晰：严格遵循 Controller -> Service -> Mapper 的分层架构，各司其职。
统一响应封装：为 REST API 设计统一的响应体（如包含 code, message, data 字段），便于前端处理。
全局异常处理：使用@ControllerAdvice和@ExceptionHandler捕获和处理全局异常，返回友好的错误信息。
参数校验：在接收参数的 DTO 类上使用javax.validation注解（如@NotBlank,@Email）进行校验，并在 Controller 方法参数前加@Valid。

10.3 安全与监控

集成 Spring Security：为 Web 应用添加认证和授权功能。
使用 Actuator：添加spring-boot-starter-actuator依赖，暴露应用的健康、指标、信息等端点，方便监控。
日志规范：使用 SLF4J + Logback，合理配置日志级别和输出格式，将日志输出到文件以便排查问题。

10.4 下一步可以探索的方向

集成 Redis：用于缓存、Session 共享，添加spring-boot-starter-data-redis依赖。
集成消息队列：如 RabbitMQ (spring-boot-starter-amqp) 或 Kafka (spring-boot-starter-kafka)，实现异步和解耦。
构建 RESTful API：深入使用@RestController,@GetMapping,@PostMapping,@RequestBody,@PathVariable等注解，设计规范的 API。
前后端分离：后端只提供 JSON API，前端使用 Vue/React，并通过 Spring Boot 解决跨域问题（@CrossOrigin或配置WebMvcConfigurer）。
微服务入门：学习 Spring Cloud，将单体应用拆分为多个独立的 Spring Boot 服务。
单元测试：为 Service 和 Controller 编写单元测试和集成测试，使用spring-boot-starter-test。

Spring Boot 的学习曲线前期非常平缓，能让你快速获得成就感。它的价值在于通过“约定”和“自动装配”屏蔽了大量复杂性，让开发者能聚焦业务。本文带你走完了从环境搭建、项目创建、数据库集成、CRUD 实现到打包部署的完整闭环。最值得你立刻动手尝试的，就是按照步骤创建一个自己的项目，并实现一个简单的业务模块。在这个过程中，你遇到的大部分问题，都可以通过分析控制台日志、检查依赖和配置、以及查阅官方文档来解决。当你熟悉了这套流程，Spring Boot 将成为你手中构建 Java Web 应用最得力的工具。