Spring干货---IOC

原创已于 2026-08-17 22:59:44 修改 · 326 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

spring

于 2026-08-12 00:22:36 首次发布

话说天下大事，合久必分，分久必合……废话少说，直接上干货
基于Spring Framework 6.x

深入分析 Spring IoC 容器从 AbstractApplicationContext.refresh() 到容器完全就绪的完整源码链路，覆盖 Bean 从定义到实例化的全生命周期。

IoC 理论基础
- 1.1 IoC 设计思想
- 1.2 依赖注入方式
- 1.3 IoC 容器的两种形态
- 1.4 容器继承层次
Bean 核心知识
- 2.1 BeanDefinition — Bean 的元数据
- 2.2 Bean 的作用域 (Scope)
- 2.3 依赖注入详解
- 2.4 Bean 的命名与别名
- 2.5 FactoryBean vs BeanFactory
- 2.6 循环依赖问题

第二部分：源码分析

Spring IoC 容器概述
容器启动总览：refresh() 方法
步骤 1：prepareRefresh() — 准备刷新
步骤 2：obtainFreshBeanFactory() — 获取 BeanFactory
步骤 3：prepareBeanFactory() — 准备 BeanFactory
步骤 4：postProcessBeanFactory() — BeanFactory 后置处理
步骤 5：invokeBeanFactoryPostProcessors() — 调用 BeanFactory 后置处理器 ★★★
步骤 6：registerBeanPostProcessors() — 注册 Bean 后置处理器
步骤 7：initMessageSource() — 初始化消息源
步骤 8：initApplicationEventMulticaster() — 初始化事件多播器
步骤 9：onRefresh() — 刷新子容器
步骤 10：registerListeners() — 注册监听器
步骤 11：finishBeanFactoryInitialization() — 完成 BeanFactory 初始化 ★★★
步骤 12：finishRefresh() — 完成刷新
Bean 的完整生命周期
核心类继承关系
关键扩展点总结

第一部分：理论基础

1. IoC 理论基础

1.1 什么是 IoC（控制反转）

1.1.1 传统编程方式的问题

在传统的编程方式中，对象自己负责获取它所依赖的对象：

// ❌ 传统方式：对象控制自己的依赖
public class UserService {
    private UserRepository userRepository;

    public UserService() {
        // 对象自己创建依赖 —— 强耦合
        this.userRepository = new JdbcUserRepository();
    }
}

问题：

对象与具体实现类强耦合
难以替换依赖实现（如切换到 MyBatis 或 JPA）
难以进行单元测试（无法 Mock 依赖）
依赖的生命周期管理混乱

1.1.2 IoC 的思想

// ✅ IoC 方式：依赖由外部注入
public class UserService {
    private UserRepository userRepository;

    // 依赖由外部传入 —— 控制反转
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

IoC 的核心思想：

维度	传统方式	IoC 方式
谁创建依赖？	对象自己	IoC 容器
谁管理生命周期？	对象自己	IoC 容器
控制权在哪？	对象手中	容器手中（反转）
耦合程度	强耦合	松耦合
可测试性	差	好（可注入 Mock）

1.2 依赖注入（DI）—— IoC 的实现方式

依赖注入（Dependency Injection, DI）是 IoC 最主流的实现方式。Spring 支持三种注入方式：

// ① 构造器注入 — 推荐
@Service
public class UserService {
    private final UserRepository userRepository;

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

// ② Setter 注入 — 可选依赖
@Service
public class UserService {
    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

// ③ 字段注入 — 最简单但不推荐（但是工作过程中这种用法最多，至少我身边的人是这样的）
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
}

1.3 IoC 容器的两种形态

1.3.1 BeanFactory — 基础容器

1.3.2 ApplicationContext — 高级容器

1.3.3 对比总结

对比维度	BeanFactory	ApplicationContext
定位	底层 IoC 容器接口	高级容器接口，继承 BeanFactory
Bean 实例化	延迟加载（首次 getBean 时才实例化）	预加载（启动时实例化所有单例 Bean）
国际化	不支持	支持 MessageSource
事件机制	不支持	支持 ApplicationEvent 发布/监听
资源加载	不支持	支持 ResourceLoader
使用场景	资源受限环境（如 Applet）	企业级应用（绝大多数场景）

1.4 容器继承层次体系

Spring 容器支持父子容器的层次结构：

典型场景：Spring MVC 中，DispatcherServlet 创建自己的子容器（WebApplicationContext），父容器是 ContextLoaderListener 创建的 Root ApplicationContext。Controller 在子容器中，Service/Repository 在父容器中。

2. Bean 核心知识

2.1 BeanDefinition — Bean 的元数据

2.1.1 什么是 BeanDefinition

BeanDefinition 是 Spring 中描述 Bean 的核心数据结构，它包含了创建 Bean 所需的全部元信息：

2.1.2 BeanDefinition 的层次结构

2.1.3 BeanDefinition 的合并过程

为什么需要合并？ 通过父子 BeanDefinition，可以实现配置模板的复用 —— 父定义作为模板，多个子定义继承通用配置、覆盖特定配置。

2.2 Bean 的作用域 (Scope)

// 作用域配置方式
@Component
@Scope("singleton")           // 默认
public class SingletonBean {}

@Component
@Scope("prototype")           // 原型
public class PrototypeBean {}

@Component
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)  // 请求作用域
public class RequestBean {}

@Component
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)  // 会话作用域
public class SessionBean {}

