Spring 全家桶系统学习文档

适合人群：已经具备 Java 基础，准备学习企业级 Java 后端、Spring Boot、Spring MVC、Spring Data、Spring Security、Spring Cloud、Spring AI 或微服务开发的学习者。
学习目标：从 Spring Framework 的 IoC/DI/AOP 入门，逐步掌握 Spring Boot 自动配置、Web API、数据访问、安全认证、缓存、消息队列、测试、微服务、监控部署和 Spring AI。
核对时间：2026-06-25。官方当前资料显示 Spring Framework 7.0.8、Spring Boot 4.1.0、Spring Data JPA 4.1.0 等版本。实际项目应以团队选定的 Spring Boot/Spring Cloud 兼容矩阵为准。
官方资料：
Spring Framework Reference：https://docs.spring.io/spring-framework/reference/
Spring Boot Reference：https://docs.spring.io/spring-boot/reference/
Spring Security Reference：https://docs.spring.io/spring-security/reference/
Spring Data JPA Reference：https://docs.spring.io/spring-data/jpa/reference/
Spring Cloud：https://spring.io/projects/spring-cloud
Spring AI Reference：https://docs.spring.io/spring-ai/reference/

第一篇：Spring 基础认知

1. Spring 全家桶是什么

Spring 全家桶不是一个单独框架，而是一组围绕 Java 企业级开发的生态：

text

Spring Framework：核心容器、IoC、AOP、事务、Web 基础
Spring Boot：快速创建生产级 Spring 应用
Spring MVC：Web 和 REST API
Spring Data：数据访问抽象
Spring Security：认证、授权和安全防护
Spring Cloud：分布式系统和微服务组件
Spring AI：AI 应用工程框架

学习 Spring 时不要一开始记模块名。先抓住主线：

text

对象由 Spring 管理
  -> 依赖由 Spring 注入
  -> Web 请求进入 Controller
  -> Service 处理业务
  -> Repository 访问数据库
  -> Security 保护接口
  -> Boot 简化配置
  -> Cloud 支持分布式

2. Spring Framework、Spring Boot、Spring Cloud 的关系

关系：

text

Spring Framework 是地基
Spring Boot 是快速开发和自动配置
Spring Cloud 是微服务和分布式能力

类比前端：

text

Spring Framework 类似底层运行和组件机制
Spring Boot 类似脚手架 + 默认工程配置
Spring Cloud 类似大型系统基础设施套件

你学习顺序应该是：

text

Java 基础 -> Spring Core -> Spring Boot -> Spring MVC/Data/Security -> Spring Cloud/Spring AI

不要跳过 Spring Core 直接堆 Spring Boot 注解，否则项目出问题时很难排查。

3. IoC 和 DI

IoC 是 Inversion of Control，控制反转。

传统写法：

java

UserService service = new UserService(new UserRepository());

对象由你自己创建。

Spring 写法：

java

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

对象由 Spring 容器创建，依赖由 Spring 注入。

DI 是 Dependency Injection，依赖注入，是 IoC 的具体实现方式。

好处：

降低耦合。
便于测试。
便于替换实现。
统一生命周期管理。

IoC 容器的内部机制

Spring 容器（ApplicationContext）的启动核心是 AbstractApplicationContext.refresh() 模板方法，关键步骤：

准备 Environment：加载 application.yml / 环境变量等外部化配置。
实例化 BeanFactory（DefaultListableBeanFactory）。
注册 BeanPostProcessor：注意，此时注册的这些后置处理器本身将参与后续所有 Bean 的创建（@Autowired、@Async、AOP 代理都靠它们实现）。
finishBeanFactoryInitialization：实例化所有非懒加载单例 Bean。

单个 Bean 的创建生命周期（面试高频）：

text

BeanDefinition 解析（扫描 @Component / @Bean 得到"配方"）
  -> 实例化（构造器反射调用）
  -> 属性填充（依赖注入发生在这一步）
  -> Aware 回调（BeanNameAware / ApplicationContextAware 等）
  -> BeanPostProcessor#postProcessBeforeInitialization
  -> 初始化（@PostConstruct -> InitializingBean#afterPropertiesSet -> initMethod）
  -> BeanPostProcessor#postProcessAfterInitialization  ← AOP 代理通常在这里替换成代理对象
  -> 使用
  -> 销毁（@PreDestroy -> DisposableBean#destroy -> destroyMethod）

循环依赖怎么处理：Spring 用三级缓存提前暴露"半成品"单例（仅对字段/setter 注入有效）；构造器注入的循环依赖无法解决，会直接抛 BeanCurrentlyInCreationException。且 Spring Boot 2.6 起默认禁止循环依赖（spring.main.allow-circular-references=false），出现该异常优先重构依赖结构，而不是打开开关。

