Spring Boot 从入门到实战（超详细，Java 后端实习生必备）

前言

作为一名 Java 后端开发实习生，相信你一定听过甚至接触过 Spring Boot 这个框架。我们之前学的原生 SSM（Spring+SpringMVC+MyBatis）开发，需要做大量的 xml 配置、包扫描配置、依赖整合，繁琐且容易出错，而Spring Boot 就是为了解决这些痛点而生的框架。

Spring Boot 核心理念是「约定大于配置、开箱即用」，它整合了 Spring 生态的所有核心功能，简化了项目搭建、配置、部署的全流程，不用写大量配置文件就能快速开发一个后端接口项目。对于实习生来说，Spring Boot 是现阶段最必须掌握、最常用、面试最高频的技术栈，没有之一。

这篇博客从「零基础入门」到「企业级实战开发」，内容循序渐进、所有代码可直接复制运行、知识点贴合实习生工作 / 面试需求，非常适合作为你的第一篇技术博客发布，也能帮你夯实 Spring Boot 核心基础。

一、什么是 Spring Boot？

Spring Boot 是由 Pivotal 团队研发的，基于 Spring 框架的快速开发脚手架，它不是对 Spring 的替换，而是对 Spring 的封装和增强。

简单理解：Spring Boot = Spring + 自动配置 + 内嵌 Web 容器 + 一站式依赖管理

我们不用再手动整合 Spring、SpringMVC、Tomcat、MyBatis 等组件，不用写一堆 xml 配置文件，Spring Boot 帮我们把这些都做好了，我们只需要专注于业务逻辑开发即可。

二、Spring Boot 核心优势（为什么必学？）

对于实习生来说，这些优势直接决定了工作效率，也是面试必答考点，一定要记牢：

1. ✅ 快速搭建项目：通过脚手架一键生成项目结构，无需手动配置，几分钟就能创建一个可运行的后端项目；
2. ✅ 开箱即用，自动配置：Spring Boot 会根据我们引入的依赖，自动完成对应的配置（比如引入 web 依赖，自动配置 SpringMVC + 内嵌 Tomcat），零配置 / 极少配置即可开发；
3. ✅ 内嵌 Web 容器：内置 Tomcat、Jetty、Undertow，项目打包后是一个 jar 包，无需部署到外部 Tomcat，直接 java -jar 就能运行，部署超级方便；
4. ✅ 一站式依赖管理：通过starter起步依赖，一键引入相关技术栈的所有依赖，解决了 Spring 生态依赖版本冲突的痛点；
5. ✅ 完全兼容 Spring 生态：可以无缝整合 MyBatis、Redis、RabbitMQ、SpringCloud 等所有 Spring 全家桶技术；
6. ✅ 生产级别的特性：自带健康检查、指标监控、日志管理，无需额外开发即可用于生产环境。

三、开发环境准备（必配，一步到位）

工欲善其事必先利其器，Spring Boot 对环境的要求很简单，统一版本避免踩坑，所有实习生统一按这个配置即可：

基础环境

• JDK 版本：1.8 （企业开发主流版本，实习生 99% 的项目都是 JDK8，不要用太高版本）
• 构建工具：Maven 3.6+ （Spring Boot 推荐，IDEA 自带，无需额外安装）
• 开发工具：IDEA 2020+ （旗舰版最佳，社区版也够用，后端开发标配）
• Spring Boot 版本：2.7.x （稳定版，生产环境主流，3.x 版本对 JDK 要求高，实习生暂不推荐）

环境说明

• 为什么不用 JDK11/17？企业老项目基本都是 JDK8，实习接触的项目 99% 都是 JDK8，先掌握主流版本；
• 为什么不用 Spring Boot3.x？3.x 要求 JDK17 起步，且部分配置和 2.x 有差异，先吃透 2.x，后续升级无缝衔接。

四、快速搭建第一个 Spring Boot 项目（两种方式，都要会）

Spring Boot 提供了两种主流的项目搭建方式，新手推荐第二种（IDEA 快捷创建），第一种（官网脚手架）面试可能问到，都学一下。

方式一：Spring 官网脚手架创建（https://start.spring.io/）

这是 Spring 官方的可视化脚手架，所有环境都能用，步骤如下：

