Spring 入门教程：给会 Python 后端、准备转 Java 全栈的人

如果你已经写过 Flask、FastAPI 这类 Python 后端，第一次接触 Spring 时最常见的痛点不是“完全看不懂”，而是总觉得概念很多、名词很重、体系边界不清楚。

这篇文章的目标不是给你一份资料清单，而是先把 Spring 这套东西讲成一条能顺着读下去的主线：它和你熟悉的 Python Web 框架有什么映射关系，为什么现代 Java 后端几乎都从 Spring Boot 起步，以及入门阶段到底该先掌握哪些东西。

这是这组 Spring 系列的第 1 篇，适合先建立整体认知，再进入后面的项目实战。

系列顺序如下：

这篇：Spring 入门认知
下一篇：从 0 搭一个最小 REST 服务
然后：把最小项目升级成更像真实项目的版本
最后：用 JPA + H2 把项目真正落库

这不是一份“只告诉你看什么”的目录。

这是一份真正可以直接读下去的 Spring 入门教程，目标是帮你建立一套完整但不过载的入门认知。

适合你的背景：

你会 Java，但有一段时间没系统写 Java 后端
你熟悉 Flask、FastAPI 或其他 Python Web 框架
你不是零基础程序员，你只是对 Spring 体系不熟
你想先入门单体项目，不准备先学微服务

这份文档重点覆盖：

Java Web 背景
Spring Core
Spring MVC
Spring Boot
数据访问与事务基础

不覆盖：

Spring Cloud
微服务治理
响应式编程
大量中间件整合

1. 先建立整体认知

如果你以前写过 Flask 或 FastAPI，那你其实已经有后端开发的核心心智了：

请求进来
路由分发
业务处理
调数据库
返回响应

Spring 不是重新发明这一切。

Spring 更像是把 Java 后端开发里的这些能力做成了一套非常完整、非常工程化的体系。

你可以先这样粗略理解：

1 2	Flask / FastAPI：轻量、直接、上手快 Spring：体系更重，但工程能力、组织能力、扩展能力更强

1.1 Spring 家族里你现在最需要关心的三个词

你现在最需要先分清下面三个东西：

Spring Framework
Spring MVC
Spring Boot

Spring Framework 是什么

它是基础框架。

最核心的能力是：

IoC 容器
依赖注入
AOP
事务
Web 开发支持

如果只说一句话：

Spring Framework 是底层框架能力集合。

Spring MVC 是什么

它是 Spring 体系里的 Web MVC 框架。

它负责：

接收 HTTP 请求
路由分发
参数绑定
调用控制器
返回页面或 JSON

如果只说一句话：

Spring MVC 是 Spring 的 Web 层方案。

Spring Boot 是什么

它不是替代 Spring。

它是基于 Spring 的快速启动和自动装配方案。

它的作用是：

帮你快速搭好项目骨架
自动装配大量基础设施
减少样板配置
让你更快启动一个可运行项目

如果只说一句话：

Spring Boot 是现代 Spring 项目的默认起步方式。

1.2 你应该怎样理解它们的关系

最简单的理解方式：

1
2
3

Spring Framework = 基础能力
Spring MVC = Web 开发能力
Spring Boot = 快速组装和启动能力

或者这样记：

1
2
3

Spring 提供零件
Spring MVC 提供 Web 这套零件
Spring Boot 帮你把车先装起来

2. 先补一点 Java 背景，但只补 Spring 真会用到的部分

你不需要重新从头学整本 Java。

但 Spring 有三块 Java 基础是一定会反复碰到的：

Maven
注解
JDBC

2.1 Maven：Java 世界的依赖和构建工具

Python 里你对这套东西不会陌生：

pip install
requirements.txt
pyproject.toml

Java 里对应的关键角色之一就是 Maven。

它主要做三件事：

管依赖
统一项目结构
负责构建、测试、打包