⚠️ @Bean 方法所在类必须有 @Configuration；@Configuration 类默认以 CGLIB 增强（proxyBeanMethods=true），保证类内 @Bean 方法互相调用仍返回同一单例——把这个"坑位"留好，第 26 章事务失效场景会用到同样原理。

4. Bean 和 ApplicationContext

Bean 是由 Spring 容器管理的对象。

常见 Bean：

Controller
Service
Repository
Configuration
Component

ApplicationContext 是 Spring 容器，负责：

创建 Bean
管理 Bean 生命周期
注入依赖
读取配置
发布事件

java

@Service
public class UserService {
}

或：

java

@Configuration
public class AppConfig {
    @Bean
    public Clock clock() {
        return Clock.systemUTC();
    }
}

5. 注解驱动开发

常见注解：

@Component
@Service
@Repository
@Controller
@RestController
@Configuration
@Bean
@Autowired
@Value
@ConfigurationProperties

推荐构造器注入：

java

@Service
public class OrderService {
    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

不推荐字段注入：

java

@Autowired
private OrderRepository orderRepository;

构造器注入更利于测试，也能让依赖关系更明确。

6. AOP

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

适合横切逻辑：

日志
权限
事务
监控
缓存
重试

事务就是典型 AOP：

java

@Transactional
public void pay(Long orderId) {
    deductStock(orderId);
    createPayment(orderId);
}

你不需要在方法里手动 begin/commit，Spring 通过代理在方法前后织入事务逻辑。

AOP 常见坑：

同类内部方法调用可能绕过代理。
private 方法不能被正常代理增强。
事务边界要放在 public service 方法上。

AOP 代理的内部机制：JDK 动态代理 vs CGLIB

Spring AOP 默认使用运行时代理（不是 AspectJ 编译期织入），只有两种代理实现：

方式	原理	前提	特点
JDK 动态代理	实现目标类的全部接口，代理对象与目标对象是兄弟关系	目标类实现了接口	只能拦截接口中声明的 public 方法
CGLIB	生成目标类的子类，覆写方法插入拦截器链	类不能是 final、方法不能是 final/private	无接口也能代理

Spring Boot 从 2.x 起默认 proxyTargetClass=true（全走 CGLIB），避免"注入接口成功、注入实现类失败"的奇怪报错。理解代理方式差异能解释这些现象：

同类自调用绕过代理：this.otherMethod() 不经过代理对象，切面（事务、缓存、异步）全部失效——与第 3 章 IoC 生命周期中"代理在 postProcessAfterInitialization 替换了容器里的引用"直接相关，但你方法体里的 this 永远指向原始对象。
private/final 方法增强不上：CGLIB 子类无法覆写它们；不报错，静默失效。
拦截器链（MethodInterceptor 列表，如事务、日志、安全各自一个）按 @Order 组成链式调用，和 Node.js 中间件洋葱模型同构。

解决自调用失效的常见办法：拆分到另一个 Bean（首选）；注入自身代理（@Lazy @Autowired self）；或改用 AspectJ 织入模式（mode = AdviceMode.ASPECTJ，参考官方文档 @EnableTransactionManagement 的说明）。

第二篇：Spring Boot 基础

7. Spring Boot 是什么

Spring Boot 用于快速创建可独立运行的生产级 Spring 应用。

它解决：

配置繁琐。
依赖版本难配。
Web 容器部署复杂。
监控和生产能力需要手动集成。

Spring Boot 的核心：

starter 依赖
自动配置
内嵌 Web 服务器
外部化配置
Actuator
约定优于配置

8. 创建第一个 Spring Boot 项目

可以使用 Spring Initializr：

text

https://start.spring.io/

典型依赖：

Spring Web
Spring Data JPA
Spring Security
Validation
PostgreSQL Driver 或 MySQL Driver
Lombok
Spring Boot Actuator

入口类：

java

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

@SpringBootApplication 包含组件扫描、自动配置等能力。

9. starter 依赖

starter 是一组依赖组合。

例如 Web：

xml

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

JPA：

xml

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

starter 的价值：

自动引入常用依赖。
统一版本。
触发自动配置。
降低配置成本。

10. 自动配置

自动配置根据 classpath、配置属性和条件注解决定创建哪些 Bean。

例如引入 spring-boot-starter-web 后，Spring Boot 会自动配置：

Web MVC
JSON 序列化
内嵌服务器
参数绑定
静态资源处理

自动配置不是魔法。它本质上是大量带条件的配置类。

理解自动配置有助于排查：

为什么某个 Bean 被创建。
为什么配置没生效。
为什么引入某个 starter 后行为变化。

自动配置的实现原理（官方文档视角）

@SpringBootApplication 实际组合了三个注解，自动配置的入口是其中的 @EnableAutoConfiguration：

text

@SpringBootApplication
 ├── @SpringBootConfiguration   （本质是 @Configuration）
 ├── @EnableAutoConfiguration   （自动配置开关）
 └── @ComponentScan             （扫描你自己的类）

启动时，Spring Boot 读取每个 jar 里的注册清单文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports（Boot 2.7 之前的旧机制是 spring.factories，已废弃），拿到几百个 @AutoConfiguration 类的名单，再逐条用条件注解过滤。官方文档归纳的条件族：

条件注解族	判断依据	例子
Class 条件	classpath 上有没有某个类	`@ConditionalOnClass(DataSource.class)`：引入连接池才配置数据源
Bean 条件	容器里有没有某个 Bean	`@ConditionalOnMissingBean`：用户自己定义了就不再生成默认值（"你配了我就不配"）
Property 条件	配置属性的值	`@ConditionalOnProperty(prefix="spring.data.redis", name="enabled")`
Resource / JNDI / Web 环境条件	资源存在性、运行环境	`@ConditionalOnWebApplication`

官方文档的两条重要告诫：

⚠️ @ConditionalOnBean/@ConditionalOnMissingBean 的判断基于"当时已处理的定义"，顺序敏感——所以官方只建议在自动配置类里使用它们（自动配置保证在用户定义之后加载）；放在用户自己的 @Configuration 里随时可能判错。
自动配置的顺序影响"Bean 定义的先后"，但不影响"Bean 实例化的时机"（后者由依赖关系和 @DependsOn 决定）。

排查没生效的自动配置（官方推荐的诊断手段）：

bash

# 启动时打印条件评估报告
java -jar app.jar --debug

或在 Actuator 开启 conditions 端点，报告分 Positive matches（生效原因）与 Negative matches（被哪个条件挡掉），比翻源码快得多。也可在 IDE 里直接跳到如 DataSourceAutoConfiguration 看它的 @Conditional 链。

11. 配置文件

常用 application.yml：

yaml

server:
  port: 8080

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/appdb
    username: app
    password: secret

读取配置：

java

@ConfigurationProperties(prefix = "app")
public record AppProperties(String name, int pageSize) {
}

建议：

配置集中管理。
密码使用环境变量或密钥系统。
不要把生产密码提交到 Git。

12. Profile

Profile 用于不同环境配置。

yaml

spring:
  profiles:
    active: dev

文件：

text

application-dev.yml
application-test.yml
application-prod.yml

启动：

bash

java -jar app.jar --spring.profiles.active=prod

常见环境：

local
dev
test
staging
prod

13. 日志

Spring Boot 默认支持日志系统。

使用：

java

private static final Logger log = LoggerFactory.getLogger(UserService.class);

log.info("created user {}", userId);

建议：

不要在日志中输出敏感信息。
错误日志保留异常栈。
关键业务操作写审计日志。
生产日志输出 JSON 更利于采集。

SLF4J + Logback 的装配机制与 Boot 4 变化

Spring Boot 通过 starter 自动引入 SLF4J 门面 + Logback 实现，并自动接入 logging.* 配置；类路径出现 Log4j2 时自动切换实现（spring-boot-starter-log4j2），三选一即可，混装会报多个绑定冲突。
Boot 4 起 Logback 默认字符集与 Log4j2 对齐为 UTF-8（控制台优先用 Console#charset()）；此前 Windows 控制台中文乱码问题多与默认平台编码有关，升级后行为统一。
JSON 日志输出无需额外依赖，logging.structured.format.console=ecs（或 gelf/自定义模板）即可（Boot 3.4+ 能力）；生产容器环境配合 ELK/Loki 采集。

第二篇补充：Spring Boot 3 → 4 迁移要点

⚠️ 版本背景：Spring Boot 4.0 与 Spring Framework 7.0 于 2025 年 11 月一同发布，当前（2026 年）稳定线为 Boot 4.x。官方迁移指南（Spring Boot GitHub Wiki「Spring-Boot-4.0-Migration-Guide」）列出的要点如下——这是一次大版本升级，不是 minor 升级，需要专门排期。

前置基线

项目	Boot 3.x	Boot 4.x
Java 最低版本	17	17（官方鼓励用最新 LTS，即 Java 25）
Spring Framework	6.x	7.x（直接管理依赖时必须同步升级）
Jakarta EE / Servlet	EE 10 / Servlet 6.0	EE 11 / Servlet 6.1 基线
JSON 库	Jackson 2	Jackson 3（首选，见下）
Kotlin	—	需 2.2+；GraalVM native-image 需 25+

迁移第一步永远是：先升到 Boot 3.x 的最新维护版并清掉所有 deprecation——3.x 中标记弃用的 API 在 4.0 已全部移除。

属性改名与诊断工具

配置属性有大量重命名，官方提供运行时迁移助手（用完务必移除）：

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-properties-migrator</artifactId>
    <scope>runtime</scope>
</dependency>

启动时它会分析环境、打印诊断报告，并临时替你迁移旧属性。

被移除的特性

Undertow 支持整体移除（不兼容 Servlet 6.1）：用了 spring-boot-starter-undertow 必须先换成 Tomcat 或 Jetty，否则构建直接失败。
"完全可执行 jar"的内嵌 launch script 移除（java -jar 的 uber jar 仍支持）。
Spring Pulsar Reactive 的自动配置移除；Spring Session Hazelcast 等亦有调整。
classic uber-jar loader 移除，构建文件里的 <loaderImplementation> 配置需删除。

代码层面的高影响变更

变更	影响与对策
Jackson 3：包名 `com.fasterxml.jackson` → `tools.jackson`（例外：`jackson-annotations` 仍是 `com.fasterxml.jackson.annotation`）	全项目 import 大改；Boot 仍保留 Jackson 2 依赖管理，需要 Jackson 2 的库可与 Boot 的 Jackson 3 自动配置并存
相关类改名	`Jackson2ObjectMapperBuilderCustomizer` → `JsonMapperBuilderCustomizer`；`@JsonComponent`/`@JsonMixin` → `@JacksonComponent`/`@JacksonMixin`；属性移入 `spring.jackson.json.read/write.*`
JSpecify 空值注解：Boot 4 全面采用 JSpecify	用 null checker 或 Kotlin 的项目可能直接编译失败；`org.springframework.lang.Nullable` → `org.jspecify.annotations.Nullable`
包移动	`BootstrapRegistry` 移入 `org.springframework.boot.bootstrap`；`EnvironmentPostProcessor` 移入 `org.springframework.boot`；深度集成方需同步改 `spring.factories`
starter 改名	`spring-boot-starter-aop` → `spring-boot-starter-aspectj`（先确认应用是否真的用到 AspectJ 注解再引入）
Maven 可选依赖	`<optional>` 依赖不再进 uber jar，需要时配 `<includeOptional>true</includeOptional>`
Spring Retry	依赖管理移除，能力并入 Spring Framework 核心重试（`@Retryable` 等），官方建议迁移
Actuator	liveness/readiness 探针默认开启（health 端点默认暴露这两个分组）
DevTools	live reload 默认关闭，需 `spring.devtools.livereload.enabled=true`
测试	`@SpringBootTest` 不再自动提供 MockMvc/WebClient/TestRestTemplate，需显式加 `@AutoConfigureMockMvc` / `@AutoConfigureTestRestTemplate`；`MockitoTestExecutionListener` 移除，改用 Mockito 自带的 `MockitoExtension`

💡 实操建议：按"依赖审计 → Java/构建插件升级 → 属性迁移器跑一遍 → Jackson 3 import 批量替换 → 编译期 null 检查清理 → 测试注解补齐 → 冒烟验证 Actuator/安全配置"的顺序推进；官方也提供 OpenRewrite/Moderne 等自动重构配方处理属性重命名与包迁移。Spring Security 7、Spring Data、Spring Cloud 2025.1、Hibernate 7.1、Testcontainers 2、JUnit 6 等配套版本要按兼容矩阵一起对齐。

第三篇：Web 与 API 开发

14. Spring MVC

Spring MVC 负责 Web 请求处理。

流程：

text

HTTP 请求
  -> DispatcherServlet
  -> Controller
  -> Service
  -> Repository
  -> Response

前端可以类比：

text

Controller 类似后端路由处理函数
Service 类似业务逻辑模块
Repository 类似数据库访问层

15. Controller

java

@RestController
@RequestMapping("/api/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);
    }
}

