第1章 Spring Boot开发入门

适用人群：入门开发者技术栈：Spring Boot 4.1.1 + JDK 17 + IDEA 学习原则：动手优先、遇错不慌、先会用再深入、规范先行

学习建议

一定要动手：光看10遍不如自己敲1遍，每一个示例都跟着敲一遍。
遇到报错别慌：报错是正常的，新手不报错才奇怪，每一个报错都是成长的机会。
不懂就先放放：有些原理刚开始不懂很正常，先用起来，用多了回头看自然就懂了。
多查多问：学会用搜索引擎、官方文档、技术社区，解决问题的能力比知识本身更重要。

准备好了吗？我们开始吧！

1.1 先搞明白：我们要学的到底是啥

1.1.1 从Java Web到Spring Boot的进化史

Java企业级开发经历了四代演进，Spring Boot是当前的主流最终形态：

阶段	代表技术	核心特点	典型痛点
第一代	EJB（Java EE）	官方标准、功能全	配置极多、学习曲线极陡、开发效率极低、部署调试困难
第二代	Spring XML时代	轻量级、IoC/AOP思想	XML配置文件繁多、项目搭建耗时久
第三代	Spring注解时代	注解替代XML	仍需大量配置、依赖版本管理麻烦
第四代	Spring Boot	约定大于配置、开箱即用	——

Spring Boot不是一个全新的框架，而是Spring框架的「快速启动增强包」。它本身不提供新的核心功能，而是通过默认约定、自动配置、起步依赖，让开发者用最少的配置、最快的速度把Spring项目跑起来。

打个比方：

传统Spring = 自己买零件组装电脑，选配件、查兼容、装系统，折腾半天还可能装不上
Spring Boot = 品牌整机，厂家全部配好，开箱即用，不满意的地方按需升级

1.1.2 Spring Boot的核心优势

搭建项目极快 传统SSM项目搭环境要大半天，Spring Boot 3分钟就能生成可运行的Web项目。
几乎不用写XML 全注解开发，配置文件大幅减少，代码结构清爽。
自带Web服务器 内置Tomcat，打成JAR包直接java -jar就能运行，不用单独安装Tomcat。
依赖管理省心 一个Starter搞定一组相关依赖，版本官方测试兼容，不用自己挨个找、挨个对版本。
生态超级丰富 数据库、缓存、安全、消息队列……几乎所有功能都有现成的Starter，引入即用。
生产就绪 健康检查、指标监控、外部化配置等生产级功能开箱即用。

1.1.3 版本怎么选

本教程技术选型说明

本教程采用 Spring Boot 4.1.1 + JDK 17 + IntelliJ IDEA，原因如下：

官方start.spring.io默认就是该版本，无需修改地址、无需额外配置，开箱即用，对新手最友好，避免了旧教程里「改阿里云镜像地址」的额外操作。
JDK 17是当前企业新项目的主流基准，生命周期长，技术栈不过时。
IDEA2025是当前企业主流开发版本，优化了Spring集成、Maven加载和热部署体验，对新手更友好。
核心注解、开发方式与2.x/3.x完全兼容，学会后向下兼容存量项目。

企业版本现状参考

Spring Boot版本	最低JDK要求	企业使用情况
2.7.x	JDK 8	存量项目最多，逐步进入维护期
3.2.x	JDK 17	当前新项目主流，生态成熟
4.1.x	JDK 17	前沿技术栈，逐步普及

新手提示：不要盲目追最新版本，也不用纠结旧版本。先把4.1.1学透，核心原理和开发方式全版本通用，工作中遇到对应版本快速上手即可。

1.2 环境准备：手把手搭环境

工欲善其事，必先利其器。这一步很重要，环境没搭好后面寸步难行。

1.2.1 工具清单

工具	作用	推荐版本	是否必须
JDK	Java开发运行环境	17 LTS	✅ 必须
Maven	依赖管理、项目构建	3.9+	✅ 必须
IntelliJ IDEA	开发IDE	2025.x	✅ 必须
Chrome/Edge	浏览器、接口测试	最新版	✅ 必须
Postman	接口测试工具	最新版	⭐ 强烈推荐
Git	版本控制	最新版	⭐ 推荐

1.2.2 JDK 17安装与验证

Windows安装

下载
- 官方推荐：Eclipse Temurin 17
- 选择Windows x64平台的.msi安装包（图形化安装，新手推荐）
安装
- 双击安装包，一路下一步
- ✅ 勾选 Add to PATH（自动加入系统环境变量）
- 安装路径建议：D:\Java\jdk-17.0.xx，路径不要有中文、空格
配置JAVA_HOME（必须） Maven、IDEA都依赖这个变量：
1. 右键「此电脑」→ 属性 → 高级系统设置 → 环境变量
2. 系统变量 → 新建：
  - 变量名：JAVA_HOME
  - 变量值：JDK 17根目录（如D:\Java\jdk-17.0.12），不要写到bin目录
3. 确认Path中存在%JAVA_HOME%\bin
验证安装 必须完全关闭旧的命令行窗口，打开全新的PowerShell/CMD，执行：
```
java -version
javac -version
echo %JAVA_HOME%
```
看到JDK 17版本号输出即安装成功。

⚠️ 注意：必须安装JDK，不能只装JRE。JRE只能运行程序，不能开发编译。

CentOS 7.9一键安装（服务器部署用）

# 一键安装JDK 17开发版
yum install -y java-17-openjdk-devel

# 验证
java -version
javac -version

YUM安装会自动配置命令软链接，java和javac直接可用。

1.2.3 Maven安装与配置（重点中的重点）

90%新手第一个坑就是Maven没配国内镜像，导致依赖下载慢、下载失败。

下载安装

官网下载：Apache Maven
下载Binary zip archive格式的安装包（如apache-maven-3.9.16-bin.zip）
解压到非系统盘，如D:\maven\apache-maven-3.9.16
配置环境变量：
- 系统变量新建MAVEN_HOME，值为Maven根目录
- Path中添加%MAVEN_HOME%\bin