一个典型的 pom.xml 看起来像这样：

<project>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

这里你先不用死记所有标签，只需要知道：

groupId：组织或公司名
artifactId：项目名
version：版本
dependencies：依赖列表

你现在要掌握到什么程度

能看懂 pom.xml 是项目依赖配置
知道 Spring Boot 项目通常用 Maven 或 Gradle
知道 starter 是 Spring Boot 常见依赖包组织方式

2.2 注解：Spring 为什么这么依赖它

Spring 代码里到处都是注解，比如：

@RestController
@Service
@Autowired
@Configuration
@Bean
@Transactional

所以如果你对注解不熟，会觉得 Spring 非常像魔法。

注解是什么

注解是给编译器、框架、运行时工具读取的元数据。

它不是普通注释。

例如：

1
2
3

@Service
public class UserService {
}

这段代码的意思不是“给人看这是服务类”。

它更重要的意思是：

Spring 会读取这个注解
Spring 会把这个类当作一个 Bean 来管理

所以你可以先记住：

在 Spring 里，很多注解都不是装饰性的，而是有实际行为影响的。

2.3 JDBC：为什么你即使不用原生 JDBC，也最好知道它

你可以把 JDBC 理解成 Java 访问关系型数据库的底层标准接口。

最原始的时候，Java 代码连数据库大概会像这样：

Connection connection = DriverManager.getConnection(url, username, password);
PreparedStatement statement = connection.prepareStatement("select * from users where id = ?");
statement.setLong(1, 1L);
ResultSet resultSet = statement.executeQuery();

这类代码会很繁琐，所以后面才会出现：

JdbcTemplate
MyBatis
JPA / Hibernate

Spring 后面的数据库整合，本质上就是在这个基础上继续往上封装。

所以你现在知道这件事就够了：

Spring 的数据库能力不是凭空来的
它底层仍然要和数据库驱动、连接、SQL 这些东西打交道

3. Java Web 背景：Spring MVC 不是从天上掉下来的

很多人直接学 Spring MVC，会把它当成“天生就该这么写”。

但你稍微知道一点 Java Web 演进史，就会更容易理解它为什么长这样。

3.1 先看最原始的 Java Web 思路

早期 Java Web 开发里，一个很核心的东西是 Servlet。

它大致像这样：

public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().write("hello");
    }
}

它的问题不是不能用。

它的问题是：

路由组织不够优雅
参数绑定很原始
业务代码容易和 Web 细节混在一起
项目一大就很难维护

所以后面才会逐步演进出 MVC 分层思路。

3.2 MVC 思想先怎么理解

MVC 最粗略的理解：

Model：数据和业务对象
View：页面展示
Controller：接请求、调业务、返回结果

在现代前后端分离接口项目里，你可以把“View”弱化成“响应结果”。

也就是说，Spring MVC 在很多接口项目里更常见的落地方式是：

Controller 接 HTTP 请求
Service 处理业务
Repository / DAO 负责数据访问
最后返回 JSON

4. Spring Core：整个 Spring 体系真正的地基

很多人一提 Spring，第一反应是“写接口”。

其实这不是 Spring 最核心的东西。

Spring 最核心的是：

IoC
依赖注入
Bean 管理

4.1 IoC 先怎么理解

IoC 是 Inversion of Control，控制反转。

你先别被名字吓到。

最朴素的理解是：

以前对象自己创建依赖
现在对象依赖由容器来提供

例如没有 Spring 时你可能会这样写：

1
2
3

public class UserController {
    private UserService userService = new UserService();
}

Spring 的思路是反过来：

UserController 不自己 new UserService()
容器负责创建 UserService
容器再把它注入给 UserController

这就是“控制权从业务代码手里转交给容器”的核心感觉。

4.2 Bean 是什么

在 Spring 里，Bean 本质上就是：

被 Spring 容器管理的对象。

比如：

Controller
Service
Repository
配置类里声明出来的对象

