一、Spring 基础核心
1. Spring 定义 + 特性 + 模块
一句话总结：Spring 是轻量级、非入侵式 Java 框架，核心为 IoC（控制反转）和 AOP（面向切面编程），模块化设计实现解耦与高效开发。
- 核心特性 ：
- IoC/DI 解耦对象依赖；
- AOP 抽离日志 / 事务等通用逻辑；
- 声明式事务简化事务管理；
- 便捷测试、易集成第三方框架；
- 封装复杂 API（如 JDBC、缓存）。
- 核心模块 ：
- 必选：Spring Core（IoC 核心）、Context（上下文）；
- 可选：Web/MVC（Web 开发）、DAO/ORM（数据访问）、AOP（切面）。
2. Spring 常用注解
一句话总结：Spring 注解覆盖 Web 请求、Bean 注入、AOP 切面、事务控制四大核心场景，大幅简化开发。
表格
| 场景 | 核心注解 | 作用 |
|---|---|---|
| Web 注解 | @Controller/@RestController、@RequestMapping/@GetMapping、@RequestBody/@ResponseBody | 处理 Web 请求、映射 URL、处理 JSON 数据 |
| 容器注解 | @Component/@Service/@Repository、@Autowired/@Resource、@Configuration/@Bean | 声明 Bean、自动注入依赖、配置类 / 显式声明 Bean |
| AOP 注解 | @Aspect、@Before/@After/@Around、@PointCut | 定义切面、声明通知（增强逻辑）、定义切点 |
| 事务注解 | @Transactional | 声明方法需要事务支持 |
3. Spring 设计模式
一句话总结：Spring 大量运用工厂、单例、代理模式，分别实现 Bean 创建管理、实例唯一性、AOP 切面增强。
- 工厂模式：BeanFactory/ApplicationContext 作为 Bean 工厂，统一创建和获取 Bean；
- 单例模式 ：通过
singletonObjects缓存保证 Bean 唯一性，容器初始化时创建； - 代理模式：基于 JDK/CGLIB 动态代理实现 AOP（如事务、日志增强）。
4. Spring 容器 vs Web 容器
一句话总结：Spring 容器管理 Bean 生命周期和依赖，Web 容器提供 Web 运行环境，Spring MVC 是 Spring 处理 Web 请求的模块。
- Spring 容器：IoC 核心，管控 Bean 的创建、依赖注入、销毁；
- Web 容器（Tomcat/Jetty）：运行 Servlet/JSP，提供 HTTP 服务、会话管理等 Web 运行环境；
- Spring MVC：Spring 的 Web 模块，基于 MVC 模式处理 Web 请求。
二、IoC/DI 核心机制
5. IoC/DI 核心
一句话总结：IoC 是 "控制反转" 思想，将对象创建 / 依赖交由 Spring 容器管理，DI（依赖注入）是 IoC 的具体实现。
- IoC 价值：消除硬编码依赖，降低耦合、提高代码灵活性和可维护性；
- DI 实现方式 ：
- 构造器注入（推荐，保证依赖不可变）；
- Setter 注入（灵活，支持可选依赖）；
- 自动装配（@Autowired/@Resource）；
- 核心容器：BeanFactory 是基础接口，ApplicationContext 是增强版（默认使用，提供国际化、事件发布等能力）。
6. BeanFactory vs ApplicationContext
一句话总结：BeanFactory 是 IoC 容器顶层接口（基础版），ApplicationContext 是其子接口（增强版），是 Spring 应用默认选择。
表格
| 特性 | BeanFactory | ApplicationContext |
|---|---|---|
| 核心方法 | 提供 getBean () 获取 Bean | 继承 getBean ()，扩展层级、列表化等能力 |
| 初始化方式 | 按需初始化（调用 getBean 时） | 容器启动时自动初始化所有单例 Bean |
| 功能丰富度 | 基础功能（仅 IoC） | 增强功能（国际化、事件、AOP 等） |
| 易用性 | 低（需手动配置） | 高（自动配置、默认实现） |
7. Spring 容器启动 + Bean 实例化
一句话总结：容器启动加载解析配置生成 Bean 定义，实例化 Bean 支持构造方法、静态工厂、实例工厂、FactoryBean 四种方式。
- 容器启动流程 ：
- 加载解析 XML / 注解 / Java 配置；
- 将配置信息转换为 Bean 定义（BeanDefinition）；
- 注册 Bean 定义到容器；
- 实例化 / 初始化 Bean（单例 Bean 自动初始化）。
- Bean 实例化方式 ：
- 构造方法（主流，默认方式）；
- 静态工厂（通过静态方法创建 Bean）；
- 实例工厂（通过实例方法创建 Bean）；
- FactoryBean（自定义实例化逻辑，如整合第三方框架）。
8. Bean 定义 + 生命周期
一句话总结：Bean 是 Spring 容器管理的对象，支持多方式声明，生命周期为 "实例化→属性赋值→初始化→使用→销毁"。
- Bean 声明方式 ：
- 注解（@Component/@Service，主流，自动扫描）；
- XML（<bean> 标签，老旧项目使用）；
- Java 配置（@Configuration + @Bean，适配第三方类）；
- @Component vs @Bean ：
- @Component：类级别注解，自动扫描创建 Bean；
- @Bean：方法级别注解，显式声明 Bean（适用于无法修改源码的第三方类）；
- Bean 生命周期 ：
- 实例化（创建对象）；
- 属性赋值（依赖注入）；
- 初始化（调用 @PostConstruct/init-method）；
- 使用（业务调用）；
- 销毁（调用 @PreDestroy/destroy-method）。
9. @Autowired vs @Resource + 自动装配方式
一句话总结：@Autowired（Spring 提供，按类型注入）和 @Resource（JavaEE 提供，按名称注入）实现自动装配，支持四种装配方式。
表格
| 注解 | 所属框架 | 注入规则 | IDEA 建议 |
|---|---|---|---|
| @Autowired | Spring | 优先按类型，配合 @Qualifier 按名称 | 不推荐字段注入（无法注入 final 对象），推荐构造器注入 |
| @Resource | JavaEE | 优先按名称，无名称按类型 | 字段注入兼容性更好 |
- 自动装配方式 ：
- byName（按 Bean 名称注入）；
- byType（按 Bean 类型注入）；
- constructor（构造器注入）；
- autodetect（自动检测，优先构造器）。
10. Bean 作用域
一句话总结：Spring Bean 默认单例（Singleton），支持多作用域适配不同场景。
表格
| 作用域 | 核心特点 | 适用场景 |
|---|---|---|
| Singleton | 容器内唯一实例，默认值 | 无状态 Bean（Controller/Service） |
| Prototype | 每次 getBean 生成新实例 | 有状态 Bean（避免线程安全问题） |
| Request | 单次 HTTP 请求内唯一 | Web 场景，单次请求共享数据 |
| Session | 单次会话内唯一 | Web 场景，会话共享数据 |
| （废弃）globalSession | 全局会话唯一 | 分布式会话（Spring5 移除） |
11. 单例 Bean 线程安全
一句话总结：无状态单例 Bean 线程安全，有状态 Bean 需通过局部变量、ThreadLocal 等方式解决线程安全问题。
- 安全前提：Bean 无可变成员变量（如 Controller/Service 仅包含方法，无属性，默认安全）；
- 解决方案 ：
- 局部变量（线程私有，推荐）；
- ThreadLocal（为每个线程创建变量副本）；
- 同步机制（synchronized / 锁，性能差）；
- 线程安全工具类（AtomicInteger 等）；
- 原型作用域（每次获取新实例）。
12. 循环依赖
一句话总结：Spring 通过三级缓存解决单例 Bean 循环依赖，核心是提前暴露未完全初始化的 Bean 引用。
- 三级缓存 ：
- 一级缓存（singletonObjects）：存储完整初始化的 Bean；
- 二级缓存（earlySingletonObjects）：存储未初始化的 Bean 实例；
- 三级缓存（singletonFactories）：存储 Bean 工厂，用于生成代理对象；
- 解决逻辑 ：
- 实例化 Bean A 时，将工厂放入三级缓存；
- Bean A 依赖 Bean B，实例化 Bean B 并注入 Bean A 的早期引用（二级缓存）；
- Bean B 初始化完成后，Bean A 完成初始化，移入一级缓存；
- 三级缓存必要性 ：为生成代理对象，保证 Bean 实例唯一性；缺二级缓存会抛出
BeanCurrentlyInCreationException。
13. @Autowired 实现原理
一句话总结 ：@Autowired 通过 AutowiredAnnotationBeanPostProcessor 后置处理器，在 Bean 初始化的 populateBean 阶段完成属性自动装配。
- 核心流程 ：
- 容器创建 Bean 时调用
doCreateBean()； - 进入
populateBean()阶段（属性赋值）； - 触发
AutowiredAnnotationBeanPostProcessor后置处理器； - 解析 @Autowired 注解，按类型 / 名称查找依赖；
- 将依赖注入到 Bean 属性中。
- 容器创建 Bean 时调用
三、AOP 核心机制
14. AOP 核心
一句话总结：AOP（面向切面编程）将通用逻辑抽离为切面，通过动态代理织入核心业务，实现逻辑解耦。
- 核心概念 ：
- 切面（Aspect）：通用逻辑模块（如日志、事务）；
- 切点（Pointcut）：匹配需要增强的方法；
- 通知（Advice）：增强逻辑（@Before/@After/@Around 等）；
- 连接点（Join Point）：可被增强的方法 / 字段；
- 织入方式 ：
- Spring AOP：运行时动态代理（轻量，依赖 IoC）；
- AspectJ：编译期 / 类加载期织入（性能更高）；
- 与 OOP 关系：互补，OOP 封装核心业务，AOP 处理横切逻辑。
15. JDK 动态代理 vs CGLIB 代理
一句话总结：AOP 的两种动态代理方式，JDK 基于接口，CGLIB 基于继承。
表格
| 特性 | JDK 动态代理 | CGLIB 代理 |
|---|---|---|
| 实现方式 | 基于接口 | 基于继承 |
| 依赖 | JDK 原生支持（无额外依赖） | 需引入 CGLIB 依赖 |
| 代理目标 | 仅能代理实现接口的类 | 可代理任意类（无接口） |
| 性能 | 创建快，运行稍慢 | 创建开销大，运行快 |
| 选择原则 | 有接口用 JDK，无接口用 CGLIB | 性能敏感且创建频率低可选 CGLIB |
16. Spring AOP vs AspectJ AOP
一句话总结：Spring AOP 是运行时增强（动态代理），AspectJ 是编译期增强（静态织入）。
表格
| 特性 | Spring AOP | AspectJ AOP |
|---|---|---|
| 增强时机 | 运行时（动态代理） | 编译期 / 类加载期（静态织入） |
| 依赖 | 依赖 Spring IoC 容器 | 独立框架，无需 Spring |
| 连接点支持 | 仅支持方法级连接点 | 支持方法 / 字段 / 构造方法等 |
| 功能丰富度 | 轻量，功能有限 | 功能全面 |
| 性能 | 运行时开销（代理调用） | 无运行时开销（字节码修改） |
17. AOP vs 反射
一句话总结：反射是动态代理的基础，动态代理是 AOP 的实现方式，AOP 是动态代理的典型应用。
- 反射：Java 内置机制，可直接操作类的方法 / 字段，是动态代理的底层支撑；
- 动态代理：基于反射生成代理类，拦截目标方法调用，是 AOP 的核心实现方式；
- AOP：封装动态代理，专注于横切逻辑解耦，无需关注代理底层实现。
四、事务核心
18. Spring 事务
一句话总结：Spring 支持声明式（AOP 实现）和编程式（显式 API）事务管理，通过隔离级别和传播机制控制事务行为。
- 事务类型 ：
- 声明式事务：@Transactional（方法级，无侵入，推荐）；
- 编程式事务：TransactionTemplate（代码块级，灵活，适用于复杂事务）；
- 隔离级别 ：
- 默认使用数据库隔离级别；
- 支持：读未提交、读已提交、可重复读、串行化；
- 传播机制：控制事务嵌套行为（如 REQUIRED、REQUIRES_NEW 等）；
- 生效范围：@Transactional 仅对 public 方法生效，protected/private 方法不生效。
19. 声明式事务实现原理 + 失效场景
一句话总结：声明式事务基于 AOP + 动态代理实现，多种场景会导致其失效。
- 实现原理 ：
- Bean 初始化时，Spring 为加 @Transactional 的 Bean 创建代理；
- 调用目标方法时，代理类拦截方法执行；
- 启动事务→执行目标方法→提交 / 回滚事务；
- 失效场景 ：
- 方法非 public（如 private/protected）；
- 内部调用（代理类无法拦截）；
- 异常被捕获（未抛出，事务无法回滚）；
- 数据源未配置事务管理器；
- 传播机制配置错误（如 NOT_SUPPORTED）；
- 异常类型不匹配（默认仅回滚 RuntimeException）。
五、Spring MVC 核心
20. Spring MVC 工作流程
一句话总结：客户端请求经 DispatcherServlet 分发，通过处理器映射器 / 适配器调用 Controller，处理后经视图解析器渲染响应。
- 核心流程 ：
- 客户端发起 HTTP 请求；
- DispatcherServlet（前端控制器）接收请求；
- HandlerMapping 查找匹配的 Controller；
- HandlerAdapter 调用 Controller 方法；
- Controller 返回 ModelAndView；
- ViewResolver 解析视图；
- 渲染视图并返回响应；
- 核心组件 ：
- DispatcherServlet：前端控制器（核心）；
- HandlerMapping：处理器映射（找 Controller）；
- HandlerAdapter：处理器适配（调用方法）；
- ViewResolver：视图解析（解析页面路径）。
21. Spring MVC Restful 接口流程
一句话总结：Restful 接口流程与普通 MVC 一致，差异在于返回值直接写入 JSON 响应（无 ModelAndView）。
- 核心流程 ：
- 请求→DispatcherServlet→HandlerMapping→HandlerAdapter；
- Controller 处理请求，返回 JSON 数据（如 Map/POJO）；
- HandlerMethodReturnValueHandler 处理返回值；
- 转换为 JSON 写入响应体，返回客户端；
- 关键差异：无视图解析步骤，ModelAndView 为 null，响应体直接返回 JSON 数据。
六、Spring Boot 核心
22. Spring Boot 定义 + 优点 + 常用注解
一句话总结：Spring Boot 是 Spring 扩展，基于 "约定大于配置"，通过自动配置、Starter 依赖、内嵌容器快速搭建应用。
- 核心优点 ：
- 内嵌容器（Tomcat/Jetty），可直接运行 jar 包；
- 自动配置（无需手动配置 XML）；
- Starter 起步依赖（预定义依赖组合）；
- 内置监控 / 调试工具（Actuator/DevTools）；
- 核心注解 ：
- @SpringBootApplication：组合注解，包含 @EnableAutoConfiguration（自动配置）、@Configuration（配置类）、@ComponentScan（包扫描）；
- 复用 Spring 原有注解（@Autowired/@Service 等）。
23. Spring Boot 自动配置原理
一句话总结：通过 @EnableAutoConfiguration 注解，借助 AutoConfigurationImportSelector 加载自动配置类，按需创建 Bean。
- 核心流程 ：
- @SpringBootApplication 包含 @EnableAutoConfiguration；
- @EnableAutoConfiguration 导入 AutoConfigurationImportSelector；
- AutoConfigurationImportSelector 调用 selectImports ()→getAutoConfigurationEntry ()；
- 加载 META-INF/spring.factories 中的自动配置类；
- 根据条件（@Conditional）按需创建 Bean。
24. Spring Boot Starter 原理
一句话总结：Starter 通过 "起步依赖 + 自动配置" 简化项目依赖和配置。
- 起步依赖：预定义依赖组合（如 spring-boot-starter-web 包含 Spring MVC + Tomcat + Jackson）；
- 自动配置：扫描类路径，根据依赖自动创建 / 配置 Bean（如引入 mysql-connector-java 自动配置数据源）；
- 自定义 Starter：遵循 "xxx-spring-boot-starter" 命名规范，包含自动配置类和起步依赖。
25. Spring Boot 启动原理
一句话总结：由 SpringApplication 主导启动，流程为创建实例→加载配置→初始化上下文→启动内嵌容器→发布事件。
- 核心流程 ：
- 创建 SpringApplication 实例；
- 加载 application.yml/properties 配置；
- 初始化 ApplicationContext（Spring 上下文）；
- 启动内嵌 Tomcat 容器；
- 调用 ApplicationRunner/CommandLineRunner；
- 发布启动完成事件；
- 包扫描：默认扫描 @SpringBootApplication 所在包及其子包。
26. Spring Boot 与 Spring MVC/Spring 区别
一句话总结：Spring 是基础框架，Spring MVC 是其 Web 模块，Spring Boot 是 Spring 的 "脚手架"，简化配置和部署。
表格
| 框架 | 定位 | 核心差异 |
|---|---|---|
| Spring | 核心 IoC/AOP 框架 | 需手动配置 XML，无内嵌容器 |
| Spring MVC | Spring 的 Web 模块 | 专注 Web 请求处理，需整合 Spring |
| Spring Boot | Spring 快速开发工具 | 自动配置、内嵌容器、Starter 依赖 |
七、Spring Cloud 核心
27. Spring Cloud 核心
一句话总结：Spring Cloud 是基于 Spring Boot 的微服务工具集，解决分布式系统的核心问题。
- 核心定位：微服务架构解决方案，依赖 Spring Boot 实现快速开发；
- 核心能力 ：
- 配置管理（Config/Nacos）；
- 服务发现（Eureka/Nacos/Consul）；
- 负载均衡（Ribbon/LoadBalancer）；
- 熔断降级（Hystrix/Sentinel）；
- 网关（Gateway/Zuul）；
- 分布式事务（Seata）。
八、核心要点回顾
- Spring 核心：IoC（容器管理 Bean 生命周期、依赖注入）和 AOP（动态代理实现横切逻辑解耦）是两大基石；
- 关键解决方案 ：
- 循环依赖：三级缓存提前暴露 Bean 早期引用；
- 单例 Bean 线程安全：无状态设计 / ThreadLocal；
- 事务管理：@Transactional 声明式事务（AOP 实现）；
- AOP 实现：JDK/CGLIB 动态代理；
- Spring Boot 核心：基于 "约定大于配置"，自动配置 + Starter 依赖 + 内嵌容器大幅降低开发 / 部署成本；
- 生态关系：Spring 是基础，Spring MVC 是 Web 模块，Spring Boot 是快速开发工具，Spring Cloud 是微服务解决方案。