配置阿里云镜像（必做）

Maven默认从国外中央仓库下载，国内速度极慢，换成阿里云镜像：

打开Maven安装目录下conf/settings.xml文件
找到<mirrors>标签，在里面添加：

<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

配置本地仓库（建议）

默认本地仓库在C盘用户目录，时间长了占用几十个G。在settings.xml的<settings>标签下添加：

<localRepository>D:\maven-repo</localRepository>

验证

打开命令行执行：

mvn -v

输出版本信息即成功。

新手避坑指南

镜像一定要配，不然下载慢到怀疑人生
本地仓库不要放C盘，避免占用系统盘空间
settings.xml要改对位置，不要改错文件
IDEA里要确认Maven路径和配置文件路径，不然配了半天IDEA不用你的配置

1.2.4 IDEA 安装与配置

本教程基于 IntelliJ IDEA 2025.x 版本编写。2025版采用统一安装包，不再区分社区版与旗舰版的独立安装包：核心Java开发、Maven管理、Spring项目创建等基础功能免费开放；高级Spring深度调试、数据库工具、AI辅助等功能需要Ultimate订阅。入门学习阶段免费功能完全够用，且2025版优化了Spring Initializr集成、Maven依赖加载速度和热部署响应速度，对新手更友好。

版本选择

免费核心功能：满足入门学习、接口开发、打包部署全部需求
Ultimate订阅：适合进阶开发，支持数据库工具、高级Spring调试、AI代码助手
学生可通过学校教育邮箱免费申请Ultimate授权：JetBrains学生申请

下载安装

下载地址：IntelliJ IDEA下载选择2025.x正式版，一路下一步安装即可。

核心配置：Maven

打开IDEA，按Ctrl + Alt + S打开设置： Build, Execution, Deployment → Build Tools → Maven

设置项	填写说明
Maven home path	你的Maven安装目录，也可以用IDEA自带的Bundled Maven
User settings file	你的`settings.xml`文件路径，勾选Override
Local repository	你的本地仓库路径，勾选Override

⚠️ 超级重要：很多同学说「我配了镜像怎么还是慢」，结果一看IDEA用的是默认的settings.xml，根本不是你配的那个。这里一定要确认清楚！

其他建议设置

文件编码： Editor → File Encodings，全部设为UTF-8，勾选「Transparent native-to-ascii conversion」
自动导入： Build Tools → Maven → Importing，勾选自动导入Maven项目
字体大小： Editor → Font，字号设为16或18，方便阅读

1.2.5 Postman安装（强烈推荐）

接口测试必备工具，浏览器只能测GET请求，POST等复杂请求必须用Postman。

下载地址：Postman下载
免费版足够入门学习使用。

1.2.6 Git安装（推荐）

版本控制工具，企业开发必备。

下载地址：Git下载
一路下一步安装，默认选项即可
验证：命令行输入git --version，看到版本号即成功。

1.3 动手实践：创建第一个Spring Boot项目

1.3.1 方式一：官方网页版Spring Initializr（全环境通用）

这是Spring官方标准创建方式，不依赖IDEA版本，社区版、旗舰版都能用，也是理解项目生成原理的基础。

为什么直接用官方地址？官方https://start.spring.io/默认就是Spring Boot 4.1.1 + JDK 17，和我们的技术栈完全匹配，无需修改地址，稳定性优于第三方镜像站，对新手最友好。

详细步骤

步骤1：打开官方网站

浏览器访问：https://start.spring.io/ 页面是标准的项目生成表单，所有选项都有默认值。

步骤2：填写项目基本信息

照着下表填写，不用的选项保持默认：

配置项	填写值	说明
Project	Maven Project	用Maven构建项目，Java开发主流
Language	Java	开发语言
Spring Boot	4.1.1	默认选中的最新稳定版，和本教程一致，不用改
Group	com.itheima	组织名，一般是公司域名倒写，学习随便填
Artifact	chapter01-demo	项目名，小写英文，多个单词用横杠分隔
Name	chapter01-demo	项目显示名称，和Artifact一致即可
Description	Spring Boot入门项目	项目描述，随便写
Package name	自动生成	不用改，就是Group + Artifact
Packaging	Jar	打成可执行JAR包，Spring Boot推荐方式
Java	17	默认JDK 17，和我们的环境完全匹配，不用改

💡 新手注意：
Group一般用公司域名倒写，比如com.alibaba，学习阶段随便填即可
Artifact就是项目名，全部小写，不要中文、不要空格

步骤3：选择依赖

点击右侧的 ADD DEPENDENCIES 按钮（或按快捷键Ctrl + B），弹出搜索框，搜索并添加以下3个依赖：

Spring Web：Web开发核心，包含Spring MVC + 内嵌Tomcat + JSON处理
Spring Boot DevTools：热部署工具，改代码不用手动重启
Lombok：简化Java代码，自动生成getter/setter等

选中后会出现在右侧「Selected Dependencies」列表里。

步骤4：生成下载项目

点击页面底部的 GENERATE 按钮（或按Ctrl + Enter），浏览器会自动下载一个zip压缩包，比如chapter01-demo.zip。

步骤5：解压项目

把zip包解压到你存放项目的目录，比如D:\workspace\chapter01-demo。

⚠️ 重要：解压路径不要有中文、不要有空格，否则可能出现各种诡异问题。

步骤6：导入IDEA

打开IDEA → 左上角File → Open
选择刚才解压的项目文件夹，点击OK
IDEA会自动识别这是Maven项目，开始自动下载依赖
等待右下角进度条走完，pom.xml没有红叉，即导入成功。

1.3.2 方式二：IDEA内置Spring Initializr（日常开发推荐）

IDEA深度集成了Spring Initializr，直接在IDE里就能创建，不用去网页，操作更便捷。

步骤

