Spring Boot 面试突击：高频考点全面解析

📌 前置知识：阅读本文需要具备 Java 基础、Servlet 基础、Spring 基础（IoC / AOP / Bean 容器概念）。本文定位为面试突击速查手册，每个考点都按"面试怎么答"组织，建议配合实际项目经验一起记忆。

📊 各模块面试频率参考

在开始具体考点之前，先了解各模块的面试出现频率，有助于合理分配背诵时间：

重点背诵：自动配置原理、事务失效原因、Bean 生命周期、@SpringBootApplication 组成、配置加载优先级。

📖 一、基础概念题

❓ 1.1 什么是 Spring Boot？与 Spring、Spring MVC 的关系？

这是最基础的面试开场题，回答需要简洁清晰、一句话点明三者关系。

Spring：核心是 IoC（Inversion of Control，控制反转）和 AOP（Aspect Oriented Programming，面向切面编程），负责管理 Bean 的完整生命周期。IoC 容器通过 DI（Dependency Injection，依赖注入）实现对象之间的解耦。

Spring MVC：Spring 生态中的 Web 模块，专门处理 HTTP 请求、路由分发、视图渲染。它实现了 MVC（Model-View-Controller）设计模式，核心组件是 DispatcherServlet。

Spring Boot：不是对 Spring 的替代，而是在 Spring 和 Spring MVC 之上的一层整合简化。它提供自动配置、嵌入式容器、Starter 依赖管理，让开发者无需编写 XML 配置即可快速搭建生产级应用。

三者的层次关系如下：

flowchart TD
    SPRING(("⚙️ Spring Framework\nIoC + AOP"))

    SPRING --> MVC["🔄 Spring MVC\nWeb请求处理 / 路由 / 视图"]
    SPRING --> BOOT["🚀 Spring Boot\n整合简化层"]

    BOOT --> AC[自动配置]
    BOOT --> EM[嵌入式容器]
    BOOT --> ST[Starter依赖]
    BOOT --> AC1[Actuator监控]

classDef root fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#bfdbfe,font-weight:bold;
classDef branch fill:#2d1a05,stroke:#f59e0b,stroke-width:2px,color:#fde68a,font-weight:bold;
classDef leaf fill:#1e1e24,stroke:#6b7280,stroke-width:1.5px,color:#e5e7eb;

    class SPRING root
    class MVC,BOOT branch
    class AC,EM,ST,AC1 leaf

一句话总结：Spring Boot = Spring + Spring MVC + 自动配置 + 嵌入式服务器 + Starter。

⚠️ 新手提示：面试中回答这个问题时，切忌说"Spring Boot 是 Spring 的升级版"或"Spring Boot 替代了 Spring"。正确表述是"Spring Boot 是对 Spring 的整合和简化"。

⭐ 1.2 Spring Boot 核心优势？

面试回答时按以下六点依次说明，每条一句话：

1. 简化配置：消除 XML 配置，全部基于 Java Config 和约定
2. 自动配置（Auto Configuration）：根据 classpath 中的 jar 依赖自动配置 Bean
3. 嵌入式容器：内嵌 Tomcat、Jetty 或 Undertow，无需部署 WAR 包
4. Starter 依赖：一组预定义依赖集合，实现一键集成（如 spring-boot-starter-web）
5. 生产级监控（Actuator）：提供 /health、/metrics 等端点用于运维监控
6. 无代码生成、无 XML：不需要生成代码，也不需要 XML 配置文件

实际场景：某团队从传统 Spring MVC 项目迁移到 Spring Boot 后，配置代码量从几百行 XML 减少到几乎为零，本地开发直接运行 main 方法即可启动，不再依赖外部 Tomcat。

🤝 1.3 什么是"约定优于配置"？

“约定优于配置”（Convention over Configuration）是 Spring Boot 的核心理念：框架按照内置的默认约定来工作，开发者只需修改与默认约定不同的部分即可。

具体体现：

⚠️ 新手提示：“约定"是指框架提前设计好的一套默认规则，并非看不见摸不着的"潜规则”。例如，只要把 application.properties 放在 resources 目录下，Spring Boot 就会自动读取它，不需要额外配置。