@RestController 等价于 @Controller + @ResponseBody，返回对象会序列化为 JSON。

16. RequestMapping

常见注解：

@GetMapping
@PostMapping
@PutMapping
@PatchMapping
@DeleteMapping

示例：

java

@PostMapping
public UserDto createUser(@RequestBody CreateUserRequest request) {
    return userService.createUser(request);
}

REST 常见约定：

text

GET /users
GET /users/{id}
POST /users
PUT /users/{id}
DELETE /users/{id}

17. 参数接收

路径参数：

java

@GetMapping("/{id}")
public UserDto get(@PathVariable Long id) {
    ...
}

查询参数：

java

@GetMapping
public Page<UserDto> list(@RequestParam int page) {
    ...
}

请求体：

java

@PostMapping
public UserDto create(@RequestBody CreateUserRequest request) {
    ...
}

Header：

java

@RequestHeader("Authorization") String token

18. DTO 和校验

DTO：

java

public record CreateUserRequest(
    @NotBlank String name,
    @Email String email
) {
}

Controller：

java

@PostMapping
public UserDto create(@Valid @RequestBody CreateUserRequest request) {
    return userService.create(request);
}

常见校验：

@NotNull
@NotBlank
@Email
@Size
@Min
@Max
自定义 Validator

DTO 不要直接使用 Entity。Entity 是数据库模型，DTO 是 API 契约。