打开IDEA → 新建项目（New Project）
左侧选择 Spring Initializr
填写项目基本信息（和网页版完全一致）
点击下一步，选择依赖（和网页版相同）
选择项目存放位置
点击Finish，IDEA自动创建并导入项目

两种方式最终效果完全一样，日常开发推荐用IDEA内置版，学习原理推荐先过一遍网页版。

1.3.3 方式三：Maven手动创建（理解原理用）

了解即可，实际开发基本都用Initializr。适合无网络环境，或者想深入理解项目结构的场景。

步骤

IDEA → New Project → Maven → 不选Archetype → 填写Group/Artifact → Create
在pom.xml中添加父工程和依赖：

xml

<!-- 继承Spring Boot父工程 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.1</version>
</parent>

<dependencies>
    <!-- Web开发起步依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

编写启动类
右键项目 → Maven → Reload Project，等待依赖下载完成

1.3.4 项目结构深度解析

创建好的项目标准结构如下：

chapter01-demo/
├── .idea/                      # IDEA配置文件，不用管
├── .mvn/                       # Maven Wrapper，了解即可
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/itheima/chapter01/
│   │   │       └── Chapter01DemoApplication.java  # 【核心】项目启动类
│   │   └── resources/
│   │       ├── static/          # 静态资源（CSS、JS、图片、HTML）
│   │       ├── templates/       # 模板页面（Thymeleaf等）
│   │       └── application.properties  # 【核心】配置文件（可改成yml）
│   └── test/
│       └── java/
│           └── com/itheima/chapter01/
│               └── Chapter01DemoApplicationTests.java  # 测试类
├── target/                     # 编译输出、打包结果，自动生成
├── .gitignore                  # Git忽略文件配置
├── mvnw / mvnw.cmd             # Maven Wrapper脚本
└── pom.xml                     # 【核心】Maven配置文件

三个核心文件（必须认识）

文件	作用	重要程度
`Chapter01DemoApplication.java`	项目启动类，程序入口	⭐⭐⭐⭐⭐
`application.properties/yml`	全局配置文件，所有配置都在这里改	⭐⭐⭐⭐⭐
`pom.xml`	Maven配置，管理依赖和构建	⭐⭐⭐⭐⭐

超级重要的提醒

启动类一定要放在最外层的包下面！ 比如启动类在com.itheima.chapter01包下，那你的Controller、Service这些类，都要放在这个包下面或者子包里：

✅ com.itheima.chapter01.controller
✅ com.itheima.chapter01.service
❌ com.itheima.controller（和启动类平级，扫描不到）
❌ com.controller（差更远了）

原因：Spring Boot默认只扫描启动类所在的包及其子包。放错位置，你的类就不会被Spring管理，项目就跑不起来。这是新手最容易犯的错误，没有之一！

1.3.5 pom.xml逐段详解

pom.xml是Maven的核心配置文件，我们逐段拆解：

xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

这一段是XML声明和命名空间，固定写法，不用管。

父工程（非常重要）

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.1</version>
    <relativePath/>
</parent>

你可以把它理解成「基准配置表」：

里面定义了几百个常用依赖的版本号
里面定义了各种插件的版本、编译版本、编码等默认配置
继承它之后，加依赖就不用写版本号了，自动用父工程里的版本
好处：所有依赖的版本都是官方测试过兼容的，不会出现版本冲突

类比：parent就像餐厅的菜单，上面列了所有菜品和价格。你点菜（加依赖）的时候不用自己定价，直接按菜单上的价格来，所有价格都是餐厅定好的，保证搭配合理。

项目基本信息

<groupId>com.itheima</groupId>
<artifactId>chapter01-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>chapter01-demo</name>
<description>Spring Boot入门项目</description>

groupId：组织名（公司域名倒写）
artifactId：项目名
version：版本号，SNAPSHOT表示开发中快照版
三者合起来叫「项目坐标」，唯一标识一个项目。

属性配置

<properties>
    <java.version>17</java.version>
</properties>

定义属性变量，比如JDK版本，后面可以通过${java.version}引用。

依赖列表

xml

<dependencies>
    <!-- Web起步依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 热部署 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

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

    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

每个<dependency>就是一个依赖：

groupId + artifactId：依赖的坐标
version：版本号（继承了parent，所以不用写）
scope：依赖范围
- compile（默认）：编译、测试、运行都需要
- runtime：运行时需要，编译不需要
- test：只有测试需要
- provided：编译测试需要，运行时由容器提供
optional：是否可选，可选的依赖不会向下传递

重点理解：Starter（起步依赖）

spring-boot-starter-web就是一个Starter。什么是Starter？就是一组相关依赖的打包。你加了这一个依赖，Maven会自动把它依赖的所有包都引进来，包括： spring-web、spring-webmvc、jackson-databind（JSON处理）、tomcat-embed-core（内嵌Tomcat）……还有很多。

类比：Starter就像套餐。你点一个「商务套餐A」，里面菜、饭、汤、水果都有了，不用一个个点。而且搭配都是设计好的，保证营养均衡（版本兼容）。

构建插件配置

xml

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

spring-boot-maven-plugin是Spring Boot提供的Maven插件，负责把项目打成可执行的JAR/WAR包。没有这个插件，打出来的jar包不能直接运行。

1.3.6 启动类详解

打开启动类Chapter01DemoApplication.java：

java

package com.itheima.chapter01;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Chapter01DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(Chapter01DemoApplication.class, args);
    }
}

核心就是@SpringBootApplication注解，它是一个组合注解，包含三个核心功能：

注解	作用
`@SpringBootConfiguration`	标记这是一个配置类，就是`@Configuration`的包装
`@EnableAutoConfiguration`	开启自动配置（核心中的核心！）
`@ComponentScan`	组件扫描，扫描启动类所在包及其子包的Bean

main方法里调用SpringApplication.run()，传入启动类的class和命令行参数，就启动了整个应用。