1. 打开官网地址：https://start.spring.io/
2. 配置项目基础信息：
   • Project：选择 Maven Project（Maven 为主，Gradle 企业用的少）
   • Language：选择 Java
   • Spring Boot：选择 2.7.18（2.7 稳定版）
   • Group：包名，格式 com.xxx 例如 com.demo
   • Artifact：项目名，例如 springboot-demo
   • Java：选择 8
3. 点击「ADD DEPENDENCIES」，添加核心依赖：Spring Web（这是开发后端接口的核心依赖，必加）
4. 点击「GENERATE」，会下载一个 zip 压缩包，解压后用 IDEA 打开即可。

方式二：IDEA 快捷创建（推荐，最常用）

IDEA 集成了 Spring Boot 脚手架，不用打开浏览器，几步就能创建完成，实习生日常开发首选：

1. 打开 IDEA → 新建项目 → 选择「Spring Initializr」→ 下一步
2. 填写项目信息：Group（com.demo）、Artifact（springboot-demo）、Java Version（8）→ 下一步
3. 选择依赖：在「Web」分类下勾选「Spring Web」→ 下一步
4. 选择项目存储路径 → 完成，IDEA 会自动下载依赖并构建项目。

✨ 小技巧：第一次创建项目会下载依赖，速度可能慢，在 IDEA 中配置阿里云 Maven 镜像，下载速度直接起飞（实习生必配）。

五、Spring Boot 项目核心结构解析（重中之重）

项目创建完成后，会生成标准化的目录结构，Spring Boot 是「约定大于配置」，这个结构是固定的，不要乱改，看懂每个目录的作用，是开发的前提，也是面试常问的点。

plaintext

springboot-demo // 项目根目录 ├── src │ ├── main │ │ ├── java │ │ │ └── com.demo // 你的包名 │ │ │ ├── SpringbootDemoApplication.java // 项目启动类【核心】 │ │ │ ├── controller // 控制层：写接口的地方【核心】 │ │ │ ├── service // 业务层：写业务逻辑的地方【核心】 │ │ │ ├── mapper // 数据层：操作数据库（MyBatis） │ │ │ └── pojo // 实体类：封装数据 │ │ └── resources │ │ ├── application.properties // 全局配置文件【核心】 │ │ ├── static // 静态资源：css、js、图片（后端基本不用） │ │ └── templates // 模板页面：thymeleaf（前后端分离项目不用） │ └── test // 测试目录：写单元测试，实习生也要养成写测试的习惯 └── pom.xml // Maven核心文件：管理依赖和项目配置【核心】 

核心文件说明（实习生必须熟记）

• 项目的入口，带有 @SpringBootApplication 注解，运行这个类的 main 方法，项目就启动了；
• 一个项目只能有一个启动类，且启动类要放在所有业务包的最外层（否则会扫描不到组件）。
• 核心代码（自动生成，不用改）：
1. 配置文件 application.properties
   • Spring Boot 的全局配置文件，所有自定义配置都写在这里（端口号、数据库连接、日志配置等）；
   • 支持两种格式：.properties（键值对，新手友好）和 .yml（层级结构，更简洁），两者任选其一即可。
2. Maven 文件 pom.xml
   • 管理项目的所有依赖，比如我们引入的 Spring Web、MyBatis 等，都在这里配置；
   • Spring Boot 的核心是「starter 起步依赖」，比如引入spring-boot-starter-web，就自动整合了 SpringMVC+Tomcat+JSON 等所有 web 开发需要的依赖，不用手动加多个 jar 包。

启动类 SpringbootDemoApplication.javajava运行

package com.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringbootDemoApplication { public static void main(String[] args) { SpringApplication.run(SpringbootDemoApplication.class, args); } } 

六、第一个 Spring Boot 接口：Hello World（入门必写）

一切准备就绪，我们来写第一个 Spring Boot 接口，这是所有后端开发的起点，代码超级简单，运行后就能看到效果，成就感拉满！

步骤 1：创建 Controller 控制层

在 com.demo 包下新建 controller 包，然后创建 HelloController.java 类，代码如下：

java

运行