19. 统一响应和异常处理

全局异常：

java

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(NotFoundException.class)
    public ErrorResponse handle(NotFoundException ex) {
        return new ErrorResponse("NOT_FOUND", ex.getMessage());
    }
}

统一错误响应：

java

public record ErrorResponse(String code, String message) {
}

建议：

错误码稳定。
用户可读信息清晰。
内部异常不要直接暴露给前端。
日志记录完整上下文。

20. RESTful API

RESTful 关注资源。

资源：

text

/users
/orders
/products

HTTP 方法表达动作：

text

GET 查询
POST 创建
PUT 全量更新
PATCH 局部更新
DELETE 删除

状态码：

200 OK
201 Created
204 No Content
400 Bad Request
401 Unauthorized
403 Forbidden
404 Not Found
500 Internal Server Error

21. OpenAPI/Swagger

Spring 项目常用 springdoc-openapi 生成接口文档。

价值：

前后端联调。
API 契约可视化。
自动生成客户端。
测试接口。

但接口文档不能代替清晰 DTO 和稳定错误码设计。

第四篇：数据访问

22. JDBC 和 JdbcTemplate

JDBC 是 Java 访问数据库的底层 API。

Spring 提供 JdbcTemplate 简化操作：

java

List<UserDto> users = jdbcTemplate.query(
    "select id, name from users",
    (rs, rowNum) -> new UserDto(rs.getLong("id"), rs.getString("name"))
);