1.3.7 第一次启动项目

启动方式一：IDEA里启动（最常用）

找到启动类，点击行号左边的绿色小三角 → 选Run 'Chapter01DemoApplication' 或者右键类名 → Run 或者快捷键：光标在类里，按Ctrl + Shift + F10

启动方式二：Maven命令启动

打开IDEA下面的Terminal终端，输入：

mvn spring-boot:run

启动成功标志

控制台看到类似输出：

Tomcat started on port 8080 (http) with context path ''
Started Chapter01DemoApplication in 2.345 seconds

端口号：8080（默认）
启动耗时：2秒多

浏览器测试

打开浏览器访问：http://localhost:8080 你会看到Spring Boot默认错误页面（404），别慌，这是正常的！因为我们还没写任何接口，访问根路径当然找不到。能看到这个页面，说明： ✅ Tomcat启动成功了 ✅ Spring Boot应用跑起来了 ✅ 只是没有对应的接口而已

1.4 动手实践：写你的第一个接口

1.4.1 先了解几个基本概念

接口：HTTP API，浏览器访问URL，服务器返回数据。
RESTful风格：用HTTP方法表示对资源的操作：
- GET：查询
- POST：新增
- PUT：修改
- DELETE：删除
Controller：处理请求的类，接收请求、调用业务、返回结果。

1.4.2 第一个接口：Hello World

步骤1：创建controller包

在com.itheima.chapter01包下右键 → New → Package → 输入controller → 回车。

步骤2：创建HelloController类

右键controller包 → New → Java Class → 输入HelloController → 回车。

写入代码：

java

package com.itheima.chapter01.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot!";
    }
}

代码逐行讲解

@RestController：告诉Spring这个类是控制器，方法的返回值直接作为响应体返回（不是跳页面），相当于@Controller + @ResponseBody的组合。
@GetMapping("/hello")：映射GET请求，访问路径是/hello的时候，就会调用这个方法。
方法返回的字符串，会直接作为HTTP响应体返回给浏览器。

步骤3：测试

重启项目，浏览器访问http://localhost:8080/hello，页面显示Hello Spring Boot!即成功。

1.4.3 再写几个接口练练手

例子1：查询参数 @RequestParam

接收URL问号后面的参数：

java

@GetMapping("/hello2")
public String hello2(@RequestParam String name) {
    return "你好，" + name + "！欢迎学习Spring Boot！";
}

测试：http://localhost:8080/hello2?name=张三

可选参数+默认值：

java

@GetMapping("/hello3")
public String hello3(@RequestParam(defaultValue = "陌生人") String name) {
    return "你好，" + name + "！";
}

不传name参数时，默认显示「陌生人」。

例子2：路径参数 @PathVariable

参数在URL路径中，RESTful风格：

@GetMapping("/user/{id}")
public String getUserById(@PathVariable Integer id) {
    return "查询用户，ID：" + id;
}

测试：http://localhost:8080/user/1001

多个路径参数：

@GetMapping("/user/{id}/order/{orderId}")
public String getOrder(@PathVariable Integer id, @PathVariable Long orderId) {
    return "用户" + id + "的订单" + orderId;
}

例子3：返回对象（自动转JSON）

实际开发中大部分接口返回对象，自动转成JSON。

步骤1：创建entity包和User类

新建entity包，创建User类：

java

package com.itheima.chapter01.entity;

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 email;
}

步骤2：写接口

@GetMapping("/user")
public User getUser() {
    return new User(1, "张三", 25, "zhangsan@example.com");
}

步骤3：测试

访问http://localhost:8080/user，自动返回JSON格式数据。这就是starter-web里的Jackson在干活，你什么都不用配，直接返回对象就行。

例子4：返回List集合

java

@GetMapping("/users")
public List<User> getUsers() {
    List<User> users = new ArrayList<>();
    users.add(new User(1, "张三", 25, "zhangsan@example.com"));
    users.add(new User(2, "李四", 28, "lisi@example.com"));
    users.add(new User(3, "王五", 22, "wangwu@example.com"));
    return users;
}

返回JSON数组格式。

例子5：POST请求 @RequestBody

POST请求在请求体里传JSON，适合参数多的场景。

java

@PostMapping("/user")
public String addUser(@RequestBody User user) {
    return "新增用户：" + user.getName() + "，年龄：" + user.getAge();
}

Postman测试

打开Postman，新建请求
方法选POST，URL填http://localhost:8080/user
Body → 选raw → 格式选JSON
输入JSON：

{
    "id": 4,
    "name": "赵六",
    "age": 30,
    "email": "zhaoliu@example.com"
}

点击Send，看到返回结果即成功。

1.4.4 常用注解小结

注解	作用	位置
`@RestController`	标记控制器，返回值直接作为响应体	类上
`@Controller`	标记控制器（返回页面用）	类上
`@ResponseBody`	方法返回值作为响应体	类上或方法上
`@GetMapping`	映射GET请求	方法上
`@PostMapping`	映射POST请求	方法上
`@PutMapping`	映射PUT请求	方法上
`@DeleteMapping`	映射DELETE请求	方法上
`@RequestMapping`	通用映射，可指定方法	类上或方法上
`@RequestParam`	接收URL查询参数	方法参数上
`@PathVariable`	接收路径参数	方法参数上
`@RequestBody`	接收请求体JSON	方法参数上

不用死记，用多了自然就记住了。

1.5 开发利器：让你的开发效率翻倍

1.5.1 Lombok：再也不用写getter/setter

写实体类的时候，getter/setter、构造方法、toString……写起来很烦，字段多的时候几十行重复代码。Lombok通过注解在编译时自动生成这些方法。

安装插件

IDEA已默认集成Lombok支持，无需手动安装插件，直接使用即可。

依赖确认

创建项目的时候已经加了Lombok依赖，pom.xml里有：

xml

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

常用注解