Singleton 依赖 Prototype 的问题：如果 Singleton Bean 内部注入了 Prototype Bean，由于 Singleton 只创建一次，其内部的 Prototype Bean 也只会被注入一次。解决方案：使用 @Lookup 注解或 ObjectFactory 动态获取。

2.3 依赖注入详解

2.3.1 自动装配模式 (AutowireMode)

// AbstractBeanDefinition.java 中定义的常量
public static final int AUTOWIRE_NO       = 0;  // 默认 - 不自动装配
public static final int AUTOWIRE_BY_NAME  = 1;  // byName - 按名称自动装配
public static final int AUTOWIRE_BY_TYPE  = 2;  // byType - 按类型自动装配
public static final int AUTOWIRE_CONSTRUCTOR = 3;  // 构造器自动装配

2.3.2 @Autowired vs @Resource vs @Inject

// @Autowired 示例
@Service
public class UserService {

    // 按类型注入（如果只有一个匹配）
    @Autowired
    private UserRepository userRepository;

    // 按类型 + 按名称限定
    @Autowired
    @Qualifier("jdbcUserRepository")
    private UserRepository jdbcRepo;

    // 注入所有匹配类型的 Bean
    @Autowired
    private List<UserRepository> allRepos;

    // 可选依赖（不存在时不报错）
    @Autowired(required = false)
    private Logger logger;
}

2.3.3 注入方式的处理顺序

2.4 Bean 的命名与别名

场景	Bean 名称	示例
`@Component` (无参数)	类名首字母小写	`UserService` → `userService`
`@Component("myName")`	使用指定名称	`myName`
`@Service("userSvc")`	使用指定名称	`userSvc`
`@Bean` (无参数)	方法名	`userRepository`
`@Bean("myRepo")`	使用指定名称	`myRepo`
`@Bean(name = {"a", "b"})`	多个名称，第一个为主名	主名 `a`，别名 `b`
XML `<bean id="xxx">`	使用 id 属性值	`xxx`
BeanNameGenerator 自定义	自定义生成规则	任意

别名机制示例：

// 方式一: @Bean 声明多个名称
@Bean(name = {"dataSource", "primaryDataSource", "masterDataSource"})
public DataSource dataSource() { ... }

// 方式二: 编程式注册别名
@Component("userService")
public class UserService { }

@Configuration
public class AppConfig implements BeanFactoryAware {
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        ((BeanDefinitionRegistry) beanFactory)
            .registerAlias("userService", "uSvc");
    }
}

2.5 FactoryBean vs BeanFactory

这是一个经典面试题：