JdbcTemplate 适合：

简单 SQL
精确控制查询
不想引入 ORM 的场景

23. JPA 和 Hibernate

JPA 是 Java 持久化规范，Hibernate 是常见实现。

Entity：

java

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
}

JPA 让 Java 对象映射到数据库表。

注意：ORM 不等于不用懂 SQL。复杂查询、索引、事务仍然要理解数据库。

24. Spring Data JPA

Spring Data JPA 简化 Repository。

java

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

常见能力：

基础 CRUD
分页排序
方法名查询
JPQL
Specification
自定义查询

示例：

java

Page<User> findByActiveTrue(Pageable pageable);

25. Repository

Repository 是数据访问层。

java

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

职责：

封装数据库查询。
不写业务流程。
不处理 HTTP。

业务逻辑应放在 Service 层，而不是 Controller 或 Repository。

26. 事务管理

java

@Transactional
public void pay(Long orderId) {
    orderRepository.markPaid(orderId);
    paymentRepository.create(orderId);
}

事务重点：

方法异常时回滚。
事务边界放在 Service。
不要在事务中做慢网络请求。
注意传播行为。
注意同类内部调用问题。

常见传播：

REQUIRED：默认，加入当前事务，没有则创建。
REQUIRES_NEW：新开事务。

事务代理的内部机制

@Transactional 的本质是第 6 章 AOP 的一个具体应用：TransactionInterceptor（一个 MethodInterceptor）环绕目标方法，执行 获取事务 → 调用方法 → commit / rollback。Spring 通过 PlatformTransactionManager 统一抽象 JDBC/JPA/缓存等底层事务 API（这也是"Spring 事务比裸 JDBC 强的核心卖点"——换持久化技术不改事务代码）。

回滚规则的默认值（官方文档明确的语义，也是最多人踩的坑）：

抛出的异常	默认是否回滚
`RuntimeException` / `Error`（unchecked）	✅ 回滚
checked `Exception`（如 `IOException`、自定义 `extends Exception`）	❌ 提交（数据不一致的经典来源）
自定义规则	`rollbackFor = Exception.class` / `noRollbackFor = BizException.class` 覆盖默认

java

// 想要任何异常都回滚，显式声明：
@Transactional(rollbackFor = Exception.class)
public void pay(Long orderId) throws PaymentException { ... }

Kotlin 没有 checked 异常、默认回滚语义同样生效；官方提示 Kotlin 场景可考虑 ALL_EXCEPTIONS 风格的规则保持一致性。

传播行为全景（7 种）

传播	已有事务时	无事务时	典型用途
`REQUIRED`（默认）	加入	新建	绝大多数业务方法
`REQUIRES_NEW`	挂起当前事务，新开一个	新建	审计日志、序列号——外层回滚它也要留下
`NESTED`	以 savepoint 嵌套	新建（等价 REQUIRED）	外层可整体回滚、内层可部分回滚
`SUPPORTS`	加入	非事务执行	只读查询
`NOT_SUPPORTED`	挂起	非事务执行	长耗时步骤不该占事务
`NEVER`	抛异常	非事务执行	强约束"此方法绝不能有事务"
`MANDATORY`	加入	抛异常	强约束"必须由上层开事务"