注解	作用
`@Data`	生成getter/setter、toString、equals、hashCode
`@Getter`	只生成getter
`@Setter`	只生成setter
`@ToString`	只生成toString
`@NoArgsConstructor`	生成无参构造方法
`@AllArgsConstructor`	生成全参构造方法
`@Builder`	生成建造者模式
`@Slf4j`	生成日志对象

企业项目基本都用Lombok，能省很多重复代码，一定要学会用。

1.5.2 热部署：改代码不用重启

改了代码就要重启项目，项目大了启动一次几分钟，非常浪费时间。热部署就是改了代码不用手动重启，自动生效。

💡 IDEA优化了运行时编译的响应速度，热部署触发比旧版本更快，修改代码后1-2秒即可生效。

两步配置（缺一不可）

第一步：开启自动构建项目

File → Settings → Build, Execution, Deployment → Compiler
勾选 ✅ Build project automatically（自动构建项目）
点击应用保存。

第二步：开启运行时也允许自动构建（最容易漏掉）

默认情况下项目正在运行时，IDEA会暂停自动编译，改了代码也不会触发更新，必须打开这个开关。

设置中找到 Advanced Settings（高级设置）
勾选 ✅ Allow auto-make to start even if developed application is currently running （即使应用程序当前正在运行，也允许启动自动构建）
点击确定保存全部设置。

验证是否生效

重启Spring Boot项目
随便修改一个Controller的返回字符串
等1-2秒，刷新浏览器，看内容是不是更新了。

补充说明

两个开关分工：
- 「自动构建项目」：开启IDEA的自动编译能力
- 「运行时允许自动构建」：解除「运行时暂停编译」的限制
必须两个同时开启，运行中的项目才能自动编译代码，进而触发devtools热部署。
配置完成后不需要重启IDEA，只需要重启运行中的Spring Boot项目即可。

1.5.3 IDEA常用快捷键（新手必记）

熟练使用快捷键，开发效率提升好几倍。

快捷键	作用	频率
`Ctrl + Alt + L`	格式化代码	⭐⭐⭐⭐⭐
`Ctrl + Alt + O`	优化import，去掉没用的导入	⭐⭐⭐⭐⭐
`Ctrl + D`	复制当前行	⭐⭐⭐⭐⭐
`Ctrl + Y`	删除当前行	⭐⭐⭐⭐⭐
`Ctrl + /`	单行注释/取消注释	⭐⭐⭐⭐⭐
`Ctrl + Shift + /`	多行注释	⭐⭐⭐⭐
`Alt + Enter`	快速修复（万能键！）	⭐⭐⭐⭐⭐
`Ctrl + Shift + F10`	运行当前类	⭐⭐⭐⭐
`Shift + F9`	Debug运行	⭐⭐⭐⭐
`Ctrl + F`	当前文件查找	⭐⭐⭐⭐⭐
`Ctrl + Shift + F`	全局查找	⭐⭐⭐⭐

重点推荐Alt + Enter：IDEA最强大的快捷键，没有之一。代码标红、想生成方法、想导入包，按它就对了！

1.5.4 Debug调试技巧

新手遇到问题不要只会加System.out.println，学会Debug调试才是专业的。

基本操作

代码行号左边点击，加断点（出现小红点）
点击虫子图标，Debug模式启动项目
程序运行到断点的地方会停下来
常用调试键：
- F8：单步执行，一行一行走
- F7：进入方法内部
- Shift + F8：跳出当前方法
- F9：继续运行，到下一个断点
Variables窗口查看当前变量的值

Debug能干嘛

看变量的值对不对
看代码执行流程是不是你想的那样
看异常是从哪抛出来的

遇到问题先Debug，不要瞎猜，这是程序员的基本技能。

1.6 项目规范：从第一天养成好习惯

1.6.1 标准包结构

企业项目标准包结构：

com.itheima.项目名/
├── 项目名Application.java      # 启动类（必须在最外层！）
├── controller/                  # 控制层：接收请求、参数校验、返回结果
├── service/                     # 业务层：业务逻辑处理
│   └── impl/                    # 业务实现类
├── mapper/                      # 数据层：操作数据库
├── entity/                      # 实体类：对应数据库表
├── dto/                         # 数据传输对象：接收前端参数
├── vo/                          # 视图对象：返回给前端的数据
├── config/                      # 配置类
├── exception/                   # 自定义异常
├── common/                      # 公共类、工具类
└── constants/                   # 常量类

1.6.2 三层架构

经典Java Web分层思想：

浏览器 → Controller → Service → Mapper → 数据库

Controller：接收请求、参数校验、调用Service、返回结果。不写业务逻辑。
Service：核心业务逻辑、事务控制。
Mapper：数据库操作，增删改查。

为什么要分层？职责清晰、便于维护、便于测试、团队协作方便。

1.6.3 命名规范

类型	命名规范	示例
包名	全小写，单词间用点分隔	`com.itheima.user.controller`
类名	大驼峰（PascalCase）	`UserController`、`UserService`
方法名	小驼峰（camelCase）	`getUserById`、`addUser`
变量名	小驼峰	`userName`、`maxSize`
常量名	全大写下划线分隔	`MAX_SIZE`、`DEFAULT_PAGE_SIZE`
Controller	业务名 + Controller	`UserController`
Service接口	业务名 + Service	`UserService`
Service实现	业务名 + ServiceImpl	`UserServiceImpl`
Mapper	业务名 + Mapper	`UserMapper`

命名原则：见名知意，不要用拼音，不要用莫名其妙的缩写。

1.6.4 统一返回结果

企业项目所有接口返回格式统一，前端才好处理。一般统一格式：

code：状态码（200成功，其他失败）
message：提示信息
data：返回数据

统一返回结果类

新建common包，创建Result类：

java