📝 二、核心注解

❓ 2.1 @SpringBootApplication 是什么？由哪三个注解组成？

📌 前置知识：需要了解 Java 注解基础、@Configuration、@ComponentScan 的基本含义。

@SpringBootApplication 是一个组合注解（元注解），它等价于以下三个注解的叠加：

@SpringBootConfiguration    // 本质是 @Configuration
@EnableAutoConfiguration    // 开启自动配置
@ComponentScan              // 扫描启动类所在包及子包

三者关系如下图所示：

flowchart TD
    SBA["🔷 @SpringBootApplication\n组合注解"]

    SBA --> SBC["⚙️ @SpringBootConfiguration"]
    SBA --> EAC["⚡ @EnableAutoConfiguration"]
    SBA --> CS["🔍 @ComponentScan"]

    SBC --> CFG["本质是 @Configuration\n标识该类为配置类"]
    EAC --> IMP["通过 @Import 引入\nAutoConfigurationImportSelector"]
    CS --> SCAN["默认扫描启动类\n所在包及子包"]

classDef root fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#bfdbfe,font-weight:bold;
classDef branch fill:#2d1a05,stroke:#f59e0b,stroke-width:2px,color:#fde68a,font-weight:bold;
classDef leaf fill:#1e1e24,stroke:#6b7280,stroke-width:1.5px,color:#e5e7eb;

    class SBA root
    class SBC,EAC,CS branch
    class CFG,IMP,SCAN leaf

面试中常见追问：“为什么启动类必须放在根包？"——因为 @ComponentScan 默认扫描启动类所在包及其子包，如果放在子包中，父包中的组件将无法被扫描到。

📋 2.2 常用注解全分类

下表面试中需要全部记住，按功能分类整理：

⚔️ 2.3 @Autowired vs @Resource

实际场景：当项目中存在多个相同类型的 Bean 时（如多个 DataSource），@Autowired 需要配合 @Qualifier("beanName") 使用；而 @Resource(name="beanName") 直接指定名称即可。

// @Autowired 多 Bean 场景需要 @Qualifier
@Autowired
@Qualifier("primaryDataSource")
private DataSource dataSource;

// @Resource 直接通过 name 指定
@Resource(name = "primaryDataSource")
private DataSource dataSource;

⚖️ 2.4 @Component 与 @Configuration 的区别

这是一个区分候选人对 Spring 底层理解深度的题目。

以下 HTML 示意图展示了两种模式在多次调用 @Bean 方法时的行为差异：

🔍 2.5 @Repository 的特殊之处

@Repository 除了标识 DAO 层之外，还有一个特殊功能：将数据库原生异常转换为 Spring 的 DataAccessException。

// MySQL 驱动抛出的原生异常
SQLException → DataAccessException（Spring 统一异常体系）

// 转换前：各数据库异常五花八门
MySQL:     SQLException
Oracle:    SQLException
PostgreSQL: SQLException

// 转换后：Spring 统一封装，便于上层统一处理
DataAccessException
  ├── DataIntegrityViolationException
  ├── DuplicateKeyException
  └── BadSqlGrammarException

这个机制通过 PersistenceExceptionTranslationPostProcessor 实现，它是一个 BeanPostProcessor，专门为标注了 @Repository 的 Bean 创建异常转换代理。

⚙️ 三、自动配置原理

⚙️ 3.1 自动配置如何实现？四步回答法

这是 Spring Boot 面试的灵魂考点，掌握以下四步即可应对所有追问。

以下 HTML+CSS 管线图展示了四步流程的完整路径：

面试回答模板：

1. 入口：@EnableAutoConfiguration 通过 @Import 引入 AutoConfigurationImportSelector
2. 加载：读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports（Spring Boot 2.7+）或旧版 spring.factories 中定义的所有自动配置类全类名
3. 条件过滤：使用 @Conditional 系列注解（如 @ConditionalOnClass、@ConditionalOnMissingBean）判断哪些配置类符合生效条件
4. 注册 Bean：满足条件的配置类中的 @Bean 方法被执行，Bean 注册到容器；其中 @ConditionalOnMissingBean 保证用户自定义 Bean 优先于默认配置