// FactoryBean 示例：创建复杂对象
@Component("myBatisSqlSessionFactory")
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory> {

    private DataSource dataSource;

    @Override
    public SqlSessionFactory getObject() throws Exception {
        // 复杂创建逻辑
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        return sessionFactoryBean.getObject();
    }

    @Override
    public Class<?> getObjectType() {
        return SqlSessionFactory.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

// 获取 FactoryBean 产生的对象 vs FactoryBean 自身
@Autowired
private SqlSessionFactory sqlSessionFactory;     // ← getObject() 的产物

@Autowired
@Qualifier("&myBatisSqlSessionFactory")
private SqlSessionFactoryBean factoryBean;       // ← FactoryBean 自身

2.6 循环依赖问题

2.6.1 什么是循环依赖

A 依赖 B → B 依赖 C → C 依赖 A

例如:
@Service
public class A { @Autowired private B b; }
@Service
public class B { @Autowired private C c; }
@Service
public class C { @Autowired private A a; }

2.6.2 循环依赖解决的前提条件

2.6.3 解决方案

方案	做法	推荐度
重新设计	消除循环依赖，引入第三个类	⭐⭐⭐⭐⭐ 最佳
@Lazy 注解	`@Autowired @Lazy private A a;` 使用代理延迟加载	⭐⭐⭐⭐
Setter/Field 注入	改为非构造器注入方式	⭐⭐⭐
ObjectFactory/ObjectProvider	`@Autowired private ObjectProvider<A> aProvider;` 延迟获取	⭐⭐⭐⭐
@PostConstruct + setter	构造器注入后，在 @PostConstruct 中手动设置另一个	⭐⭐
spring.main.allow-circular-references=true	回退到旧行为	⭐ 不推荐

第二部分：源码分析

3. Spring IoC 容器概述

3.1 什么是 IoC 容器

Spring IoC（Inversion of Control）容器是 Spring 框架的核心，负责：

Bean 定义加载：读取 XML、注解、Java Config 等配置，解析为 BeanDefinition
Bean 实例化：通过反射创建 Bean 实例
依赖注入：自动装配 Bean 之间的依赖关系
Bean 生命周期管理：从初始化到销毁的完整生命周期回调

3.2 容器启动的整体阶段

4. 容器启动总览：refresh() 方法

4.1 概览图

4.2 源码

// AbstractApplicationContext.java
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // ─── 步骤 1：准备刷新 ───
        prepareRefresh();

        // ─── 步骤 2：获取 BeanFactory ───
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // ─── 步骤 3：准备 BeanFactory ───
        prepareBeanFactory(beanFactory);

        try {
            // ─── 步骤 4：BeanFactory 后置处理（模板方法） ───
            postProcessBeanFactory(beanFactory);

            // ─── 步骤 5：调用 BeanFactoryPostProcessor ★核心★ ───
            invokeBeanFactoryPostProcessors(beanFactory);

            // ─── 步骤 6：注册 BeanPostProcessor ★核心★ ───
            registerBeanPostProcessors(beanFactory);

            // ─── 步骤 7：初始化消息源 ───
            initMessageSource();

            // ─── 步骤 8：初始化事件多播器 ───
            initApplicationEventMulticaster();

            // ─── 步骤 9：onRefresh（模板方法） ───
            onRefresh();

            // ─── 步骤 10：注册监听器 ───
            registerListeners();

            // ─── 步骤 11：完成 BeanFactory 初始化 ★核心★ ───
            finishBeanFactoryInitialization(beanFactory);

            // ─── 步骤 12：完成刷新 ───
            finishRefresh();
        }
        catch (BeansException ex) {
            // 清理
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
        finally {
            // 清除反射缓存等公共缓存
            resetCommonCaches();
        }
    }
}

5. 步骤 1：prepareRefresh() — 准备刷新

5.1 流程图

5.2 源码

// AbstractApplicationContext.java
protected void prepareRefresh() {
    // 1. 记录容器启动时间
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    if (logger.isDebugEnabled()) {
        logger.debug("Refreshing " + this);
    }

    // 2. 初始化属性源（模板方法，留给子类覆盖）
    initPropertySources();

    // 3. 校验必要属性
    getEnvironment().validateRequiredProperties();

    // 4. 创建早期事件集合（存储监听器注册前发布的事件）
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

initPropertySources() 扩展点：

// 例如：GenericWebApplicationContext 中的实现
@Override
protected void initPropertySources() {
    ConfigurableEnvironment env = getEnvironment();
    if (env instanceof ConfigurableWebEnvironment) {
        ((ConfigurableWebEnvironment) env).initPropertySources(
            getServletContext(), getServletConfig());
    }
}

6. 步骤 2：obtainFreshBeanFactory() — 获取 BeanFactory

6.1 流程图

6.2 源码

// AbstractApplicationContext.java
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    return getBeanFactory();
}

XML 模式实现 (AbstractRefreshableApplicationContext)：

@Override
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory);
        loadBeanDefinitions(beanFactory);  // ★ 加载 XML
        this.beanFactory = beanFactory;
    } catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing XML document", ex);
    }
}