都可能是 Bean。

一句话记忆：

1	普通对象 + 交给 Spring 管 = Bean

4.3 依赖注入为什么重要

依赖注入不是为了“少写几行 new”。

它更重要的价值是：

降低对象之间的耦合
更容易替换实现
更容易测试
更适合大型项目组织

例如：

@RestController
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }
}

这里的意思是：

UserController 依赖 UserService
但它不负责自己创建 UserService
由 Spring 注入进来

4.4 `@Component`、`@Service`、`@Repository`、`@Controller` 大概怎么分

它们都可以理解成“把类交给 Spring 管”的组件注解。

只是语义不同：

@Component：通用组件
@Service：业务服务层
@Repository：数据访问层
@Controller / @RestController：Web 层

例如：

1
2
3

@Service
public class UserService {
}

你可以理解成：

这是一个 Spring 组件
Spring 可以扫描并管理它
它在语义上属于业务层

4.5 `@Bean` 又是什么

有些类不是你自己写业务逻辑的组件，但你仍然希望把它交给 Spring 管理。

这时常见写法是：

用 @Configuration 声明配置类
用 @Bean 声明要交给 Spring 容器的对象

例如：

@Configuration
public class AppConfig {

    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper();
    }
}

4.6 Spring 为什么会让人觉得“像魔法”

因为你看到的是：

好像没 new
好像没手工注册
好像很多东西自动就连起来了

但本质上只是：

容器在启动时扫描和注册组件
识别依赖关系
在合适时机把对象组装起来

所以你真正要理解的不是“记住每个魔法注解”，而是：

Spring 核心是容器在管理对象和对象关系。

4.7 为什么不推荐到处自己 `new`

如果你在 Spring 项目里到处自己 new，常见后果是：

这个对象不受 Spring 管理
注入、事务、AOP 等能力可能失效
测试和替换实现会更麻烦

所以 Spring 风格里一个重要思维转变就是：

业务类尽量交给容器
对象关系尽量通过依赖注入表达

5. AOP 和事务：先建立“它解决什么问题”的认知

很多入门文章会很快提到 AOP，但第一次学不一定要钻实现细节。

你先知道它解决什么问题更重要。

5.1 AOP 是干什么的

AOP 是 Aspect-Oriented Programming，面向切面编程。

它适合处理一些“横切关注点”，比如：

日志
权限
事务
监控

所谓横切，就是：

这些逻辑会出现在很多业务方法周围
但它们本身又不属于某一个业务本体

5.2 为什么事务常和 AOP 一起出现

例如你写一个转账方法：

@Transactional
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    ...
}

你真正写的业务逻辑只是转账流程。

但 Spring 往往会通过 AOP / 代理机制，在调用这个方法前后帮你处理事务边界。

所以你先记住这件事：

@Transactional 背后经常和代理/AOP 机制有关
你不需要一开始就把代理细节学透
但要知道它不是“普通注释”

6. Spring MVC：现代 Java Web 接口开发主线

如果你是做后端接口开发，Spring MVC 是你最早会高频接触的部分。

6.1 `DispatcherServlet` 先怎么理解

你可以把它理解成 Spring MVC 的总入口。

请求进来后，大致流程是：

先到 DispatcherServlet
找到匹配的处理器方法
做参数绑定
调用 Controller
处理返回值
渲染成页面或 JSON 响应

你不需要死记所有内部组件名，但要知道：

Spring MVC 是一套完整的请求分发和处理机制，不只是几个注解。

6.2 `@RestController` 是什么

你后面会经常看到：

@RestController
@RequestMapping("/users")
public class UserController {
}

@RestController 可以先理解成：

这是一个 Web 控制器
返回值通常直接作为响应体
常用于 JSON 接口

6.3 路由注解怎么理解

常见的有：

@RequestMapping
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping

例如：

@GetMapping("/{id}")
public UserDTO getUser(@PathVariable Long id) {
    ...
}