⚠️ 新手提示：条件过滤这步类似"if 判断”——classpath 里有相关 jar 包（@ConditionalOnClass），对应的配置才生效；用户自己定义了 Bean（@ConditionalOnMissingBean），默认的就不再生效。

下面用 Mermaid 流程图展示底层调用链：

flowchart TD
    START(["🔷 @EnableAutoConfiguration"])

    START --> IMPORT["@Import 导入\nAutoConfigurationImportSelector"]

    IMPORT --> METADATA["读取 spring.factories 或\nAutoConfiguration.imports"]

    METADATA --> FILTER{"🔍 @Conditional\n条件判断"}

    FILTER -->|满足| REGISTER["✅ 注册 Bean 到容器"]
    FILTER -->|不满足| SKIP["⏭️ 跳过此配置"]

    REGISTER --> PRIORITY{"@ConditionalOnMissingBean?"}
    PRIORITY -->|用户未定义| DEFAULT["使用默认 Bean"]
    PRIORITY -->|用户已定义| USER["使用用户自定义 Bean"]

classDef startEnd fill:#701a4c,stroke:#e11d48,stroke-width:2px,color:#fce7f3,font-weight:bold;
classDef condition fill:#2a1147,stroke:#a855f7,stroke-width:1.5px,color:#ede9fe,font-weight:bold;
classDef process fill:#1e1e24,stroke:#6b7280,stroke-width:1.5px,color:#e5e7eb;
classDef highlight fill:#450a0a,stroke:#dc2626,stroke-width:1.5px,color:#fecaca,font-weight:bold;

    class START startEnd
    class FILTER,PRIORITY condition
    class IMPORT,METADATA,REGISTER,SKIP,DEFAULT,USER process

🎛️ 3.2 常用 @Conditional 注解

🌐 3.3 spring-boot-starter-web 自动配置了什么？

当引入 spring-boot-starter-web 后，以下组件会被自动配置：

🚫 3.4 如何排除自动配置类？

两种方式：

// 方式一：注解属性排除
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

# 方式二：配置文件排除
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

实际场景：当项目不涉及数据库操作，但又引入了包含 DataSourceAutoConfiguration 的依赖时，启动会报"无法配置 DataSource"错误，此时需要排除该自动配置类。

📦 四、Starter 与依赖管理

📦 4.1 什么是 Starter？原理？

Starter 是一组预定义的依赖集合（Maven POM 中的依赖描述），它本身不包含任何代码，只是一个"依赖清单"。启动时，Starter 的自动配置模块读取 META-INF/spring/...AutoConfiguration.imports，加载对应的自动配置类，条件化注册 Bean。

常见 Starter：

🔧 4.2 如何自定义 Starter？

以创建 myapp-spring-boot-starter 为例，分以下步骤：

1. 创建 Maven 项目：添加 spring-boot-starter（核心 Starter 依赖）和 spring-boot-autoconfigure（自动配置支持）
2. 编写配置属性类：

@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String host = "localhost";  // 默认值
    private int port = 8080;
    // getter / setter
}

3. 编写自动配置类：

@Configuration
@ConditionalOnClass(MyAppService.class)
@EnableConfigurationProperties(MyAppProperties.class)
public class MyAppAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public MyAppService myAppService(MyAppProperties properties) {
        return new MyAppService(properties.getHost(), properties.getPort());
    }
}

4. 注册自动配置：在 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 中写入配置类全类名：

com.example.myapp.autoconfigure.MyAppAutoConfiguration

5. 打包发布：mvn clean install 发布到 Maven 仓库

🔧 五、配置文件

⚔️ 5.1 properties vs yml

# properties 写法
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456

# yml 写法（层级清晰）
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456

🌍 5.2 多环境配置

使用 Spring Profile 实现多环境隔离：

application.yml            # 公共配置
application-dev.yml        # 开发环境
application-prod.yml       # 生产环境
application-test.yml       # 测试环境

激活方式：

# 方式一：配置文件
spring.profiles.active=dev