注解模式实现 (GenericApplicationContext)：

@Override
protected final void refreshBeanFactory() throws IllegalStateException {
    if (!this.refreshed.compareAndSet(false, true)) {
        throw new IllegalStateException(
            "GenericApplicationContext does not support multiple refresh attempts");
    }
    this.beanFactory.setSerializationId(getId());
}

注解模式下，BeanFactory（DefaultListableBeanFactory）在 GenericApplicationContext 的构造函数中就已创建：

// GenericApplicationContext.java
public GenericApplicationContext() {
    this.beanFactory = new DefaultListableBeanFactory();
}

BeanDefinition 的注册在 AnnotationConfigApplicationContext 的构造函数中完成：

// AnnotationConfigApplicationContext.java
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    refresh();  // ← 随即调用 refresh()
}

7. 步骤 3：prepareBeanFactory() — 准备 BeanFactory

7.1 流程图

7.2 源码

// AbstractApplicationContext.java
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 1. 设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());

    // 2. 设置 SpEL 表达式解析器
    if (!NativeDetector.inNativeImage()) {
        beanFactory.setBeanExpressionResolver(
            new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    }

    // 3. 注册属性编辑器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 4. ★ 注册 ApplicationContextAwareProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

    // 5. ★ 忽略以下 Aware 接口的自动装配
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationStartup.class);

    // 6. 注册可解析依赖
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 7. ★ 注册 ApplicationListenerDetector
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 8. LoadTimeWeaver
    if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(
            new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 9. 注册环境相关单例 Bean
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,
            getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,
            getEnvironment().getSystemEnvironment());
    }
    if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
        beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME,
            getApplicationStartup());
    }
}

8. 步骤 4：postProcessBeanFactory() — BeanFactory 后置处理

8.1 说明

这是模板方法，AbstractApplicationContext 中为空实现，由子类覆盖。

// AbstractApplicationContext.java
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 空实现，留给子类扩展
}

8.2 Spring Boot Web 容器中的实现

// ServletWebServerApplicationContext.java (Spring Boot)
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    beanFactory.addBeanPostProcessor(
        new WebApplicationContextServletContextAwareProcessor(this));
    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    registerWebApplicationScopes();  // ★ 注册 request、session、application scope
}

9. 步骤 5：invokeBeanFactoryPostProcessors() — 调用 BeanFactory 后置处理器 ★★★

9.1 概述

这是 Spring 容器启动过程中最核心、最复杂的步骤。它负责：

执行所有 BeanFactoryPostProcessor（包括 BeanDefinitionRegistryPostProcessor）
ConfigurationClassPostProcessor 在此解析 @Configuration、@ComponentScan、@Import、@Bean 等
自动配置在此生效（Spring Boot 通过 AutoConfigurationImportSelector 导入配置类）
最终所有 BeanDefinition 注册完成

9.2 整体流程图

9.3 源码详解