它表达的是：

这是一个 GET 请求处理方法
路径里有一个 id
id 会绑定到方法参数上

6.4 参数绑定：Spring MVC 很重要的一块体验

Spring MVC 很强的一点就是参数绑定。

你会经常看到下面几种：

`@PathVariable`

用于接路径参数：

@GetMapping("/{id}")
public UserDTO getUser(@PathVariable Long id) {
    ...
}

`@RequestParam`

用于接查询参数：

@GetMapping
public List<UserDTO> listUsers(@RequestParam(defaultValue = "1") int page) {
    ...
}

`@RequestBody`

用于接 JSON 请求体：

@PostMapping
public UserDTO createUser(@RequestBody CreateUserRequest request) {
    ...
}

6.5 返回 JSON 是怎么发生的

你返回的是一个 Java 对象，不是手工拼 JSON。

Spring MVC 会结合消息转换器，把对象序列化成 JSON。

所以接口开发里，你可以理解成：

你返回 Java 对象
Spring 帮你转换成 HTTP 响应内容

6.6 Filter 和 Interceptor 先怎么区分

很多人刚学时会把这两个混在一起。

你可以先粗略记：

Filter 更靠近 Servlet 层
Interceptor 更靠近 Spring MVC

通常：

Filter 适合做更通用、更底层的请求处理
Interceptor 更适合做和 Controller 调用链相关的逻辑

例如：

非 Spring MVC 专属的通用过滤逻辑
编码、基础审计、跨域等更底层逻辑

它更靠近 Spring MVC。

一句话记忆：

1 2	Filter 更靠近 Servlet Interceptor 更贴近 Spring MVC

7. Spring Boot：为什么现代 Spring 项目几乎都从它开始

学完前面的 Spring Core 和 Spring MVC，再看 Spring Boot 就容易多了。

7.1 Spring Boot 到底解决了什么问题

Spring Framework 很强，但过去自己搭一个项目会比较重：

XML 配置很多
基础设施要自己配
起项目成本高
新人很难快速跑起来

Spring Boot 主要解决的是：

快速初始化项目
自动配置常见基础设施
提供统一的 starter 依赖组织方式
降低启动和工程化门槛

7.2 为什么它不是“只是更省事”

它不只是“帮你少写几行配置”。

而是“现代 Spring 项目的默认工程化入口”。

7.3 `@SpringBootApplication` 是什么

一个最小 Spring Boot 应用通常长这样：

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

`@SpringBootApplication`

你现在先记住它的实际作用：

它告诉 Spring Boot：这是应用主入口配置类
它会触发自动配置、组件扫描等关键机制

`SpringApplication.run(...)`

它会：

创建 Spring 容器
处理配置
启动内嵌服务器

这是 Spring Boot 最关键的概念之一。

7.4 自动配置到底在做什么

Spring Boot 会根据你引入的依赖，推断你想做什么，然后自动帮你配好很多基础设施。

例如你加了：

spring-boot-starter-web

它就会倾向于帮你准备：

Spring MVC
JSON 处理
内嵌 Tomcat

所以最简单的理解是：

你声明意图，Spring Boot 帮你补齐常见基础配置。

7.5 `starter` 是什么

Spring Boot 常见依赖名里经常有 starter。

你可以把它理解成：

按场景打包好的一组常用依赖

例如：

想做 Web，就加 starter-web
想做 JPA，就加 starter-data-jpa

这会让项目起步非常快。

7.6 配置文件怎么理解

Spring Boot 项目里很常见的配置方式是：

application.properties
application.yml

例如：

server:
  port: 8080

spring:
  application:
    name: demo

这些配置会影响：

端口
数据源
日志
profile
第三方中间件

7.7 `profile` 是做什么的

很多项目会区分：

开发环境
测试环境
生产环境

Spring Boot 常用 profile 来区分这些环境。