# 方式二：启动参数
java -jar app.jar --spring.profiles.active=prod

# 方式三：环境变量
export SPRING_PROFILES_ACTIVE=prod

📖 5.3 读取配置的方式

// 方式一：单个值注入
@Value("${server.port}")
private int port;

// 方式二：批量绑定（推荐）
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
}

// 方式三：编程式获取
@Autowired
private Environment env;
String port = env.getProperty("server.port");

📊 5.4 配置加载优先级

从高到低的优先级顺序如下：

⚠️ 新手提示：命令行参数优先级最高意味着——即使 application.yml 中写了 server.port=8080，通过 --server.port=9090 启动时实际端口仍是 9090。这在 Docker 部署时特别常用。

🌐 六、Web 与 MVC

🔄 6.1 Spring MVC 执行流程

这是面试中经常要求"手绘流程图"的考点。下面先用 HTML+CSS 管线图直观展示核心流程：

面试口述版本：

1. 用户请求到达 DispatcherServlet（前端控制器）
2. DispatcherServlet 调用 HandlerMapping 找到处理请求的 HandlerExecutionChain（包含 Handler + Interceptors）
3. DispatcherServlet 调用 HandlerAdapter 执行对应的 Controller 方法
4. Controller 调用 Service 层完成业务逻辑，返回 ModelAndView
5. DispatcherServlet 将逻辑视图名交给 ViewResolver 解析为物理视图
6. 渲染视图，生成 HTML 响应返回客户端

📌 前置知识：需要了解 Servlet 规范中的 doGet/doPost 方法，以及 Filter 和 Servlet 的执行顺序。

🚨 6.2 全局异常处理

@RestControllerAdvice  // @ControllerAdvice + @ResponseBody
public class GlobalExceptionHandler {

    @ExceptionHandler(BusinessException.class)
    public Result handleBusinessException(BusinessException e) {
        return Result.error(e.getCode(), e.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e) {
        log.error("系统异常", e);
        return Result.error(500, "系统繁忙，请稍后再试");
    }
}

实际场景：某项目的订单接口在生产环境出现空指针异常，由于没有全局异常处理，前端收到的是 Tomcat 默认的 HTML 错误页面而非 JSON 格式的错误信息，导致前端解析失败。加入 @RestControllerAdvice 全局异常处理后，所有异常统一返回 JSON 格式。

🌐 6.3 跨域解决（CORS）

CORS（Cross-Origin Resource Sharing，跨域资源共享）是浏览器的安全策略。当前后端分离部署在不同域名/端口时，前端请求会被浏览器拦截。

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")        // 允许所有路径
                .allowedOrigins("*")       // 允许所有来源
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*");
    }
}

⚠️ 新手提示：跨域是浏览器行为，不是后端拒绝请求。请求实际上已经到达后端并返回了数据，但浏览器发现响应头中没有正确的 CORS 头，于是拦截了响应。生产环境不允许使用 *，应配置具体的域名白名单。

🔄 七、事务管理

⚙️ 7.1 声明式事务实现原理

Spring 声明式事务基于 AOP 动态代理实现。核心流程如下：

flowchart TD
    CALL(["🔷 调用 @Transactional 方法"])

    CALL --> PROXY{AOP 代理拦截}

    PROXY --> TM[⚙️ PlatformTransactionManager\n开启事务]

    TM --> EXEC[执行目标方法]

    EXEC --> CHECK{是否抛出异常?}

    CHECK -->|正常返回| COMMIT[✅ 提交事务]
    CHECK -->|RuntimeException/Error| ROLLBACK[❌ 回滚事务]
    CHECK -->|受检异常| DEPENDS{rollbackFor\n是否配置?}

    DEPENDS -->|已配置| ROLLBACK
    DEPENDS -->|未配置| COMMIT

    COMMIT --> END([事务结束])
    ROLLBACK --> END