package com.itheima.chapter01.common;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
    private Integer code;   // 状态码：200成功，其他失败
    private String message;  // 提示信息
    private T data;         // 返回数据

    // 成功（带数据）
    public static <T> Result<T> success(T data) {
        return new Result<>(200, "操作成功", data);
    }

    // 成功（不带数据）
    public static <T> Result<T> success() {
        return new Result<>(200, "操作成功", null);
    }

    // 失败
    public static <T> Result<T> fail(Integer code, String message) {
        return new Result<>(code, message, null);
    }

    // 失败（默认500）
    public static <T> Result<T> fail(String message) {
        return new Result<>(500, message, null);
    }
}

使用示例

java

@GetMapping("/user/{id}")
public Result<User> getUserById(@PathVariable Integer id) {
    User user = new User(id, "张三", 25, "zhangsan@example.com");
    return Result.success(user);
}

这样所有接口返回格式都统一了，前端处理起来很方便。这是企业项目的标配，一定要养成习惯。

1.7 原理初探：Spring Boot为什么这么神奇

1.7.1 Starter起步依赖原理

Starter本质就是Maven的依赖传递。 Starter本身没有代码，就是一个pom.xml文件，里面声明了一堆依赖。你引入这个Starter，Maven就会把它依赖的所有包都传递进来。

比如引入spring-boot-starter-web，依赖传递后，Spring Web、Spring MVC、Jackson、Tomcat等全都进来了。

为什么版本不会冲突？因为有spring-boot-starter-parent统一管理版本，所有依赖的版本都是官方测试过兼容的。

1.7.2 自动配置原理

自动配置是Spring Boot最核心的功能，核心思想是「约定大于配置」。

简单来说：

@EnableAutoConfiguration开启自动配置
启动时读取所有自动配置类
每个配置类都有条件注解（比如@ConditionalOnClass），满足条件才生效
满足条件的，自动把Bean注册到容器里

比如引入Web Starter，就自动配置视图解析器、文件上传解析器、消息转换器、异常处理器等。如果你自己配置了对应的Bean，自动配置的就不生效，你的优先。

新手不用太纠结原理，刚学的时候知道有这么个东西就行。先会用，用多了再回头看原理，自然就懂了。

1.7.3 启动执行流程

SpringApplication.run()大致做了这几件事：

创建SpringApplication实例，推断Web应用类型
准备环境：加载配置文件、配置参数
打印Banner（启动时的Spring图案）
创建应用上下文ApplicationContext
刷新上下文：初始化所有单例Bean、执行自动配置（最核心）
发布应用启动完成事件

面试常问：Spring Boot启动流程？记住关键词：实例化 → 准备环境 → 创建上下文 → 刷新上下文 → 启动完成。

1.8 单元测试入门

1.8.1 为什么要写单元测试

提前发现Bug，比线上出问题再排查成本低很多
便于回归测试，改完代码跑一遍测试，知道有没有改坏
企业开发基本要求，专业开发者的必备技能

1.8.2 Service层测试

步骤1：写一个Service

创建service包，新建HelloService：

java

package com.itheima.chapter01.service;

import org.springframework.stereotype.Service;

@Service
public class HelloService {
    public String sayHello(String name) {
        return "你好，" + name + "！";
    }

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

步骤2：写测试类

在test目录下创建HelloServiceTest：

java

package com.itheima.chapter01.service;

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.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class HelloServiceTest {

    @Autowired
    private HelloService helloService;

    @Test
    void testSayHello() {
        String result = helloService.sayHello("张三");
        assertEquals("你好，张三！", result);
    }

    @Test
    void testAdd() {
        int result = helloService.add(3, 5);
        assertEquals(8, result);
    }
}

点击方法左边的绿色三角运行，看到绿色对勾即测试通过。

1.8.3 Controller层测试（MockMvc）

测试Controller不用启动完整服务器，用MockMvc模拟请求就行。

java

package com.itheima.chapter01.controller;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void testHello() throws Exception {
        mockMvc.perform(get("/hello"))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello Spring Boot!"));
    }
}

1.9 项目打包与运行

1.9.1 打成JAR包（推荐）

这是Spring Boot推荐的方式，也是企业最常用的。可执行JAR包（也叫fat jar）把你的代码、所有依赖、内置Tomcat都打进一个包里，一个文件就是一个完整应用。

打包步骤

方式一：IDEA图形化操作

右侧Maven面板 → 展开项目 → Lifecycle
先双击clean清理旧的编译结果
再双击package打包

方式二：命令行

# 打包（会跑测试）
mvn clean package

# 跳过测试打包（开发常用，省时间）
mvn clean package -DskipTests

打包成功后，target目录下生成.jar文件。

运行JAR包

java -jar chapter01-demo-0.0.1-SNAPSHOT.jar

指定端口运行：

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

Linux服务器后台运行

生产环境不能前台运行，关闭终端就停了：

# 后台运行，日志输出到app.log
nohup java -jar chapter01-demo.jar > app.log 2>&1 &

nohup：不挂断运行，关闭终端也不停止
> app.log：标准输出重定向到文件
2>&1：错误日志也重定向到同一文件
&：后台运行

查看日志：

# 实时查看日志
tail -f app.log

# 查看最后100行
tail -100 app.log

停止应用：

# 查找进程号
ps -ef | grep chapter01-demo

# 杀掉进程
kill -9 进程号

1.9.2 打成WAR包（了解即可）

老项目用外部Tomcat部署时使用，新项目不推荐。

改造步骤

pom.xml修改打包方式：<packaging>war</packaging>
排除内置Tomcat
启动类继承SpringBootServletInitializer
打包后放到外部Tomcat的webapps目录运行

1.9.3 JAR vs WAR对比

对比项	JAR包	WAR包
运行方式	java -jar直接运行	部署到外部Tomcat
内嵌Tomcat	有	没有
部署难度	简单，一个文件	稍复杂
访问路径	直接根路径	要加项目名
适用场景	新项目、微服务、容器化	老项目兼容、传统部署
企业趋势	越来越多	逐步减少