你现在只要知道：

不同环境可以有不同配置
这是工程化里非常重要的一块

7.8 为什么官方脚手架很重要

如果你刚入门，最推荐的起步方式是 start.spring.io。

因为它会直接帮你生成一个标准 Spring Boot 项目骨架。

这能帮你避开很多“项目还没开始，环境和结构就先乱了”的问题。

8. 一个最小 Spring Boot REST 项目应该长什么样

现在把前面的认知拼起来，你会更容易看懂一个最小项目。

项目结构大概会像这样：

src/main/java/com/example/demo
├── DemoApplication.java
├── controller
│   └── UserController.java
├── service
│   └── UserService.java
└── dto
    ├── CreateUserRequest.java
    └── UserDTO.java

8.1 启动类

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

8.2 Controller

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
}

8.3 Service

@Service
public class UserService {

    public UserDTO getUser(Long id) {
        return new UserDTO(id, "ash");
    }
}

8.4 这已经说明了什么

它已经体现了 Spring 入门最关键的几件事：

容器管理组件
Controller 接请求
Service 承担业务逻辑
参数绑定和 JSON 返回都由框架支撑

9. 数据访问：你要知道 Spring 怎么碰数据库

入门阶段你不一定马上实战数据库。

但你必须知道 Java 项目里数据库访问大概在什么层发生。

9.1 最原始路线：JDBC

最底层是 JDBC。

它能直接连数据库、发 SQL、拿结果。

但代码会比较重。

9.2 再往上：更高层的封装

常见会看到这些路线：

JdbcTemplate
MyBatis
JPA / Hibernate

9.3 JPA 和 MyBatis 先怎么理解

JPA

更偏对象映射。

特点通常是：

Spring 生态集成度很高
开发速度快
适合先跑通主线

MyBatis

更偏 SQL 可控。

特点通常是：

SQL 写得更明确
对复杂查询控制感更强
国内项目里很常见

9.4 你现在不用立刻二选一

你现在最需要知道的是：

数据访问应该有独立层次
不要把所有数据库逻辑塞进 Controller

10. 事务：为什么它是后端核心能力

事务是 Java 后端里非常核心的能力之一。

例如转账场景：

A 扣钱成功
B 加钱失败

如果没有事务，数据就不一致了。

10.1 事务最核心要解决什么

一句话：

保证一组操作要么都成功，要么都失败

10.2 Spring 里最常见的事务写法

你后面很常看到：

@Transactional
public void createOrder(...) {
    ...
}

入门阶段先记住：

Spring 常用 @Transactional 管事务
它通常加在 Service 层方法上更合理

11. 把你熟悉的 Python 后端经验映射到 Spring

如果你已经有 Python 后端经验，这一步很重要。

因为很多概念你并不是“第一次学”，而是在“换一种工程化表达”。

11.1 一个粗略映射表

你熟悉的 Python 概念	Spring 里常见对应感受
Flask/FastAPI 路由函数	Controller 方法
请求对象/参数解析	`@PathVariable` / `@RequestParam` / `@RequestBody`
依赖注入机制	Spring 容器 + DI
ORM / DB 层	JPA / MyBatis / Repository
装饰器式能力	AOP / 注解驱动
配置文件	`application.yml`

11.2 最重要的思维切换是什么

Python 框架里很多东西你可以很直接地组织。

Spring 则把依赖注入做成了整个框架的基础设施。

所以你要适应的是：

更强调分层
更强调容器管理
更强调工程化组织

11.3 哪些东西不要硬类比

也不要把所有概念生硬映射。

例如：

Interceptor 更靠近 Spring MVC
AOP 也不只是“Java 版装饰器”

类比只是帮助你上手，不是让你忽略 Spring 自己的设计。

12. 一条更适合你的学习顺序

如果你的背景是“会 Python 后端、准备补 Java 全栈”，那我更建议按下面顺序学：

