Spring IoC 容器初始化全链路深度解析：从 BeanFactory 到 refresh() 的底层真相

Spring IoC 容器初始化全链路深度解析：从 BeanFactory 到 refresh() 的底层真相

后端技术源码解读系列 · 第一篇 > 基于 Spring Framework 6.1.x 源码，逐行剖析 IoC 容器初始化的每一步关键操作。读完本文，你对 Spring 的理解将从"会用"跃升到"懂底层"。---## 一、前言：为什么你必须理解 IoC 容器初始化多数 Java 开发者对 Spring IoC 的认知停留在"配置 Bean → Spring 自动装配"这一层。但你有没有想过：- AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class) 这一行代码背后，Spring 到底做了什么？- @ComponentScan、@Bean、@Import 这些注解是在什么时机被处理的？- 为什么 BeanFactoryPostProcessor 能修改 BeanDefinition，而 BeanPostProcessor 只能修改 Bean 实例？答案全部藏在 refresh() 方法里。 这个方法只有不到 200 行代码（含注释），却是整个 Spring Framework 最精密的齿轮箱。今天，本座带你把这 200 行代码彻底拆开。---## 二、容器体系：BeanFactory 与 ApplicationContext 的继承帝国在理解初始化流程之前，必须先搞清楚 Spring 容器的类层次结构。这是理解后续所有源码的前提。### 2.1 核心继承体系mermaidclassDiagram class BeanFactory { <<interface>> +getBean(name) Object +containsBean(name) boolean +isSingleton(name) boolean +getType(name) Class } class AutowireCapableBeanFactory { <<interface>> +createBean() Object +autowire() Object +configureBean() void } class ConfigurableListableBeanFactory { <<interface>> +getBeanDefinition(name) BeanDefinition +registerBeanDefinition() void +getBeanNamesForType() String[] } class DefaultListableBeanFactory { -beanDefinitionMap ConcurrentHashMap -beanDefinitionNames List~String~ -singletonObjects ConcurrentHashMap +registerBeanDefinition() void +getBeanDefinition() BeanDefinition +preInstantiateSingletons() void } class ApplicationContext { <<interface>> +getBean() Object +publishEvent() void +getEnvironment() Environment } class AbstractApplicationContext { +refresh() void #initMessageSource() void #initApplicationEventMulticaster() void } class AbstractRefreshableApplicationContext { #refreshBeanFactory() void #loadBeanDefinitions() void } class GenericApplicationContext { -beanFactory DefaultListableBeanFactory } class AnnotationConfigApplicationContext { +scan() void +register() void } BeanFactory <|.. AutowireCapableBeanFactory AutowireCapableBeanFactory <|.. ConfigurableListableBeanFactory ConfigurableListableBeanFactory <|.. DefaultListableBeanFactory BeanFactory <|.. ApplicationContext ApplicationContext <|.. AbstractApplicationContext AbstractApplicationContext <|-- AbstractRefreshableApplicationContext AbstractApplicationContext <|-- GenericApplicationContext GenericApplicationContext <|-- AnnotationConfigApplicationContext AbstractRefreshableApplicationContext <|-- ClassPathXmlApplicationContext AbstractApplicationContext o-- DefaultListableBeanFactory : holds### 2.2 BeanFactory vs ApplicationContext 对比| 特性 | BeanFactory | ApplicationContext ||------|-------------|-------------------|| Bean 加载策略 | 懒加载（Lazy Init） | 预加载（Eager Init） || 国际化支持 | ❌ 不支持 | ✅ MessageSource || 事件发布 | ❌ 不支持 | ✅ ApplicationEvent || 资源访问 | ❌ 不支持 | ✅ ResourcePatternResolver || AOP 集成 | 需手动配置 | 自动注册 || BeanPostProcessor 注册 | 需手动调用 | 自动检测并注册 || 适用场景 | 资源受限环境 | 企业级应用（99%场景） |关键结论： DefaultListableBeanFactory 是 Spring 中唯一真正拥有 BeanDefinition 存储和 Bean 创建能力的实现类。ApplicationContext 本身不存储 Bean，而是持有一个 DefaultListableBeanFactory 实例，将所有核心操作委托给它。源码佐证（GenericApplicationContext.java，Spring 6.1.x）：javapublic class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry { private final DefaultListableBeanFactory beanFactory; public GenericApplicationContext() { // 构造时直接创建 DefaultListableBeanFactory 实例 this.beanFactory = new DefaultListableBeanFactory(); } // 所有 getBean 操作最终委托给 beanFactory @Override public Object getBean(String name) throws BeansException { return this.beanFactory.getBean(name); }}---## 三、refresh() 方法：Spring 最精密的模板方法AbstractApplicationContext.refresh() 是 Spring 容器初始化的灵魂方法。它采用 模板方法模式 ，定义了 12 个固定步骤，每个步骤由子类或回调接口具体实现。### 3.1 完整源码（Spring 6.1.x AbstractApplicationContext.java）javapublic void refresh() throws BeansException, IllegalStateException { // 加锁：防止并发刷新导致容器状态不一致 synchronized (this.startupShutdownMonitor) { StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); // ===== 第1步：准备刷新上下文环境 ===== // 记录启动时间、校验必需属性（如 jndi 环境是否可用） // 设置 active 和 closed 状态标志 prepareRefresh(); // ===== 第2步：获取/创建 BeanFactory ===== // 子类实现：创建新的 DefaultListableBeanFactory // 加载所有 BeanDefinition 到 BeanFactory 中 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // ===== 第3步：准备 BeanFactory ===== // 设置 BeanFactory 的标准特性： // - ClassLoader、SPEL 表达式解析器、属性编辑器注册 // - 添加 ApplicationContextAwareProcessor（处理各种 *Aware 接口回调） // - 忽略自动装配的接口（如 EnvironmentAware） // - 注册可解析的依赖（如 BeanFactory、ApplicationContext 本身） prepareBeanFactory(beanFactory); try { // ===== 第4步：允许子类对 BeanFactory 进行后处理 ===== // 空的模板方法，由子类重写 // 例如 WebApplicationContext 在这里注册 ServletContext 相关的 Bean postProcessBeanFactory(beanFactory); // ===== 第5步：调用所有 BeanFactoryPostProcessor ===== // ⚠️ 这是整个容器初始化中最重要的扩展点之一 // 典型代表：PropertySourcesPlaceholderConfigurer（处理 ${} 占位符） // ConfigurationClassPostProcessor（处理 @Configuration 注解） // 执行顺序：PriorityOrdered → Ordered → 普通 invokeBeanFactoryPostProcessors(beanFactory); // ===== 第6步：注册所有 BeanPostProcessor ===== // 注意：这里只是注册，还不会执行 // 真正执行要等到每个 Bean 的创建过程中 // 典型代表：AutowiredAnnotationBeanPostProcessor（处理 @Autowired） // CommonAnnotationBeanPostProcessor（处理 @Resource） registerBeanPostProcessors(beanFactory); // ===== 第7步：初始化消息源（国际化） ===== // 支持 i18n，从 BeanDefinition 中查找名为 "messageSource" 的 Bean initMessageSource(); // ===== 第8步：初始化事件广播器 ===== // 查找名为 "applicationEventMulticaster" 的 Bean // 如果没有，默认创建 SimpleApplicationEventMulticaster initApplicationEventMulticaster(); // ===== 第9步：子类扩展点 ===== // 典型实现：WebApplicationContext 在这里初始化主题资源等 onRefresh(); // ===== 第10步：注册事件监听器 ===== // 扫描所有 ApplicationListener 类型的 Bean，注册到广播器 registerListeners(); // ===== 第11步：实例化所有剩余的非懒加载单例 Bean ===== // ⚠️ 这是 Bean 真正被创建的地方 // 包括依赖注入、AOP 代理生成、初始化方法调用等全部发生在这里 finishBeanFactoryInitialization(beanFactory); // ===== 第12步：完成刷新，发布容器刷新完成事件 ===== // 发布 ContextRefreshedEvent // 清除资源缓存、初始化 LifecycleProcessor finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // 销毁已创建的单例 Bean，防止资源泄漏 destroyBeans(); // 重置 active 标志 cancelRefresh(ex); throw ex; } finally { resetCommonCaches(); contextRefresh.end(); } }}### 3.2 十二步骤一览| 步骤 | 方法名 | 核心职责 | 扩展点 ||------|--------|---------|--------|| 1 | prepareRefresh() | 设置启动时间、校验环境、初始化属性源 | 可重写 || 2 | obtainFreshBeanFactory() | 创建 BeanFactory、加载 BeanDefinition | 子类重写 || 3 | prepareBeanFactory() | 配置 BeanFactory 标准特性 | 可重写 || 4 | postProcessBeanFactory() | 子类自定义后处理 | 模板方法 || 5 | invokeBeanFactoryPostProcessors() | 执行 BeanFactoryPostProcessor | ✅ 重要扩展点 || 6 | registerBeanPostProcessors() | 注册 BeanPostProcessor | ✅ 重要扩展点 || 7 | initMessageSource() | 初始化国际化消息源 | --- || 8 | initApplicationEventMulticaster() | 初始化事件广播器 | --- || 9 | onRefresh() | 子类初始化特殊 Bean | 模板方法 || 10 | registerListeners() | 注册事件监听器 | --- || 11 | finishBeanFactoryInitialization() | 实例化所有单例 Bean | ✅ 核心步骤 || 12 | finishRefresh() | 发布刷新完成事件 | 可重写 |### 3.3 初始化总流程图mermaidflowchart TD A["new AnnotationConfigApplicationContext(AppConfig.class)"] --> B["① prepareRefresh()准备刷新环境"] B --> C["② obtainFreshBeanFactory()创建 BeanFactory + 加载 BeanDefinition"] C --> D["③ prepareBeanFactory()配置标准特性"] D --> E["④ postProcessBeanFactory()子类后处理"] E --> F["⑤ invokeBeanFactoryPostProcessors执行工厂后置处理器"] F --> G["⑥ registerBeanPostProcessors注册 Bean 后置处理器"] G --> H["⑦ initMessageSource初始化消息源"] H --> I["⑧ initApplicationEventMulticaster初始化事件广播器"] I --> J["⑨ onRefresh子类扩展"] J --> K["⑩ registerListeners注册事件监听器"] K --> L["⑪ finishBeanFactoryInitialization实例化所有单例 Bean"] L --> M["⑫ finishRefresh发布刷新完成事件"] style F fill:#ff6b6b,color:#fff style G fill:#ff6b6b,color:#fff style L fill:#ff6b6b,color:#fff---## 四、BeanDefinition 的加载、解析、注册全链路BeanDefinition 是 Spring 容器中 Bean 的"设计图纸"------它描述了一个 Bean 的类型、作用域、属性、依赖关系等所有元信息。### 4.1 BeanDefinition 的核心属性java// RootBeanDefinition.java（Spring 6.1.x）public class RootBeanDefinition extends AbstractBeanDefinition { private volatile Class<?> resolvedTargetType; // 解析后的目标类型 private volatile Object beanClass; // Bean 的 Class 对象或类名 private int role = BeanDefinition.ROLE_APPLICATION; // Bean 角色 private BeanDefinitionHolder decoratedDefinition; // 装饰器定义}``````java// AbstractBeanDefinition.java 关键属性public abstract class AbstractBeanDefinition implements BeanDefinition, Cloneable { private volatile Object beanClass; // 类名或 Class 对象 private ScopeMetadata scopeMetadata; // 作用域元数据 private String scope = SCOPE_DEFAULT; // 作用域：singleton / prototype private boolean abstractFlag = false; // 是否抽象 Bean（不会被实例化） private boolean lazyInit = false; // 是否懒加载 private int autowireMode = AUTOWIRE_NO; // 自动装配模式 private int dependencyCheck = DEPENDENCY_CHECK_NONE; private String[] dependsOn; // 显式依赖（初始化前必须先初始化） private boolean autowireCandidate = true; // 是否作为自动装配候选 private boolean primary = false; // 是否首选 Bean private final Map<String, AutowiredPropertyMarker> qualifierEntries; // @Qualifier private ConstructorArgumentValues constructorArgumentValues; // 构造参数 private MutablePropertyValues propertyValues; // 属性值 private MethodOverrides methodOverrides; // 方法覆盖（lookup-method 等） private String[] initMethodNames; // 初始化方法名 private String[] destroyMethodNames; // 销毁方法名 private boolean enforceInitMethod = true; private boolean enforceDestroyMethod = true; private boolean synthetic = false; // 是否合成（框架内部生成）}### 4.2 注解驱动的加载流程以 AnnotationConfigApplicationContext 为例，当执行 new AnnotationConfigApplicationContext(AppConfig.class) 时：java// AnnotationConfigApplicationContext.java（Spring 6.1.x）public AnnotationConfigApplicationContext(Class<?>... componentClasses) { // 1. 调用无参构造，创建 AnnotatedBeanDefinitionReader 和 ClassPathBeanDefinitionScanner this(); // 2. 注册配置类为 BeanDefinition register(componentClasses); // 3. 触发 refresh() 开始容器初始化 refresh();}public AnnotationConfigApplicationContext() { // 创建读取器：用于解析 @Configuration 注解的类 this.reader = new AnnotatedBeanDefinitionReader(this); // 创建扫描器：用于扫描 @Component 注解的类 this.scanner = new ClassPathBeanDefinitionScanner(this);}核心链路如下：register(AppConfig.class) └→ reader.register(componentClasses) └→ registerBean(componentClass) └→ BeanDefinitionReaderUtils.registerBeanDefinition() └→ BeanDefinitionRegistry.registerBeanDefinition() └→ DefaultListableBeanFactory.registerBeanDefinition() └→ this.beanDefinitionMap.put(beanName, beanDefinition)### 4.3 ConfigurationClassPostProcessor：最关键的 BeanFactoryPostProcessor这是 @Configuration 注解驱动的核心处理器。它在第 5 步（invokeBeanFactoryPostProcessors）被调用时，完成以下工作：java// ConfigurationClassPostProcessor.java（Spring 6.1.x）@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { // 解析所有 @Configuration 类 processConfigBeanDefinitions(registry);}public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { List<BeanDefinitionHolder> configCandidates = new ArrayList<>(); // 1. 遍历所有已注册的 BeanDefinition，筛选出 @Configuration 类 for (String beanName : registry.getBeanDefinitionNames()) { BeanDefinition beanDef = registry.getBeanDefinition(beanName); // 检查是否有 @Configuration 注解（full 模式）或 @Component（lite 模式） if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) { configCandidates.add(new BeanDefinitionHolder(beanDef, beanName)); } } // 2. 创建解析器 ConfigurationClassParser parser = new ConfigurationClassParser(...); // 3. 解析每个配置类 for (BeanDefinitionHolder holder : configCandidates) { BeanDefinition bd = holder.getBeanDefinition(); // 解析 @ComponentScan → 扫描并注册带 @Component 的类 // 解析 @Import → 导入其他配置类或 ImportSelector/ImportBeanDefinitionRegistrar // 解析 @Bean 方法 → 注册为 BeanDefinition // 解析 @ImportResource → 加载 XML 配置文件 parser.parse(bd.getBeanClassName(), holder.getBeanName()); } // 4. 加载所有解析出来的 BeanDefinition this.reader.loadBeanDefinitions(configClasses);}### 4.4 BeanDefinition 的存储结构所有 BeanDefinition 最终存储在 DefaultListableBeanFactory 的 beanDefinitionMap 中：java// DefaultListableBeanFactory.java（Spring 6.1.x）public class DefaultListableBeanFactory extends ... { /** 存储 BeanName → BeanDefinition 的映射 */ private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256); /** 按注册顺序保存所有 BeanName */ private volatile List<String> beanDefinitionNames = new CopyOnWriteArrayList<>(); /** 单例 Bean 的缓存（一级缓存）：BeanName → 完整的 Bean 实例 */ private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /** 早期单例引用（三级缓存）：BeanName → ObjectFactory */ private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /** 已实例化的早期单例（二级缓存）：BeanName → 早期 Bean 实例 */ private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);}> 💡 提示： 这三个 singleton* 缓存就是解决循环依赖的"三级缓存"机制。后续文章会单独解析。---## 五、BeanFactoryPostProcessor 与 BeanPostProcessor：两大扩展点的本质区别这是 Spring 面试中最高频的问题之一，也是理解容器初始化的关键。### 5.1 对比总览| 维度 | BeanFactoryPostProcessor | BeanPostProcessor ||------|--------------------------|-------------------|| 操作对象 | BeanDefinition（Bean 的元数据） | Bean 实例（已创建的对象） || 执行时机 | refresh() 第 5 步，Bean 实例化之前 | 每个 Bean 创建过程中，实例化之后 || 能做什么 | 修改/新增/删除 BeanDefinition | 修改/包装/代理 Bean 实例 || 典型应用 | PropertySourcesPlaceholderConfigurer
ConfigurationClassPostProcessor | AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
AbstractAutoProxyCreator（AOP） || 影响范围 | 全局影响容器配置 | 逐个影响 Bean 实例 || 设计模式 | 策略模式 | 责任链模式 |### 5.2 BeanFactoryPostProcessor 执行时机mermaidflowchart LR A["BeanDefinition 已加载"] --> B["invokeBeanFactoryPostProcessors"] B --> C["修改 BeanDefinition"] C --> D["注册 BeanPostProcessor"] D --> E["实例化 Bean"] E --> F["BeanPostProcessor 拦截"] style B fill:#ff6b6b,color:#fff style F fill:#4ecdc4,color:#fff``````java// PostProcessorRegistrationDelegate.java（Spring 6.1.x）public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { // Phase 1: 执行 BeanDefinitionRegistryPostProcessor // 1a. PriorityOrdered 优先级 // 1b. Ordered 优先级 // 1c. 普通优先级 // → ConfigurationClassPostProcessor 就在 Phase 1 被调用 // 它会扫描出更多的 BeanDefinition（比如 @ComponentScan 发现的类） // Phase 2: 执行 BeanFactoryPostProcessor // 2a. PriorityOrdered 优先级 // 2b. Ordered 优先级 // 2c. 普通优先级}### 5.3 BeanPostProcessor 的两个关键方法java// BeanPostProcessor.java（Spring 6.1.x）public interface BeanPostProcessor { // 在 Bean 初始化方法（InitializingBean.afterPropertiesSet / @PostConstruct / init-method）之前调用 // 典型用途：@Autowired 注入、@Value 注入 default Object postProcessBeforeInitialization(Object bean, String beanName) { return bean; } // 在 Bean 初始化方法之后调用 // 典型用途：AOP 代理生成（AbstractAutoProxyCreator） default Object postProcessAfterInitialization(Object bean, String beanName) { return bean; }}### 5.4 Bean 创建的完整生命周期mermaidflowchart TD A["① 实例化<br>createBeanInstance()"] --> B["② 属性填充<br>populateBean()"] B --> C["③ Aware 接口回调<br>BeanNameAware, BeanFactoryAware 等"] C --> D["④ BeanPostProcessor.postProcessBeforeInitialization"] D --> E["⑤ 初始化方法<br>InitializingBean.afterPropertiesSet()"] E --> F["⑥ 自定义 init-method"] F --> G["⑦ BeanPostProcessor.postProcessAfterInitialization"] G --> H["⑧ Bean 就绪，可使用"] H --> I["⑨ 销毁<br>DisposableBean.destroy()"] style D fill:#4ecdc4,color:#fff style G fill:#4ecdc4,color:#fff对应源码（AbstractAutowireCapableBeanFactory.initializeBean()，Spring 6.1.x）：javaprotected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { // 1. 调用 Aware 接口回调方法 invokeAwareMethods(beanName, bean); Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 2. 执行所有 BeanPostProcessor.postProcessBeforeInitialization wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 3. 调用初始化方法 // 依次尝试：InitializingBean.afterPropertiesSet() → 自定义 init-method invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException(...); } if (mbd == null || !mbd.isSynthetic()) { // 4. 执行所有 BeanPostProcessor.postProcessAfterInitialization // ⚠️ AOP 代理就是在这里生成的！ wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean;}---## 六、从配置到运行：一个完整的启动示例让我们用一个极简示例串联所有概念：java// AppConfig.java@Configuration@ComponentScan("com.example")public class AppConfig { @Bean public DataSource dataSource(@Value("${db.url}") String url) { return new HikariDataSource(url); }}// Main.javapublic class Main { public static void main(String[] args) { // 一行代码，背后是 12 个精密步骤 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); DataSource ds = context.getBean(DataSource.class); System.out.println("数据源已就绪：" + ds); }}执行时序如下：1. AnnotationConfigApplicationContext() └→ 创建 AnnotatedBeanDefinitionReader（注册内置后置处理器） └→ 创建 ClassPathBeanDefinitionScanner2. register(AppConfig.class) └→ 将 AppConfig 注册为 BeanDefinition3. refresh() ├→ 第 5 步：ConfigurationClassPostProcessor 被调用 │ ├→ 解析 @Configuration │ ├→ 解析 @ComponentScan → 扫描 com.example 包下的 @Component 类 │ ├→ 解析 @Bean → 注册 dataSource BeanDefinition │ └→ 所有 BeanDefinition 加载到 beanDefinitionMap │ ├→ 第 6 步：注册 BeanPostProcessor │ ├→ AutowiredAnnotationBeanPostProcessor（处理 @Autowired / @Value） │ ├→ CommonAnnotationBeanPostProcessor（处理 @Resource / @PostConstruct） │ └→ ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor │ ├→ 第 11 步：finishBeanFactoryInitialization │ ├→ 实例化 dataSource Bean │ │ ├→ createBeanInstance() → 反射创建 HikariDataSource │ │ ├→ populateBean() → 解析 @Value("${db.url}")，注入属性值 │ │ ├→ postProcessBeforeInitialization → @Autowired 注入 │ │ └→ postProcessAfterInitialization → AOP 代理判断 │ └→ 实例化所有扫描到的 @Component 类 │ └→ 第 12 步：finishRefresh → 发布 ContextRefreshedEvent---## 七、常见面试题与易混淆点### Q1：BeanFactoryPostProcessor 和 BeanPostProcessor 的执行顺序是什么？答： 先执行所有 BeanFactoryPostProcessor（第 5 步），再注册所有 BeanPostProcessor（第 6 步）。BeanPostProcessor 的真正执行贯穿于第 11 步每一个 Bean 的创建过程。### Q2：@Configuration 和 @Component 的区别是什么？答： @Configuration 是 Full 模式，Spring 会为配置类创建 CGLIB 代理，保证 @Bean 方法的语义------多次调用同一个 @Bean 方法返回同一个实例。@Component 是 Lite 模式，不会创建代理，每次调用 @Bean 方法都会创建新实例。### Q3：为什么 ApplicationContext 不支持并发 refresh()？答： refresh() 方法通过 synchronized (this.startupShutdownMonitor) 保证线程安全。容器状态通过 active 和 closed 标志管理，并发刷新会导致 BeanDefinition 状态不一致、重复注册处理器等严重问题。### Q4：Spring Boot 的启动流程和原生 Spring 有什么区别？答： Spring Boot 的 SpringApplication.run() 底层创建的是 AnnotationConfigServletWebServerApplicationContext，它的 onRefresh() 方法会创建内嵌的 Tomcat 等服务器。整个 refresh 流程与原生 Spring 一致，只是多了 Web 环境和自动配置的处理。---## 八、总结本文从容器继承体系出发，逐步深入到 refresh() 的 12 个步骤，重点解析了：1. DefaultListableBeanFactory 是唯一真正的 Bean 存储工厂 ------ApplicationContext 只是一个功能更丰富的壳。2. BeanDefinition 是一切的基础 ------所有注解的解析最终都归结为 BeanDefinition 的注册。3. ConfigurationClassPostProcessor 是注解驱动的核心引擎 ------它在第 5 步完成所有扫描和解析工作。4. 两大扩展点的本质区别 ------BeanFactoryPostProcessor 修改"图纸"，BeanPostProcessor 修改"成品"。理解了 IoC 容器初始化，你就掌握了 Spring 的"第一推动力"。后续系列文章将深入 AOP 代理创建、循环依赖解决、事务管理等核心机制。---> 后端技术源码解读系列预告： > - 第二篇：Spring AOP 代理创建全链路源码解析> - 第三篇：Spring 循环依赖三级缓存机制彻底搞懂> - 第四篇：Spring 事务管理 TransactionManager 源码揭秘如果本文对你有帮助，请点赞收藏关注，下篇更精彩。