REQUIRES_NEW 的关键细节：外层事务被挂起等待内层独立提交——内层先提交成功，外层后来回滚时内层的数据不会消失；且需要第二个数据库连接，池子小 + 嵌套深容易死锁/耗尽连接。

事务失效场景清单（每一幕都在生产出现过）

自调用：同类中 a() 调 @Transactional b()，不经过代理（见第 6 章）。
方法非 public：代理模式下只有 public 方法会被增强（class-based 代理对 protected/包级可见的处理与接口代理不同，官方建议一律 public）。
异常被 catch 吞掉：方法内 try/catch 后正常返回，代理认为一切成功 → 提交。要么 rethrow，要么 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly()。
抛 checked 异常：默认不回滚（见上表）。
Bean 没被 Spring 管理：忘了 @Service，自己 new 出来的对象没有代理。
注解加在接口上但依赖注解继承：Java 注解不从接口继承，官方推荐把 @Transactional 标在具体类的方法上，而不是接口。
@PostConstruct 等初始化代码里调用事务方法：代理尚未完全就绪，官方明确不要依赖这个特性。
多线程：事务上下文绑定 ThreadLocal，new Thread/线程池里另起线程执行 DB 写不在同一事务。
存储引擎不支持：MySQL MyISAM 表、或底层连接自动提交且未接入 DataSourceTransactionManager。

💡 诊断顺序：先看 SQL 日志有没有真的发出（logging.level org.springframework.jdbc.datasource.DataSourceTransactionManager=DEBUG 打印事务 begin/commit/rollback），再对照失效清单。

只读优化与事务边界

@Transactional(readOnly = true)：对 JPA/Hibernate 还会跳过脏检查、把连接置为只读，路由中间件可据此走读库——读方法也标事务并设只读是常见规范。
不要把远程调用放进事务：HTTP/RPC 超时 10 秒 = 数据库连接与行锁被占 10 秒；正确姿势是"事务内只做 DB 操作，远程调用挪到事务外，配合幂等与补偿"。
事务传播 + 异常组合出的"意外提交/意外回滚"，优先用集成测试固化回滚预期，而不是靠人脑推演。

27. MyBatis

MyBatis 是 SQL Mapper 框架，适合想精细控制 SQL 的团队。

Mapper：

java

@Mapper
public interface UserMapper {
    UserDto findById(Long id);
}

MyBatis 优势：

SQL 可控。
复杂查询清晰。
与数据库贴近。

JPA 优势：

CRUD 快。
对象模型自然。
Repository 抽象强。

选择取决于团队习惯和业务复杂度。

28. 数据库迁移

常用工具：

Flyway
Liquibase

Flyway 迁移文件：

text

V1__create_users.sql
V2__add_orders.sql

迁移原则：

数据库结构变更版本化。
迁移文件提交 Git。
生产变更前审查 SQL。
大表变更谨慎执行。

第五篇：安全、缓存和消息

29. Spring Security

Spring Security 提供：

Authentication 认证
Authorization 授权
密码加密
CSRF 防护
CORS 配置
OAuth2
Resource Server

基础概念：

text

认证：你是谁？
授权：你能做什么？

Spring Security 强大但学习曲线较陡，建议先掌握 Web API 和 JWT，再深入 OAuth2。

30. JWT 认证

流程：

text

用户登录
  -> 后端校验账号密码
  -> 生成 JWT
  -> 前端保存 token
  -> 请求携带 Authorization: Bearer token
  -> 后端校验 token

注意：

JWT 不要存敏感信息。
设置过期时间。
refresh token 单独设计。
HTTPS 必须使用。
前端存储 token 要考虑 XSS 风险。

31. RBAC 权限模型

RBAC：

text

User -> Role -> Permission

表设计：

users
roles
permissions
user_roles
role_permissions

接口授权：

java

@PreAuthorize("hasRole('ADMIN')")
public void deleteUser(Long id) {
}

权限系统要区分：

菜单权限
按钮权限
API 权限
数据权限

32. CORS 和 CSRF

CORS 解决跨域请求。

前后端分离常见：

text

前端 http://localhost:3000
后端 http://localhost:8080

需要允许跨域。

CSRF 是跨站请求伪造。对于 cookie session 应用很重要。对于纯 token API，也要理解攻击模型，不要机械关闭安全配置。

33. Cache

Spring Cache 抽象：

java

@Cacheable(value = "users", key = "#id")
public UserDto getUser(Long id) {
    return queryFromDb(id);
}

缓存适合：

读多写少。
计算成本高。
数据短时间内可接受延迟。

缓存问题：

缓存穿透
缓存击穿
缓存雪崩
数据一致性

34. Redis

Redis 常用于：

缓存
分布式锁
session
排行榜
限流
消息流

Spring Boot 可集成 Redis。

注意：

key 命名规范。
TTL 设置。
序列化格式。
缓存一致性。
不要把 Redis 当主数据库随意使用。

