史上最详细Spring IOC源码解析（Spring Framework 5.3.x）

一、IOC容器概述

Spring IOC容器的本质是一个管理POJO对象生命周期的工厂系统，其核心实现位于org.springframework.beans和org.springframework.context包。本节将深入分析BeanFactory和ApplicationContext两大核心接口的源码差异。

1.1 BeanFactory源码层级

public interface BeanFactory {
    // 核心方法定义（部分）
    Object getBean(String name) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    // 层级关系：通过HierarchicalBeanFactory实现父子容器
}

关键实现类DefaultListableBeanFactory的类继承关系：

BeanFactory ← ListableBeanFactory ← ConfigurableBeanFactory
           ← AutowireCapableBeanFactory ← AbstractBeanFactory
           ← DefaultListableBeanFactory

1.2 ApplicationContext的增强
ApplicationContext通过组合模式集成多个功能接口：

public interface ApplicationContext extends EnvironmentCapable, 
    ListableBeanFactory, HierarchicalBeanFactory,
    MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    // 扩展方法如getEnvironment(), publishEvent()等
}

典型实现类AnnotationConfigApplicationContext的类结构包含：

• GenericApplicationContext：基础容器

• AnnotationConfigRegistry：注解配置支持

• BeanDefinitionRegistry：Bean定义注册能力

---

二、容器启动全流程源码分析

以AnnotationConfigApplicationContext为例，分析容器初始化过程：

2.1 构造方法调用链

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    refresh(); // 核心方法！！！
}

// 分解refresh()方法（AbstractApplicationContext类）
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备阶段
        prepareRefresh();

        // 2. 获取BeanFactory（关键！）
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3. BeanFactory预处理
        prepareBeanFactory(beanFactory);

        try {
            // 4. 后置处理（空实现，留给子类扩展）
            postProcessBeanFactory(beanFactory);

            // 5. 执行BeanFactoryPostProcessor
            invokeBeanFactoryPostProcessors(beanFactory);

            // 6. 注册BeanPostProcessor
            registerBeanPostProcessors(beanFactory);

            // 7. 初始化消息源
            initMessageSource();

            // 8. 初始化事件广播器
            initApplicationEventMulticaster();

            // 9. 子类扩展（如Web应用的Context刷新）
            onRefresh();

            // 10. 注册监听器
            registerListeners();

            // 11. 完成Bean初始化（重点！）
            finishBeanFactoryInitialization(beanFactory);

            // 12. 完成刷新
            finishRefresh();
        }
        // ... 异常处理
    }
}

2.2 BeanDefinition加载过程
以ConfigurationClassPostProcessor为例解析@Configuration类：

// ConfigurationClassPostProcessor.processConfigBeanDefinitions()
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    // 1. 解析@Configuration类
    ConfigurationClassParser parser = new ConfigurationClassParser(...);
    parser.parse(candidates);

    // 2. 加载@Bean方法生成的BeanDefinition
    this.reader.loadBeanDefinitions(configClasses);
}

2.3 finishBeanFactoryInitialization详解

// DefaultListableBeanFactory.preInstantiateSingletons()
public void preInstantiateSingletons() throws BeansException {
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 触发Bean实例化
            getBean(beanName);
        }
    }
}

---

三、Bean生命周期源码深度剖析

跟踪getBean()方法的完整调用链：

3.1 实例化阶段

// AbstractAutowireCapableBeanFactory.createBean()
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 1. 解析Bean类
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

    // 2. 处理lookup-method和replace-method
    mbd.prepareMethodOverrides();

    // 3. 应用BeanPostProcessor（前置处理）
    Object bean = resolveBeforeInstantiation(beanName, mbd);
    if (bean != null) return bean;

    // 4. 真正创建Bean实例
    Object beanInstance = doCreateBean(beanName, mbd, args);
    return beanInstance;
}

3.2 属性注入（populateBean）

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // 1. 应用InstantiationAwareBeanPostProcessor
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                // 执行@Autowired等注解处理
            }
        }
    }

    // 2. 按类型自动装配
    if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
        autowireByType(beanName, mbd, bw, newPvs);
    }
}

3.3 初始化阶段

// AbstractAutowireCapableBeanFactory.initializeBean()
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // 1. 调用Aware接口
    invokeAwareMethods(beanName, bean);

    // 2. 应用BeanPostProcessor前置处理
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);

    // 3. 调用init方法
    invokeInitMethods(beanName, wrappedBean, mbd);

    // 4. 应用BeanPostProcessor后置处理（AOP代理在此发生！）
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

    return wrappedBean;
}

---

四、循环依赖解决机制

Spring通过三级缓存解决循环依赖问题，核心代码位于DefaultSingletonBeanRegistry：

4.1 三级缓存定义

// 一级缓存：完整Bean实例
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 二级缓存：早期暴露对象（未完成属性注入）
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

// 三级缓存：ObjectFactory（用于生成代理对象）
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

4.2 getBean()中的处理流程

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

4.3 addSingletonFactory()关键方法

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

---

五、设计模式在IOC中的运用

1. 工厂模式：BeanFactory作为顶层工厂接口

2. 模板方法：AbstractApplicationContext.refresh()

3. 观察者模式：ApplicationEvent事件机制

4. 装饰器模式：BeanWrapper对Bean的包装

5. 策略模式：InstantiationStrategy的不同实现

---

六、性能优化关键点

1. BeanDefinition的缓存机制

2. 类型转换的缓存（ResolvableType）

3. 反射元数据的缓存（CachedIntrospectionResults）

4. 合并BeanDefinition的优化（MergedBeanDefinition）

---

七、常见问题源码级解答

Q1：为什么构造器注入无法解决循环依赖？
源码证明：当检测到构造器循环依赖时，直接抛出BeanCurrentlyInCreationException

// DefaultSingletonBeanRegistry.beforeSingletonCreation()
protected void beforeSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) 
        && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

Q2：@Autowired和@Resource的区别实现
源码差异：

• AutowiredAnnotationBeanPostProcessor处理@Autowired

• CommonAnnotationBeanPostProcessor处理@Resource

---

八、总结

通过对Spring IOC容器源码的逐层剖析，我们可以清晰看到：

1. 容器初始化的12个标准步骤

2. Bean生命周期的27个扩展点

3. 循环依赖的三级缓存解决方案

4. 注解驱动的实现原理