package com.demo.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; /** * 第一个Spring Boot接口 * @RestController 注解：标识这是一个控制器，返回JSON格式数据 */ @RestController public class HelloController { /** * @GetMapping("/hello") 注解：标识这是一个GET请求，接口路径为 /hello */ @GetMapping("/hello") public String hello() { // 接口返回字符串 return "Hello Spring Boot! 我是Java后端实习生～"; } } 

核心注解解释（实习生必懂，高频面试题）

• @RestController：组合注解 = @Controller + @ResponseBody，作用有两个：
  1. 告诉 Spring 这是一个控制器类，接收前端请求；
  2. 将方法的返回值直接以 JSON / 字符串的形式返回给前端，而不是跳转页面。（前后端分离开发的核心注解，后端 99% 的接口都会用这个）
• @GetMapping("/hello")：指定接口的请求方式为 GET，请求路径为/hello；对应还有@PostMapping（POST 请求）、@PutMapping（修改）、@DeleteMapping（删除），这四个是 RESTful 风格的核心注解。

步骤 2：启动项目，测试接口

1. 找到启动类 SpringbootDemoApplication.java，右键点击「Run」，启动项目；
2. 启动成功后，控制台会打印日志，看到 started SpringbootDemoApplication in xxx seconds 说明启动成功；
3. 测试方式（两种都要会，后端必备）：
   • 方式一：打开浏览器，输入地址 http://localhost:8080/hello，回车就能看到返回的字符串；
   • 方式二：用 Postman（后端接口测试神器），发送 GET 请求 http://localhost:8080/hello，返回结果一致。

✨ 小知识点：Spring Boot 默认端口是 8080，如果端口被占用，在application.properties中配置：server.port=8081 即可修改端口。

七、Spring Boot 核心实战开发（企业级必备，重点中的重点）

恭喜你完成了入门案例！接下来的内容是这篇博客的核心干货，也是你作为 Java 后端实习生，在实际工作中每天都会用到的功能，所有知识点都是企业开发的标配，代码可直接复制到项目中使用，学会这些，你就能独立开发基础的后端接口了。

所有实战功能都是循序渐进的，从简单到复杂，全部基于上面的入门项目改造，无需额外创建项目。

实战 1：全局统一返回结果封装（必做，大厂规范）

我们刚才写的接口返回的是一个字符串，而在实际开发中，后端接口的返回格式必须统一、规范，无论接口成功还是失败，都要返回相同的 JSON 结构，这是大厂的硬性规范，也是实习生必须掌握的第一个实战技能。

为什么要统一返回结果？

• 前端开发可以统一解析返回数据，不用处理各种不同的返回格式；
• 接口的可读性更强，能明确知道接口的请求状态、返回数据、错误信息；
• 方便统一处理异常，规范项目开发。

步骤 1：创建统一返回结果实体类

在 com.demo 包下新建 pojo 包，创建 Result.java 类：

java

运行

package com.demo.pojo; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; /** * 全局统一返回结果类 * 所有接口都返回这个类的对象 */ @Data @NoArgsConstructor @AllArgsConstructor public class Result { // 响应码：200=成功，500=失败，400=参数错误，401=未登录，403=无权限 private Integer code; // 响应信息：提示内容 private String msg; // 响应数据：返回给前端的业务数据 private Object data; // 快速返回：成功且无数据 public static Result success() { return new Result(200, "操作成功", null); } // 快速返回：成功且带数据 public static Result success(Object data) { return new Result(200, "操作成功", data); } // 快速返回：失败且带错误信息 public static Result error(String msg) { return new Result(500, msg, null); } } 

依赖说明

上面用到了lombok的注解@Data、@NoArgsConstructor、@AllArgsConstructor，作用是自动生成 getter、setter、无参构造、全参构造方法，不用手动写，节省大量代码，后端开发必备神器！需要在pom.xml中引入 lombok 依赖：

xml

<dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> 

步骤 2：改造接口，返回统一结果

修改HelloController.java，写一个带参数的用户查询接口，返回统一的 Result 对象：

java

运行

@GetMapping("/user/{id}") public Result getUserById(@PathVariable Integer id) { // 模拟根据ID查询用户信息，实际开发中这里会调用service层查询数据库 if (id == 1) { // 模拟用户数据 User user = new User(1, "张三", 22, "Java后端实习生"); return Result.success(user); } else { return Result.error("用户不存在"); } } 

同时在 pojo 包下创建 User 实体类：

java

运行

package com.demo.pojo; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @Data @NoArgsConstructor @AllArgsConstructor public class User { private Integer id; private String name; private Integer age; private String desc; } 

测试接口

访问 http://localhost:8080/user/1，返回的 JSON 格式如下，规范且清晰：

json

{ "code": 200, "msg": "操作成功", "data": { "id": 1, "name": "张三", "age": 22, "desc": "Java后端实习生" } } 

访问 http://localhost:8080/user/2，返回失败结果：

json

{ "code": 500, "msg": "用户不存在", "data": null } 

实战 2：全局统一异常处理（必做，企业级核心）

在开发中，接口一定会出现异常：比如空指针异常、数组越界、数据库查询异常、自定义业务异常等。如果我们在每个接口中都写try-catch捕获异常，代码会非常臃肿，可读性极差。

Spring Boot 提供了全局异常处理机制，通过 @RestControllerAdvice + @ExceptionHandler 注解，能统一捕获项目中所有的异常，返回规范的错误信息，一次配置，全局生效，这是实习生必须掌握的核心技能！

步骤 1：创建全局异常处理类

在 com.demo 包下新建 exception 包，创建 GlobalExceptionHandler.java 类：

java

运行

package com.demo.exception; import com.demo.pojo.Result; import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.RestControllerAdvice; /** * 全局异常处理器 * @RestControllerAdvice：标识这是一个全局异常处理类，处理所有@RestController的异常 */ @RestControllerAdvice public class GlobalExceptionHandler { /** * 捕获所有运行时异常（最常用） * @ExceptionHandler(RuntimeException.class)：指定捕获的异常类型 */ @ExceptionHandler(RuntimeException.class) public Result handleRuntimeException(RuntimeException e) { e.printStackTrace(); // 打印异常堆栈，方便排查问题 return Result.error("服务器内部错误：" + e.getMessage()); } /** * 捕获所有Exception异常（兜底，捕获所有未指定的异常） */ @ExceptionHandler(Exception.class) public Result handleException(Exception e) { e.printStackTrace(); return Result.error("系统异常，请联系管理员"); } } 

核心注解解释

• @RestControllerAdvice：全局异常处理的核心注解，作用是扫描所有的控制器，捕获控制器中抛出的异常；
• @ExceptionHandler(异常类型.class)：指定当前方法处理哪种异常，方法的参数就是捕获到的异常对象。

测试异常处理

在 Controller 中写一个会抛出空指针异常的接口：

java

运行

@GetMapping("/test/exception") public Result testException() { String str = null; str.length(); // 空指针异常 return Result.success(); } 

访问该接口，会被全局异常处理器捕获，返回规范的错误结果，不会出现页面报错，也不用写 try-catch，代码非常干净！

实战 3：接口参数校验（必做，数据合法性校验）

后端接口接收前端传递的参数时，必须做参数合法性校验：比如用户名不能为空、手机号格式正确、年龄必须是正数等。如果在业务代码中手动判断每个参数，会非常繁琐。

Spring Boot 整合了 JSR380 规范，通过 @Valid + 校验注解 就能实现优雅的参数校验，校验失败会自动抛出异常，被我们的全局异常处理器捕获，返回错误信息，这是企业开发的标配！

步骤 1：引入参数校验依赖

xml

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> 

步骤 2：在实体类中添加校验注解

修改 User 实体类，给字段添加校验规则：

java

运行

@Data @NoArgsConstructor @AllArgsConstructor public class User { private Integer id; @NotBlank(message = "用户名不能为空") // 字符串不能为空，且不能是空白字符 private String name; @Min(value = 0, message = "年龄不能为负数") // 最小值为0 @Max(value = 150, message = "年龄不能超过150") // 最大值为150 private Integer age; private String desc; } 

常用的校验注解：

• @NotBlank：字符串不能为空、不能为空串、不能是空格；
• @NotNull：任意类型不能为空；
• @NotEmpty：集合 / 数组不能为空；
• @Min/@Max：数字的最小值 / 最大值；
• @Pattern：正则表达式校验（比如手机号、邮箱）。

步骤 3：在接口中添加 @Valid 注解开启校验

java

运行

@PostMapping("/user/add") public Result addUser(@Valid @RequestBody User user) { // 校验通过才会执行这里的业务逻辑 return Result.success("用户添加成功"); } 

测试参数校验

用 Postman 发送 POST 请求，传递一个用户名空、年龄为 - 1 的 JSON 参数，接口会自动返回校验失败的错误信息，无需手动判断，非常优雅！

八、项目打包与部署（实习生必懂，面试常问）

Spring Boot 项目开发完成后，需要打包部署到服务器运行，这是项目开发的最后一步，也是实习生必须掌握的技能。Spring Boot 的打包非常简单，打包后是一个可执行的 jar 包，内置了 Tomcat，无需依赖外部容器，部署超级方便！

步骤 1：打包项目

1. 在 IDEA 右侧找到「Maven」面板，展开项目 → 生命周期 → 双击「package」，开始打包；
2. 打包成功后，在项目的target目录下会生成一个 springboot-demo-0.0.1-SNAPSHOT.jar 文件，这就是我们的可执行 jar 包。

步骤 2：运行 jar 包

打开命令行，进入 jar 包所在的目录，执行以下命令即可启动项目：

bash

运行

java -jar springboot-demo-0.0.1-SNAPSHOT.jar 

启动成功后，访问接口的方式和在 IDEA 中一致，项目运行完全脱离开发环境，这就是 Spring Boot 的魅力！

九、总结与学习建议（写给 Java 后端实习生的心里话）

✅ 本文核心知识点总结

这篇博客从 Spring Boot 的入门到实战，我们学习了：

1. Spring Boot 的定义和核心优势，理解为什么它是后端开发的主流框架；
2. 两种快速搭建 Spring Boot 项目的方式，以及项目的核心目录结构；
3. 入门案例 Hello World，掌握了@RestController、@GetMapping等核心注解；
4. 企业级必备的三大实战技能：统一返回结果、全局异常处理、接口参数校验，这三个功能是所有 Spring Boot 项目的标配；
5. 项目的打包与部署，学会了如何将项目打包成 jar 包并运行。

以上内容，足够你应对实习生阶段的大部分开发工作，也是面试中 Spring Boot 的核心考点，把这些知识点吃透，你就能从「零基础」到「能独立开发基础接口」的蜕变。

✅ 给实习生的学习建议（重中之重）

作为一名 Java 后端实习生，写博客是最好的成长方式之一，而 Spring Boot 是你技术之路的第一个核心框架，我给你几个真诚的学习建议，希望能帮到你：

1. 先吃透基础，再谈进阶：Spring Boot 的核心是「约定大于配置」，先把本文的知识点全部掌握，能独立写接口、处理异常、校验参数，再去学习整合 MyBatis 操作数据库、Redis 缓存、RabbitMQ 消息队列等进阶技术；
2. 多敲代码，少看视频：技术是敲出来的，不是看出来的。把本文的所有代码都手动敲一遍，运行成功，理解每一行代码的含义，比看 10 个视频都管用；
3. 遇到问题先自己排查：开发中一定会遇到各种问题，比如启动失败、接口报错、参数校验不生效等，先学会看控制台日志，日志是排查问题的最好帮手（这也是我们之前聊的日志的作用），尝试自己解决问题，实在解决不了再问同事 / 百度，这个过程的成长最快；
4. 坚持写博客：这篇博客是你的第一篇，写完发布后，后续可以继续写「Spring Boot 整合 MyBatis」「Spring Boot 整合 Redis」「Spring Boot 分页查询」等进阶内容，博客不仅能帮你梳理知识点，还能在求职时成为你的加分项，面试官看到你的博客，会对你刮目相看；
5. 保持学习的热情：Java 后端开发需要学习的东西很多，但只要一步一个脚印，循序渐进，你一定会从实习生成长为一名合格的后端开发工程师。

最后

Spring Boot 是 Java 后端开发的基石，也是实习生的敲门砖，希望这篇博客能帮你快速入门并掌握核心实战技能。技术之路没有捷径，但坚持下去，一定会有收获！加油，未来的 Java 后端工程师～💪