1.10 新手常见问题与排查

问题1：启动报错，端口被占用

症状：提示Port 8080 was already in use 解决：

方法一：改端口，配置文件加server.port=8081

方法二：杀掉占用端口的进程

# Windows查找占用8080端口的进程
netstat -ano | findstr 8080
# 杀掉进程
taskkill /f /pid 进程号

问题2：访问接口404

可能原因（按概率排序）：

Controller放错包了（最常见！），不在启动类的子包下
URL路径写错了，大小写、斜杠不对
项目没启动成功，控制台有报错
注解写错了，写成@Controller而不是@RestController

问题3：Maven依赖下载慢/失败

排查步骤：

检查settings.xml里的阿里云镜像配了没
检查IDEA的Maven设置是不是用的你配的那个settings.xml
右键项目 → Maven → Reload Project，重新下载
检查网络

问题4：热部署不生效

排查步骤：

检查DevTools依赖加了没
检查自动编译勾了没
检查运行时允许自动构建勾了没
改的是不是方法体？改方法签名、加新类需要重启
是不是用的Debug模式？Debug模式更灵敏

问题5：中文乱码

解决：

IDEA文件编码全部设为UTF-8
配置文件加编码配置：

spring:
  http:
    encoding:
      charset: UTF-8
      enabled: true
      force: true

问题6：@Value注入失败

可能原因：

配置key写错了
类不是Spring管理的（没加@Component等注解）
配置文件位置不对

问题7：启动类找不到

原因：启动类放错位置，或者包名不对解决：确保启动类在最外层包下，类上有@SpringBootApplication注解

问题8：返回日期格式不对

解决：配置文件加：

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

1.11 本章小结

本章我们从基础概念到动手实践，完整走完了Spring Boot入门的全流程：

基础认知：Spring Boot是什么、为什么好用、版本选型
环境搭建：JDK、Maven、IDEA、工具链
项目创建：三种创建方式、项目结构、pom.xml详解
接口开发：GET/POST请求、参数接收、返回JSON
效率工具：Lombok、热部署、快捷键、Debug
项目规范：包结构、三层架构、命名规范、统一返回
原理初探：Starter、自动配置、启动流程
单元测试、打包部署、常见问题排查

1.12 动手实践清单

把这些都做一遍，确认自己掌握了：

实践项	做完打勾
能独立安装配置JDK 17和Maven，配置阿里云镜像	☐
能用官方start.spring.io创建Spring Boot项目	☐
能用IDEA内置Initializr创建项目	☐
能说出项目结构里每个关键文件的作用	☐
能看懂pom.xml里的主要内容	☐
能启动项目，看到启动成功的日志	☐
能写简单的GET接口	☐
能写带@RequestParam参数的接口	☐
能写带@PathVariable路径参数的接口	☐
能返回对象，看到JSON结果	☐
能写POST接口，用@RequestBody接收JSON	☐
会用Postman测试接口	☐
会用Lombok的@Data注解	☐
能配置热部署并验证生效	☐
知道IDEA常用快捷键	☐
会用Debug调试	☐
能写简单的单元测试	☐
能打成JAR包并运行	☐
能排查常见的新手问题	☐

1.13 本章课后作业

一、基础必做题（全员必做）

所有题目必须独立动手完成，光看不算会，敲完代码跑通才算掌握。

环境搭建验证
- 完成JDK 17、Maven、IDEA的安装与配置
- 配置Maven阿里云镜像和本地仓库
- 命令行分别执行 java -version、javac -version、mvn -v，截图保存验证结果
两种方式创建项目
- 方式一：通过官方 start.spring.io 网页创建Spring Boot 4.1.1项目
- 方式二：通过IDEA内置Spring Initializr创建项目
- 两个项目都添加Spring Web、Spring Boot DevTools、Lombok三个依赖
- 分别启动项目，控制台出现「Tomcat started on port 8080」即为成功，截图保存启动日志
用户管理接口开发 在项目中编写用户管理相关接口，要求：
- 创建entity包，编写User实体类，包含id、name、age、email四个属性，使用Lombok简化代码
- 创建common包，编写统一返回结果Result类
- 创建controller包，编写UserController，实现以下接口：
  1. GET /hello：返回字符串 Hello Spring Boot 2025!
  2. GET /user/{id}：路径参数接收用户ID，返回对应ID的User对象
  3. GET /users：返回包含3条模拟用户数据的List集合
  4. POST /user：接收JSON格式的用户信息，返回「新增用户成功」提示
- 所有接口统一返回Result格式
热部署配置与验证
- 在IDEA中完成自动编译、运行时自动构建两项配置
- 修改接口返回值，不手动重启项目，刷新浏览器能看到更新结果
- 截图验证热部署生效
打包与独立运行
- 将项目打成可执行JAR包
- 关闭IDEA，单独打开命令行启动JAR包
- 浏览器访问接口验证功能正常
- 截图保存命令行启动日志和接口访问结果

二、进阶选做题（学有余力完成）

Service层与单元测试
- 创建service包，编写UserService业务类
- 编写对应的单元测试类，使用@SpringBootTest，断言方法返回结果符合预期
参数校验
- 引入spring-boot-starter-validation依赖
- 给User实体添加校验注解：id非空、姓名长度2-20、年龄0-150、邮箱格式正确
- Controller接口添加@Valid触发校验
全局异常处理
- 编写全局异常处理器GlobalExceptionHandler
- 捕获参数校验异常、业务异常，统一返回Result格式错误信息

三、思考题

为什么Spring Boot项目可以直接通过java -jar运行？内置Tomcat的原理是什么？
pom.xml中添加依赖为什么不用写版本号？spring-boot-starter-parent父工程的作用是什么？
Controller必须放在启动类的子包下才能生效，这是为什么？如果放错了包有什么办法解决？

1.14 下一步学习方向

下一章我们会深入学习Spring Boot的配置体系，包括：