// PostProcessorRegistrationDelegate.java
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory,
        List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    Set<String> processedBeans = new HashSet<>();

    if (beanFactory instanceof BeanDefinitionRegistry registry) {
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // 首先分离手动注册的处理器
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            } else {
                regularPostProcessors.add(postProcessor);
            }
        }

        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // ─── 阶段 1: 执行实现了 PriorityOrdered 的 ───
        // ★ ConfigurationClassPostProcessor 在此执行！
        String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(
                    beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry,
            beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        // ─── 阶段 2: 执行实现了 Ordered 的 ───
        postProcessorNames = beanFactory.getBeanNamesForType(
            BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(
                    beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry,
            beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        // ─── 阶段 3: 执行所有剩余的（while 循环直到没有新的） ───
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(
                BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(
                        beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(
                currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
        }

        // ─── 阶段 4: 执行所有 RegistryProcessor 上的 BFPP 回调 ───
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // ─── 阶段 5: 执行非 Registry 的 BeanFactoryPostProcessor ───
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();

    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(
                beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    List<BeanFactoryPostProcessor> orderedPostProcessors =
        new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        orderedPostProcessors.add(
            beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    List<BeanFactoryPostProcessor> nonOrderedPostProcessors =
        new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(
            beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}

9.4 ConfigurationClassPostProcessor — 注解配置解析核心

ConfigurationClassPostProcessor 核心源码：

// ConfigurationClassPostProcessor.java
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    processConfigBeanDefinitions(registry);
}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();
    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
            // 已处理过的
        } else if (ConfigurationClassUtils.checkConfigurationClassCandidate(
                beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    if (configCandidates.isEmpty()) return;

    configCandidates.sort((bd1, bd2) -> {
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });

    ConfigurationClassParser parser = new ConfigurationClassParser(
        this.metadataReaderFactory, this.problemReporter, this.environment,
        this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());

    do {
        parser.parse(candidates);
        parser.validate();

        Set<ConfigurationClass> configClasses =
            new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);

        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                registry, this.sourceExtractor, this.resourceLoader, this.environment,
                this.importBeanNameGenerator, parser.getImportRegistry());
        }
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            Set<String> alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            }
            for (String candidateName : newCandidateNames) {
                if (!oldCandidateNames.contains(candidateName)) {
                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(
                            bd, this.metadataReaderFactory) &&
                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
                    }
                }
            }
            candidateNames = newCandidateNames;
        }
    } while (!candidates.isEmpty());
}

10. 步骤 6：registerBeanPostProcessors() — 注册 Bean 后置处理器

10.1 流程图

关键细节：BeanPostProcessor 本身的实例化也在这一步完成（通过 beanFactory.getBean()），这意味着这些 Bean 会提前于普通 Bean 被实例化。

10.2 源码