35. 消息队列

常见消息系统：

RabbitMQ
Kafka
RocketMQ

适合：

异步解耦。
削峰填谷。
事件驱动。
日志和数据流。

问题：

消息重复。
顺序消费。
失败重试。
死信队列。
幂等处理。

第六篇：微服务、运维和 AI

36. Spring Cloud

Spring Cloud 提供分布式系统常见模式工具。

包括：

配置管理
服务注册发现
网关
服务调用
熔断限流
链路追踪

学习 Spring Cloud 前要先掌握单体 Spring Boot。微服务会放大工程复杂度，不适合刚入门就上。

37. 服务注册与配置中心

服务注册发现：

text

服务启动 -> 注册到注册中心
调用方 -> 从注册中心发现服务地址

配置中心：

text

集中管理不同环境配置
配置变更可审计、可刷新

常见组件取决于团队技术栈，例如 Spring Cloud Config、Consul、Nacos 等。

38. OpenFeign 和网关

OpenFeign 用于声明式 HTTP 调用。

java

@FeignClient(name = "order-service")
public interface OrderClient {
    @GetMapping("/orders/{id}")
    OrderDto getOrder(@PathVariable Long id);
}

网关负责：

路由
鉴权
限流
CORS
日志
统一入口

常见网关：Spring Cloud Gateway。

39. Resilience4j

用于弹性能力：

熔断
限流
重试
舱壁隔离
超时

微服务中外部调用一定会失败。弹性设计不是可选项。

40. Actuator 和监控

Spring Boot Actuator 提供生产监控端点。

常见：

health
metrics
info
env
loggers

配合：

Micrometer
Prometheus
Grafana
日志系统

生产中要保护 Actuator 敏感端点，不能裸露到公网。

41. 测试

单元测试：

java

@Test
void shouldCreateUser() {
    ...
}

Spring Boot 测试：

java

@SpringBootTest
class AppTests {
}

Web 层测试：

java

@WebMvcTest(UserController.class)

数据层测试：

java

@DataJpaTest

测试策略：

Service 逻辑用单元测试。
Repository 用集成测试。
Controller 用 Web 层测试。
核心业务链路做端到端测试。

42. Docker 部署

打包：

bash

mvn clean package

运行：

bash

java -jar target/app.jar

Dockerfile：

dockerfile

FROM eclipse-temurin:25-jre
WORKDIR /app
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

生产部署要考虑：

JVM 参数
环境变量
日志输出
健康检查
数据库连接池
容器资源限制

43. Spring AI

Spring AI 是 Spring 生态面向 AI 工程的框架，目标是把 Spring 的设计原则应用到 AI 领域。

它关注：

Chat Model
Embedding Model
Prompt
Vector Store
Tools/Function Calling
RAG
多模型提供商集成

适合 Java/Spring 团队构建 AI 应用。

与 LangChain 的关系：

LangChain/Python 生态更成熟，AI 示例和工具更多。
Spring AI 更适合已有 Spring 技术栈的企业。
前端 AI 全栈可以以 Python LangChain 为主，同时了解 Spring AI 以适应 Java 企业项目。

44. 学习路线和实战项目

学习路线：

Java 基础。
Maven/Gradle。
Spring Core：IoC、DI、Bean、AOP。
Spring Boot：starter、自动配置、配置文件。
Spring MVC：Controller、DTO、校验、异常处理。
Spring Data JPA 或 MyBatis。
事务和数据库。
Spring Security：JWT、RBAC。
Redis、缓存、消息队列。
Actuator、测试、Docker 部署。
Spring Cloud。
Spring AI。

实战项目：

text

AI 知识库后台系统
- Spring Boot 提供管理后台 API
- Spring Security 做登录和权限
- Spring Data JPA 访问 PostgreSQL
- Redis 做缓存和限流
- Spring AI 或 Python AI 服务做 RAG
- 前端 Nuxt/Vue + Tailwind

前端开发者学习 Spring 的目标不是马上替代 Java 后端，而是：

能读懂企业级 Java 项目。
能开发中小型 API。
能和 Java 后端协作。
能理解安全、事务、微服务和生产部署。
能判断什么时候用 Node/NestJS，什么时候接入 Java/Spring。

快速记忆清单

Spring Framework 是地基，Spring Boot 是快速生产级应用，Spring Cloud 是微服务工具集。
IoC/DI 是 Spring 的核心，Bean 由容器管理。
推荐构造器注入，不推荐字段注入。
Controller 处理 HTTP，Service 处理业务，Repository 访问数据库。
DTO 是 API 契约，Entity 是数据库模型，不要混用。
@Transactional 是事务边界，通常放在 Service 层。
Spring Security 负责认证、授权和常见安全防护。
微服务先学单体 Spring Boot，再学 Spring Cloud。
Spring AI 适合 Java/Spring 技术栈中的 AI 应用工程。