classDef startEnd fill:#701a4c,stroke:#e11d48,stroke-width:2px,color:#fce7f3,font-weight:bold;
classDef condition fill:#2a1147,stroke:#a855f7,stroke-width:1.5px,color:#ede9fe,font-weight:bold;
classDef process fill:#1e1e24,stroke:#6b7280,stroke-width:1.5px,color:#e5e7eb;
classDef reject fill:#450a0a,stroke:#dc2626,stroke-width:1.5px,color:#fecaca,font-weight:bold;

    class CALL,END startEnd
    class PROXY,CHECK,DEPENDS condition
    class TM,EXEC process
    class ROLLBACK reject

关键点：

• 启动时扫描 @Transactional，为标注的类的 public 方法创建代理
• 方法调用前通过 PlatformTransactionManager 开启事务
• 默认只对 RuntimeException 和 Error 回滚（受检异常需显式配置 rollbackFor）

📡 7.2 事务传播行为

Spring 定义了 7 种传播行为，面试中重点掌握 3 种：

以下 HTML 示意图展示了三种重点传播行为的区别：

⚠️ 7.3 事务失效常见原因

面试超高频考点——以下列举 7 种常见失效场景：

this 调用失效的详细说明：

Spring 事务依赖 AOP 代理：调用 代理对象.方法() 时，代理在方法前后织入事务逻辑。但同类内部 this.method() 直接调用 this（原始对象），绕过了代理，事务因此失效。

@Service
public class OrderService {

    // ❌ 事务失效：this.createOrder() 不经过代理
    public void process() {
        this.createOrder();  // 直接调用，无事务
    }

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

修复方式——注入自身：

@Service
public class OrderService {

    @Autowired
    private OrderService self;  // 注入代理对象

    public void process() {
        self.createOrder();  // ✅ 通过代理调用，事务生效
    }

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

🔪 八、AOP

⚙️ 8.1 Spring AOP 实现原理

Spring AOP 基于 动态代理实现，在运行时期将切面逻辑（Advice）织入目标方法。根据目标对象是否实现接口，选择不同的代理方式：

flowchart TD
    TARGET[🎯 目标对象]

    TARGET --> CHECK{目标是否\n实现接口?}

    CHECK -->|是| JDK[🔷 JDK 动态代理\n基于接口生成代理]
    CHECK -->|否| CGLIB[🔶 CGLIB 代理\n继承目标类生成子类]

    JDK --> JDK_METHOD[基于反射调用\njava.lang.reflect.Proxy]
    CGLIB --> CGLIB_METHOD[基于字节码生成子类\norg.springframework.cglib]

classDef condition fill:#2a1147,stroke:#a855f7,stroke-width:1.5px,color:#ede9fe,font-weight:bold;
classDef process fill:#1e1e24,stroke:#6b7280,stroke-width:1.5px,color:#e5e7eb;

    class CHECK condition
    class TARGET,JDK,CGLIB,JDK_METHOD,CGLIB_METHOD process

⚖️ 8.2 JDK vs CGLIB 对比

默认策略：Spring Boot 2.x 默认 proxyTargetClass=true，优先使用 CGLIB。有接口时也可通过显式配置使用 JDK 代理。

⚠️ 新手提示：CGLIB 通过继承实现代理，因此 final 修饰的类和方法无法被 CGLIB 代理。Spring Boot 中 Controller 和 Service 默认被代理，这就是为什么 @Transactional 不能标注在 final 方法上。

📊 九、Actuator 生产监控

📊 9.1 Actuator 概述与常用端点

Spring Boot Actuator 是内置的生产级监控工具，通过 HTTP 端点暴露应用运行状态。

常用端点：

生产环境安全配置：

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics  # 仅暴露安全端点
  endpoint:
    health:
      show-details: when-authorized   # 授权后才显示详情

⚠️ 新手提示：生产环境绝不能用 * 暴露所有端点，尤其 /env 和 /beans 可能泄露配置密码和内部架构信息。通常只暴露 health、info、metrics 三个端点给监控系统（如 Prometheus）。

🔄 十、Bean 生命周期

🔄 10.1 Spring Bean 生命周期完整流程

这是面试最高频考点之一，需要完整背诵以下 8 个阶段。下面用 HTML+CSS 管线图直观展示：

面试口述版本（按顺序背诵）：

1. 实例化：反射调用构造器创建 Bean 实例
2. 属性填充：为 Bean 注入依赖（@Autowired、@Value 等）
3. Aware 接口回调：依次调用 BeanNameAware → BeanFactoryAware → ApplicationContextAware
4. BeanPostProcessor 前置处理：postProcessBeforeInitialization()
5. 初始化：按顺序执行 @PostConstruct → InitializingBean.afterPropertiesSet() → @Bean(initMethod)
6. BeanPostProcessor 后置处理：postProcessAfterInitialization()——AOP 动态代理在此阶段生成
7. 使用 Bean：放入容器，业务代码通过 @Autowired 使用
8. 销毁：容器关闭时，按顺序执行 @PreDestroy → DisposableBean.destroy() → @Bean(destroyMethod)

面试连问技巧：记住阶段 4 和阶段 6 这两个 BeanPostProcessor 回调，阶段 5 的三种初始化方式是有严格先后顺序的——@PostConstruct > afterPropertiesSet() > initMethod。

🚀 十一、启动流程与高级特性

🚀 11.1 Spring Boot 启动流程

flowchart TD
    RUN([🚀 SpringApplication.run])