Maven基础
注解和依赖注入
Servlet / Java Web 背景
Spring Core
Spring MVC
Spring开发
Spring Boot开发
第一个Spring Boot应用
参数绑定和JSON返回
配置文件
数据库访问基础
事务

如果你是按课程或资料章节看，也可以大致对照：

使用Spring MVC
Spring Boot开发
第一个Spring Boot应用
集成JPA
集成MyBatis
打包Spring Boot应用

12.1 官方资料怎么用更高效

再读 Spring 官方这几篇：

Building an Application with Spring Boot
Developing Your First Spring Boot Application

会更有感觉。

因为这时你已经知道：

它们在解决什么问题
每个概念在整个体系里的位置

13. 学的时候怎么避免“看懂了，但不会做”

这是很多人真正卡住的点。

你可以每学完一块，就做一个很小的输出。

例如学完 Spring Core 可以写：

Bean 是什么
为什么不推荐到处自己 new
依赖注入解决了什么问题

学完 Spring MVC 可以写：

一个 GET 接口怎么接参数
一个 POST 接口怎么接 JSON
为什么返回对象能自动变成 JSON

这会让你的理解从“看过”变成“能说清楚”。

14. 入门时最常见的误区

14.1 一上来只学 Spring Boot，不学 Spring Core

这会让你项目能跑，但不理解容器和依赖注入。

后面一遇到复杂问题就会很虚。

14.2 一上来就学微服务

这基本等于主线还没打通，就先把复杂度拉满。

14.3 只背注解，不理解请求和对象是怎么流动的

这样写代码会非常机械。

14.4 想一次把整个 Spring 生态学完

没必要。

先把下面几条主线打通更重要：

Spring Core
Spring MVC
Spring Boot
数据访问基础
事务

15. 读完这篇后，你至少应该能回答什么

读完这篇，你至少应该能比较清楚地回答下面这些问题：

Spring Framework、Spring MVC、Spring Boot 分别是什么
IoC 和依赖注入在解决什么问题
Bean 是什么
为什么 Spring 里不推荐到处自己 new
@RestController 和 @Controller 有什么区别
@GetMapping、@PostMapping 是做什么的
@RequestBody、@PathVariable、@RequestParam 分别解决什么问题
@Transactional 一般放在哪里，为什么
application.yml 和 profile 是干什么的
一个最小 Spring Boot 接口项目通常有哪些层

16. 入门后的下一步应该是什么

这篇文章的目标是帮你入门，不是帮你一次学到工作全部细节。

如果你已经读完这篇，最适合接着看的就是这组系列的第 2 篇：Spring 第一个项目实战：从 0 搭一个最小 REST 服务。

它会带你从 0 搭一个最小 Spring Boot REST 项目，把这篇里的概念真正落到代码上。

入门后最自然的下一步是：

自己起一个最小 Spring Boot 项目
写 3 到 5 个最基本的 REST 接口
加一层 Service
接一个简单数据库
加上事务和基础配置

再往后，你可以继续补：

参数校验
统一异常处理
日志
测试
安全认证
Redis
部署

微服务和 Spring Cloud 一定放到更后面。

17. 最后的学习建议

对你这种人，最大的优势不是“时间多”，而是：

你已经懂后端开发
你有 Python Web 框架经验
你不是从零开始理解请求、路由、业务、数据库

所以你学 Spring 最重要的不是“刷量”，而是：

把旧 Java Web 认知接上
把 Python 后端经验映射过来
把 Spring 的核心心智真正理解清楚

只要你把这三个点打通，后面进入项目会很快。

如果你打算继续顺着这组文章往下走，建议下一篇直接进入最小项目实战，再用后两篇把校验、异常处理、数据库和事务逐步补全。

一句话总结：

Spring 入门的关键，不是背多少注解，而是理解容器、分层、Web 调度、自动配置和事务这几条主线。