// PostProcessorRegistrationDelegate.java
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory,
        AbstractApplicationContext applicationContext) {

    String[] postProcessorNames = beanFactory.getBeanNamesForType(
        BeanPostProcessor.class, true, false);

    int beanProcessorTargetCount =
        beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(
        new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();

    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    List<BeanPostProcessor> orderedPostProcessors =
        new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    List<BeanPostProcessor> nonOrderedPostProcessors =
        new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

10.3 常见的 BeanPostProcessor

处理器	作用
`AutowiredAnnotationBeanPostProcessor`	处理 `@Autowired`、`@Value`、`@Inject` 注入
`CommonAnnotationBeanPostProcessor`	处理 `@PostConstruct`、`@PreDestroy`、`@Resource`
`ConfigurationPropertiesBindingPostProcessor`	`@ConfigurationProperties` 属性绑定（Spring Boot）
`ApplicationContextAwareProcessor`	处理 Aware 接口回调（步骤 3 中注册）
`ApplicationListenerDetector`	检测 ApplicationListener Bean 并注册到多播器
`PersistenceExceptionTranslationPostProcessor`	JPA 异常翻译

11. 步骤 7：initMessageSource() — 初始化消息源

// AbstractApplicationContext.java
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(
            MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        if (this.parent != null &&
                this.messageSource instanceof HierarchicalMessageSource hms) {
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    } else {
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

12. 步骤 8：initApplicationEventMulticaster() — 初始化事件多播器

// AbstractApplicationContext.java
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster = beanFactory.getBean(
            APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    } else {
        this.applicationEventMulticaster =
            new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(
            APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
}

关键：默认的 SimpleApplicationEventMulticaster 用于同步广播事件。如需异步事件，可注册自定义的 applicationEventMulticaster Bean 并设置 TaskExecutor。

13. 步骤 9：onRefresh() — 刷新子容器

// AbstractApplicationContext.java
protected void onRefresh() throws BeansException {
    // 模板方法，留给子类覆盖
}

典型覆盖场景：

容器类型	`onRefresh()` 实现	说明
Spring Boot `ServletWebServerApplicationContext`	`createWebServer()`	创建并启动内嵌 Tomcat/Jetty
Spring Boot `ReactiveWebServerApplicationContext`	`createWebServer()`	创建并启动 Netty/Undertow
普通 `AbstractApplicationContext`	空实现	无特殊处理

14. 步骤 10：registerListeners() — 注册监听器

// AbstractApplicationContext.java
protected void registerListeners() {
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    String[] listenerBeanNames =
        getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

15. 步骤 11：finishBeanFactoryInitialization() — 完成 BeanFactory 初始化 ★★★

15.1 概述

这是另一个核心步骤，负责实例化所有非懒加载的单例 Bean。每个 Bean 在此经历完整的生命周期（实例化 → 属性填充 → 初始化 → 后置处理）。

15.2 流程图

15.3 Bean 创建的完整流程（doGetBean → createBean → doCreateBean）

15.4 源码关键片段

getBean 入口：

// AbstractBeanFactory.java
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType,
        @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {

    String beanName = transformedBeanName(name);

    // ★ 第一步：尝试从缓存中获取（三级缓存解决循环依赖）
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 委托父容器
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

        String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
            for (String dep : dependsOn) {
                registerDependentBean(dep, beanName);
                getBean(dep);  // 递归创建依赖的 Bean
            }
        }

        if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
                try {
                    return createBean(beanName, mbd, args);
                } catch (BeansException ex) {
                    destroySingleton(beanName);
                    throw ex;
                }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        } else if (mbd.isPrototype()) {
            Object prototypeInstance = null;
            try {
                beforePrototypeCreation(beanName);
                prototypeInstance = createBean(beanName, mbd, args);
            } finally {
                afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        } else {
            String scopeName = mbd.getScope();
            Scope scope = this.scopes.get(scopeName);
            Object scopedInstance = scope.get(beanName, () -> {
                beforePrototypeCreation(beanName);
                try {
                    return createBean(beanName, mbd, args);
                } finally {
                    afterPrototypeCreation(beanName);
                }
            });
            bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
        }
    }

    if (requiredType != null && !requiredType.isInstance(bean)) {
        // 类型转换
    }
    return (T) bean;
}

15.5 三级缓存解决循环依赖

// DefaultSingletonBeanRegistry.java

/** 一级缓存：完全初始化完成的 Bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** 二级缓存：早期暴露的 Bean（未完成属性填充和初始化） */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

/** 三级缓存：Bean 工厂（用于生成早期 Bean 引用，支持 AOP 代理） */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** 正在创建中的 Bean 集合（用于循环依赖检测） */
private final Set<String> singletonsCurrentlyInCreation =
    Collections.newSetFromMap(new ConcurrentHashMap<>(16));

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory =
                            this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

循环依赖解决流程：

注意：Spring 只支持单例 Bean 的 Setter/Field 注入循环依赖。构造器注入的循环依赖无法解决。Spring Boot 3 默认禁用循环依赖（setAllowCircularReferences(false)）。

16. 步骤 12：finishRefresh() — 完成刷新

16.1 源码

// AbstractApplicationContext.java
protected void finishRefresh() {
    // 1. 清除上下文级 Resource 缓存
    clearResourceCaches();

    // 2. 初始化生命周期处理器
    initLifecycleProcessor();

    // 3. ★ 启动所有实现了 Lifecycle 接口的 Bean
    getLifecycleProcessor().onRefresh();

    // 4. ★ 发布 ContextRefreshedEvent（标志着容器已完全就绪）
    publishEvent(new ContextRefreshedEvent(this));

    // 5. 向 LiveBeansView 注册（JMX 支持）
    if (!NativeDetector.inNativeImage()) {
        LiveBeansView.registerApplicationContext(this);
    }
}

16.2 LifecycleProcessor

// AbstractApplicationContext.java
protected void initLifecycleProcessor() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
        this.lifecycleProcessor =
            beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
    } else {
        DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
        defaultProcessor.setBeanFactory(beanFactory);
        this.lifecycleProcessor = defaultProcessor;
        beanFactory.registerSingleton(
            LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
    }
}

DefaultLifecycleProcessor.onRefresh() 会找到所有实现了 Lifecycle 接口的 Bean，按 phase 排序后调用 start() 方法。

17. Bean 的完整生命周期

17.1 生命周期全景图

17.2 生命周期中的关键接口

接口/注解	作用	阶段
`BeanNameAware`	感知自身 Bean 名称	初始化前
`BeanClassLoaderAware`	感知类加载器	初始化前
`BeanFactoryAware`	感知所属 BeanFactory	初始化前
`ApplicationContextAware`	感知所属 ApplicationContext	初始化前
`@PostConstruct`	初始化回调（JSR-250）	初始化
`InitializingBean.afterPropertiesSet()`	初始化回调（Spring 原生）	初始化
`init-method`	自定义初始化方法	初始化
`BeanPostProcessor`	所有 Bean 的前/后置处理	全局
`InstantiationAwareBeanPostProcessor`	实例化前后的处理	实例化+填充
`SmartInstantiationAwareBeanPostProcessor`	构造器推断、早期引用等	实例化
`SmartInitializingSingleton`	所有单例 Bean 就绪后的回调	就绪
`@PreDestroy`	销毁回调（JSR-250）	销毁
`DisposableBean.destroy()`	销毁回调（Spring 原生）	销毁
`destroy-method`	自定义销毁方法	销毁

18. 核心类继承关系

19. 关键扩展点总结

19.1 扩展点一览

19.2 容器级扩展点总结

步骤	扩展点	执行时机	用途
步骤 1	`initPropertySources()`	`prepareRefresh()` 中	初始化自定义属性源
步骤 4	`postProcessBeanFactory()`	BeanFactory 准备后	注册特殊 scope、BPP 等
步骤 5	`BeanFactoryPostProcessor`	所有 BeanDefinition 注册后	修改 BeanDefinition
步骤 5	`BeanDefinitionRegistryPostProcessor`	同上，但更早	注册额外的 BeanDefinition
步骤 6	`BeanPostProcessor`	Bean 实例化前后	拦截 Bean 创建过程
步骤 9	`onRefresh()`	`finishBeanFactoryInitialization` 之前	Spring Boot 在此启动 WebServer
步骤 11	`SmartInitializingSingleton`	所有单例 Bean 就绪后	容器完全就绪后的回调
步骤 12	`LifecycleProcessor`	`finishRefresh()` 中	启动/停止 Lifecycle Bean

总结

主题	核心要点
IoC 思想	控制反转——对象不再自己控制依赖，由容器统一管理
DI 实现	构造器注入（推荐）、Setter 注入、字段注入
Bean 元数据	`BeanDefinition` 是 Bean 的"配方"，包含创建所需的所有信息
Bean 作用域	singleton（默认）、prototype、request、session、application、websocket
循环依赖	Spring 通过三级缓存解决 Setter/Field 注入的循环依赖
FactoryBean	使用 `&beanName` 获取 FactoryBean 自身，`beanName` 获取产物

Spring IoC 容器的启动过程 = 12 步 refresh()：

步骤	方法	核心工作
步骤 5	`invokeBeanFactoryPostProcessors()`	`ConfigurationClassPostProcessor` 解析配置类，扫描组件，注册所有 `BeanDefinition`
步骤 6	`registerBeanPostProcessors()`	注册 `BeanPostProcessor`，这些拦截器将在每个 Bean 创建时被调用
步骤 11	`finishBeanFactoryInitialization()`	实例化所有单例 Bean：实例化 → 属性填充 → 初始化 → AOP 代理

一条完整的调用链：

getBean() → doGetBean() → getSingleton()（查缓存）
  → createBean() → doCreateBean()
    → createBeanInstance()（实例化）
    → populateBean()（注入）
    → initializeBean()（初始化 + AOP）
  → addSingleton()（放入缓存）

理解这些，就掌握了 Spring IoC 容器的核心精髓。

2026年8月12日，成都，各位看官老爷，欲知后事如何且听下回分解

标签

#spring #java #后端