    RUN --> ENV[⚙️ 准备 Environment\n加载配置文件]

    ENV --> CTX[🏗️ 创建 ApplicationContext\n推断应用类型]

    CTX --> REFRESH[🔄 刷新容器 refresh\n实例化所有单例 Bean]

    REFRESH --> RUNNER[▶️ 执行 ApplicationRunner\n和 CommandLineRunner]

    RUNNER --> WEB[🌐 启动嵌入式 Web 服务器\nTomcat/Jetty/Undertow]

    WEB --> DONE([✅ 启动完成])

classDef startEnd fill:#701a4c,stroke:#e11d48,stroke-width:2px,color:#fce7f3,font-weight:bold;
classDef process fill:#1e1e24,stroke:#6b7280,stroke-width:1.5px,color:#e5e7eb;

    class RUN,DONE startEnd
    class ENV,CTX,REFRESH,RUNNER,WEB process

面试口述版本：

1. 准备 Environment，加载配置属性
2. 根据 classpath 推断应用类型，创建对应的 ApplicationContext（如 AnnotationConfigServletWebServerApplicationContext）
3. 刷新容器（refresh() 方法）——这是最核心的一步，会实例化所有单例 Bean
4. 执行 ApplicationRunner 和 CommandLineRunner 回调
5. 启动嵌入式 Web 服务器（Tomcat/Jetty/Undertow），监听端口

🔄 11.2 Spring Boot 3.x 主要变化（相比 2.x）

🔥 11.3 热部署如何实现？

添加 spring-boot-devtools 依赖即可实现热部署：

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

原理：devtools 使用双 ClassLoader机制——第三方 jar 由 base ClassLoader 加载（不会变），项目代码由 restart ClassLoader 加载。代码变更时，restart ClassLoader 销毁并重建，实现快速重启。

🐳 11.4 支持的嵌入式容器？如何替换？

替换为 Jetty 的示例：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

🎯 十二、面试频率总览与背诵策略

📊 12.1 模块频率速查表

📝 12.2 背诵顺序建议

按照面试提问的递进逻辑来组织记忆：

⚠️ 给读者的面试提醒：本文覆盖的 32 个考点是 Spring Boot 面试的高频范围。建议按照第 12 节的背诵顺序，每天攻破 2 ~ 3 个考点，两周内完成全部记忆。面试中回答原理类问题时，一定要先给结论再展开，不要边想边说。如果遇到不会的问题，可以坦诚说明"目前还没有深入了解过这个点"，然后引导面试官到自己熟悉的领域（如自动配置、事务管理等），避免冷场。

🖼️ 网络图片占位符标注位置：

• 第 6.1 节 “Spring MVC 执行流程”：DispatcherServlet 完整请求处理架构图，需替换 IMAGE_URL_PLACEHOLDER
• 第 10.1 节 “Bean 生命周期完整流程”：Spring IoC 容器 Bean 生命周期官方示意图，需替换 IMAGE_URL_PLACEHOLDER