YAML配置文件语法
读取配置的三种方式
多环境配置管理
自定义配置绑定
静态资源、全局异常处理
参数校验

配置是Spring Boot的核心，掌握好配置才能真正用好Spring Boot。加油，我们下一章见！

第1章 Spring Boot开发入门 ​

学习建议 ​

1.1 先搞明白：我们要学的到底是啥 ​

1.1.1 从Java Web到Spring Boot的进化史 ​

1.1.2 Spring Boot的核心优势 ​

1.1.3 版本怎么选 ​

本教程技术选型说明 ​

企业版本现状参考 ​

1.2 环境准备：手把手搭环境 ​

1.2.1 工具清单 ​

1.2.2 JDK 17安装与验证 ​

Windows安装 ​

CentOS 7.9一键安装（服务器部署用） ​

1.2.3 Maven安装与配置（重点中的重点） ​

下载安装 ​

配置阿里云镜像（必做） ​

配置本地仓库（建议） ​

验证 ​

新手避坑指南 ​

1.2.4 IDEA 安装与配置 ​

版本选择 ​

下载安装 ​

核心配置：Maven ​

其他建议设置 ​

1.2.5 Postman安装（强烈推荐） ​

1.2.6 Git安装（推荐） ​

1.3 动手实践：创建第一个Spring Boot项目 ​

1.3.1 方式一：官方网页版Spring Initializr（全环境通用） ​

详细步骤 ​

步骤1：打开官方网站 ​

步骤2：填写项目基本信息 ​

步骤3：选择依赖 ​

步骤4：生成下载项目 ​

步骤5：解压项目 ​

步骤6：导入IDEA ​

1.3.2 方式二：IDEA内置Spring Initializr（日常开发推荐） ​

步骤 ​

1.3.3 方式三：Maven手动创建（理解原理用） ​

步骤 ​

1.3.4 项目结构深度解析 ​

三个核心文件（必须认识） ​

超级重要的提醒 ​

1.3.5 pom.xml逐段详解 ​

父工程（非常重要） ​

项目基本信息 ​

属性配置 ​

依赖列表 ​

重点理解：Starter（起步依赖） ​

构建插件配置 ​

1.3.6 启动类详解 ​

1.3.7 第一次启动项目 ​

启动方式一：IDEA里启动（最常用） ​

启动方式二：Maven命令启动 ​

启动成功标志 ​

浏览器测试 ​

1.4 动手实践：写你的第一个接口 ​

1.4.1 先了解几个基本概念 ​

1.4.2 第一个接口：Hello World ​

步骤1：创建controller包 ​

步骤2：创建HelloController类 ​

代码逐行讲解 ​

步骤3：测试 ​

1.4.3 再写几个接口练练手 ​

例子1：查询参数 @RequestParam ​

例子2：路径参数 @PathVariable ​

例子3：返回对象（自动转JSON） ​

步骤1：创建entity包和User类 ​

步骤2：写接口 ​

步骤3：测试 ​

例子4：返回List集合 ​

例子5：POST请求 @RequestBody ​

Postman测试 ​

1.4.4 常用注解小结 ​

1.5 开发利器：让你的开发效率翻倍 ​

1.5.1 Lombok：再也不用写getter/setter ​

安装插件 ​

依赖确认 ​

常用注解 ​

1.5.2 热部署：改代码不用重启 ​

两步配置（缺一不可） ​

第1章 Spring Boot开发入门

学习建议

1.1 先搞明白：我们要学的到底是啥

1.1.1 从Java Web到Spring Boot的进化史

1.1.2 Spring Boot的核心优势

1.1.3 版本怎么选

本教程技术选型说明

企业版本现状参考

1.2 环境准备：手把手搭环境

1.2.1 工具清单

1.2.2 JDK 17安装与验证

Windows安装

CentOS 7.9一键安装（服务器部署用）

1.2.3 Maven安装与配置（重点中的重点）

下载安装

配置阿里云镜像（必做）

配置本地仓库（建议）

验证

新手避坑指南

1.2.4 IDEA 安装与配置

版本选择

下载安装

核心配置：Maven

其他建议设置

1.2.5 Postman安装（强烈推荐）

1.2.6 Git安装（推荐）

1.3 动手实践：创建第一个Spring Boot项目

1.3.1 方式一：官方网页版Spring Initializr（全环境通用）

详细步骤

步骤1：打开官方网站

步骤2：填写项目基本信息

步骤3：选择依赖

步骤4：生成下载项目

步骤5：解压项目

步骤6：导入IDEA

1.3.2 方式二：IDEA内置Spring Initializr（日常开发推荐）

步骤

1.3.3 方式三：Maven手动创建（理解原理用）

步骤

1.3.4 项目结构深度解析

三个核心文件（必须认识）

超级重要的提醒

1.3.5 pom.xml逐段详解

父工程（非常重要）

项目基本信息

属性配置

依赖列表

重点理解：Starter（起步依赖）

构建插件配置

1.3.6 启动类详解

1.3.7 第一次启动项目

启动方式一：IDEA里启动（最常用）

启动方式二：Maven命令启动

启动成功标志

浏览器测试

1.4 动手实践：写你的第一个接口

1.4.1 先了解几个基本概念

1.4.2 第一个接口：Hello World

步骤1：创建controller包

步骤2：创建HelloController类

代码逐行讲解

步骤3：测试

1.4.3 再写几个接口练练手

例子1：查询参数 @RequestParam

例子2：路径参数 @PathVariable

例子3：返回对象（自动转JSON）

步骤1：创建entity包和User类

步骤2：写接口

步骤3：测试

例子4：返回List集合

例子5：POST请求 @RequestBody

Postman测试

1.4.4 常用注解小结

1.5 开发利器：让你的开发效率翻倍

1.5.1 Lombok：再也不用写getter/setter

安装插件

依赖确认

常用注解

1.5.2 热部署：改代码不用重启

两步配置（缺一不可）