Spring 全家桶系统学习文档 ​

目录 ​

第一篇：Spring 基础认知 ​

第二篇：Spring Boot 基础 ​

第三篇：Web 与 API 开发 ​

第四篇：数据访问 ​

第五篇：安全、缓存和消息 ​

第六篇：微服务、运维和 AI ​

第一篇：Spring 基础认知 ​

1. Spring 全家桶是什么 ​

2. Spring Framework、Spring Boot、Spring Cloud 的关系 ​

3. IoC 和 DI ​

IoC 容器的内部机制 ​

4. Bean 和 ApplicationContext ​

5. 注解驱动开发 ​

6. AOP ​

AOP 代理的内部机制：JDK 动态代理 vs CGLIB ​

第二篇：Spring Boot 基础 ​

7. Spring Boot 是什么 ​

8. 创建第一个 Spring Boot 项目 ​

9. starter 依赖 ​

10. 自动配置 ​

自动配置的实现原理（官方文档视角） ​

11. 配置文件 ​

12. Profile ​

13. 日志 ​

SLF4J + Logback 的装配机制与 Boot 4 变化 ​

第二篇补充：Spring Boot 3 → 4 迁移要点 ​

前置基线 ​

属性改名与诊断工具 ​

被移除的特性 ​

代码层面的高影响变更 ​

第三篇：Web 与 API 开发 ​

14. Spring MVC ​

15. Controller ​

16. RequestMapping ​

17. 参数接收 ​

18. DTO 和校验 ​

19. 统一响应和异常处理 ​

20. RESTful API ​

21. OpenAPI/Swagger ​

第四篇：数据访问 ​

22. JDBC 和 JdbcTemplate ​

23. JPA 和 Hibernate ​

24. Spring Data JPA ​

25. Repository ​

26. 事务管理 ​

事务代理的内部机制 ​

传播行为全景（7 种） ​

事务失效场景清单（每一幕都在生产出现过） ​

只读优化与事务边界 ​

27. MyBatis ​

28. 数据库迁移 ​

第五篇：安全、缓存和消息 ​

29. Spring Security ​

30. JWT 认证 ​

31. RBAC 权限模型 ​

32. CORS 和 CSRF ​

33. Cache ​

34. Redis ​

35. 消息队列 ​

第六篇：微服务、运维和 AI ​

36. Spring Cloud ​

37. 服务注册与配置中心 ​

38. OpenFeign 和网关 ​

39. Resilience4j ​

40. Actuator 和监控 ​

41. 测试 ​

42. Docker 部署 ​

43. Spring AI ​

44. 学习路线和实战项目 ​

快速记忆清单 ​

Spring 全家桶系统学习文档

目录

第一篇：Spring 基础认知

第二篇：Spring Boot 基础

第三篇：Web 与 API 开发

第四篇：数据访问

第五篇：安全、缓存和消息

第六篇：微服务、运维和 AI

第一篇：Spring 基础认知

1. Spring 全家桶是什么

2. Spring Framework、Spring Boot、Spring Cloud 的关系

3. IoC 和 DI

IoC 容器的内部机制

4. Bean 和 ApplicationContext

5. 注解驱动开发

6. AOP

AOP 代理的内部机制：JDK 动态代理 vs CGLIB

第二篇：Spring Boot 基础

7. Spring Boot 是什么

8. 创建第一个 Spring Boot 项目

9. starter 依赖

10. 自动配置

自动配置的实现原理（官方文档视角）

11. 配置文件

12. Profile

13. 日志

SLF4J + Logback 的装配机制与 Boot 4 变化

第二篇补充：Spring Boot 3 → 4 迁移要点

前置基线

属性改名与诊断工具

被移除的特性

代码层面的高影响变更

第三篇：Web 与 API 开发

14. Spring MVC

15. Controller

16. RequestMapping

17. 参数接收

18. DTO 和校验

19. 统一响应和异常处理

20. RESTful API

21. OpenAPI/Swagger

第四篇：数据访问

22. JDBC 和 JdbcTemplate

23. JPA 和 Hibernate

24. Spring Data JPA

25. Repository

26. 事务管理

事务代理的内部机制

传播行为全景（7 种）

事务失效场景清单（每一幕都在生产出现过）

只读优化与事务边界

27. MyBatis

28. 数据库迁移

第五篇：安全、缓存和消息

29. Spring Security

30. JWT 认证

31. RBAC 权限模型

32. CORS 和 CSRF

33. Cache

34. Redis

35. 消息队列

第六篇：微服务、运维和 AI

36. Spring Cloud

37. 服务注册与配置中心

38. OpenFeign 和网关

39. Resilience4j

40. Actuator 和监控

41. 测试

42. Docker 部署

43. Spring AI

44. 学习路线和实战项目

快速记忆清单