Spring 入门教程：给会 Python 后端、准备转 Java 全栈的人

1. 先建立整体认知

1.1 Spring 家族里你现在最需要关心的三个词

Spring Framework 是什么

Spring MVC 是什么

Spring Boot 是什么

1.2 你应该怎样理解它们的关系

2. 先补一点 Java 背景，但只补 Spring 真会用到的部分

2.1 Maven：Java 世界的依赖和构建工具

你现在要掌握到什么程度

2.2 注解：Spring 为什么这么依赖它

注解是什么

2.3 JDBC：为什么你即使不用原生 JDBC，也最好知道它

3. Java Web 背景：Spring MVC 不是从天上掉下来的

3.1 先看最原始的 Java Web 思路

3.2 MVC 思想先怎么理解

4. Spring Core：整个 Spring 体系真正的地基

4.1 IoC 先怎么理解

4.2 Bean 是什么

4.3 依赖注入为什么重要

4.4 @Component、@Service、@Repository、@Controller 大概怎么分

4.5 @Bean 又是什么

4.6 Spring 为什么会让人觉得“像魔法”

4.7 为什么不推荐到处自己 new

5. AOP 和事务：先建立“它解决什么问题”的认知

5.1 AOP 是干什么的

5.2 为什么事务常和 AOP 一起出现

6. Spring MVC：现代 Java Web 接口开发主线

6.1 DispatcherServlet 先怎么理解

6.2 @RestController 是什么

6.3 路由注解怎么理解

6.4 参数绑定：Spring MVC 很重要的一块体验

@PathVariable

@RequestParam

@RequestBody

6.5 返回 JSON 是怎么发生的

6.6 Filter 和 Interceptor 先怎么区分

7. Spring Boot：为什么现代 Spring 项目几乎都从它开始

7.1 Spring Boot 到底解决了什么问题

7.2 为什么它不是“只是更省事”

7.3 @SpringBootApplication 是什么

@SpringBootApplication

SpringApplication.run(...)

7.4 自动配置到底在做什么

7.5 starter 是什么

7.6 配置文件怎么理解

7.7 profile 是做什么的

7.8 为什么官方脚手架很重要

8. 一个最小 Spring Boot REST 项目应该长什么样

8.1 启动类

8.2 Controller

8.3 Service

8.4 这已经说明了什么

9. 数据访问：你要知道 Spring 怎么碰数据库

9.1 最原始路线：JDBC

9.2 再往上：更高层的封装

9.3 JPA 和 MyBatis 先怎么理解

JPA

MyBatis

9.4 你现在不用立刻二选一

10. 事务：为什么它是后端核心能力

10.1 事务最核心要解决什么

10.2 Spring 里最常见的事务写法

11. 把你熟悉的 Python 后端经验映射到 Spring

11.1 一个粗略映射表

11.2 最重要的思维切换是什么

11.3 哪些东西不要硬类比

12. 一条更适合你的学习顺序

12.1 官方资料怎么用更高效

13. 学的时候怎么避免“看懂了，但不会做”

14. 入门时最常见的误区

14.1 一上来只学 Spring Boot，不学 Spring Core

14.2 一上来就学微服务

14.3 只背注解，不理解请求和对象是怎么流动的

14.4 想一次把整个 Spring 生态学完

15. 读完这篇后，你至少应该能回答什么

16. 入门后的下一步应该是什么

17. 最后的学习建议

4.4 `@Component`、`@Service`、`@Repository`、`@Controller` 大概怎么分

4.5 `@Bean` 又是什么

4.7 为什么不推荐到处自己 `new`

6.1 `DispatcherServlet` 先怎么理解

6.2 `@RestController` 是什么

`@PathVariable`

`@RequestParam`

`@RequestBody`

7.3 `@SpringBootApplication` 是什么

`@SpringBootApplication`

`SpringApplication.run(...)`

7.5 `starter` 是什么

7.7 `profile` 是做什么的