启动流程 - 墨码山河

摘要：本文学习了Spring容器的启动流程。

环境

Windows 10 企业版 LTSC 21H2
Java 1.8
Tomcat 8.5.50
Maven 3.6.3
Spring 5.2.25.RELEASE

1 基本流程

Spring容器的启动流程是围绕AnnotationConfigApplicationContext展开的，它是一个专门用于注解配置的应用程序上下文。

核心流程：

1 创建容器，初始化基本对象。
2 注册配置类。
3 启动容器刷新流程。
3.1 获取对象工厂，进行基础配置。
3.2 执行对象工厂后置处理器。
3.3 实例化对象。
3.3.1 获取对象名称列表。
3.3.2 遍历对象名称列表，根据对象名称判断是否工厂对象：
- 如果不是工厂对象，使用对象名称获取对象。
- 如果是工厂对象，使用工厂前缀获取对象，判断对象是否工厂类型：
  - 如果是工厂类型，使用对象名称获取对象。
  - 如果不是工厂类型，不作处理。
3.3.2.1 获取缓存对象，入参允许提前引用。
3.3.2.1.1 从一级缓存获取成熟对象：
- 如果成熟对象存在，返回对象。
- 如果成熟对象不存在，并且对象正在创建，继续获取缓存对象。
3.3.2.1.2 从二级缓存获取早期对象：
- 如果早期对象存在，返回对象。
- 如果早期对象不存在，并且入参允许提前引用，继续获取缓存对象。
3.3.2.1.3 对一级缓存加锁，保证并发安全。
3.3.2.1.4 再次从一级缓存和二级缓存获取对象：
- 如果对象存在，返回对象。
- 如果对象不存在，继续获取缓存对象。
3.3.2.1.5 从三级缓存获取代理工厂：
- 如果代理工厂不存在，返回空对象。
- 如果代理工厂存在，获取早期对象。
3.3.2.1.5.1 通过代理工厂获取早期对象，判断对象是否被代理：
- 如果没被代理，返回早期对象。
- 如果被代理，返回包装为代理对象的早期对象。
3.3.2.1.5.2 将早期对象放到二级缓存。
3.3.2.1.5.3 从三级缓存移除代理工厂。
3.3.2.2 判断缓存对象是否存在：
- 如果缓存对象存在，转换缓存对象，返回对象。
- 如果缓存对象不存在，继续创建对象。
3.3.2.3 根据对象名称检查是否正在创建原型对象：
- 如果正在创建原型对象，抛出循环依赖异常。
- 如果没有正在创建，或者不是原型对象，继续创建对象。
3.3.2.4 判断上级工厂是否存在，以及当前工厂是否包含对象定义：
- 如果上级工厂存在并且当前工厂不包含对象定义，使用上级工厂创建对象，返回对象。
- 如果上级工厂不存在，或者当前工厂包含对象定义，继续创建对象。
3.3.2.5 获取对象的显示依赖对象，遍历显示依赖对象，判断是否存在循环显示依赖：
- 如果存在循环显示依赖，抛出循环显示依赖异常。
- 如果不存在循环显示依赖，注册显示依赖关系，创建显示依赖对象，继续创建对象。
3.3.2.6 根据作用域使用不同策略创建对象：
- 如果是单例模式，获取单例对象，转换单例对象，返回对象。
- 如果是原型模式，创建原型对象，转换原型对象，返回对象。
- 如果是其他模式，通过作用域创建原型对象，转换原型对象，返回对象。
3.3.2.6.1 对一级缓存加锁，保证并发安全。
3.3.2.6.2 从一级缓存获取成熟对象：
- 如果成熟对象存在，返回对象。
- 如果成熟对象不存在，继续创建对象。
3.3.2.6.3 标记单例对象正在创建。
3.3.2.6.4 通过单例工厂创建单例对象。
3.3.2.6.4.1 判断对象后置处理器的执行结果：
- 如果对象存在，返回对象。
- 如果对象不存在，继续创建对象。
3.3.2.6.4.2 获取原始对象，完成原始对象的实例化。
3.3.2.6.4.3 判断是否需要提前释放对象，只有单例对象，并且允许循环依赖，并且对象正在创建，才允许提前释放对象：
- 如果不允许提前释放对象，继续创建对象。
- 如果允许提前释放对象，缓存代理工厂。
3.3.2.6.4.3.1 对一级缓存加锁，保证并发安全。
3.3.2.6.4.3.2 判断一级缓存是否存在成熟对象：
- 如果成熟对象存在，不作处理。
- 如果成熟对象不存在，缓存代理工厂。
3.3.2.6.4.3.2.1 将代理工厂放到三级缓存。
3.3.2.6.4.3.2.2 从二级缓存移除早期对象。
3.3.2.6.4.4 将暴露对象设置为原始对象。
3.3.2.6.4.5 填充属性值，成为早期对象：
- 如果没有引用对象的属性，不需要执行3.3.2.X创建属性对象。
- 如果有引用类型的属性，需要执行3.3.2.X创建属性对象。
3.3.2.6.4.6 初始化对象，成为成熟对象。
3.3.2.6.4.6.1 给对象注入容器相关信息。
3.3.2.6.4.6.2 执行对象后置处理器，在对象初始化之前执行。
3.3.2.6.4.6.3 执行对象初始化方法。
3.3.2.6.4.6.4 执行对象后置处理器，在对象初始化之后执行。
3.3.2.6.4.7 判断是否需要提前释放对象：
- 如果不允许提前释放对象，继续创建对象。
- 如果允许提前释放对象，需要执行3.3.2.1获取缓存对象，入参不允许提前引用。
3.3.2.6.4.8 判断缓存对象是否存在：
- 如果缓存对象不存在，继续创建对象。
- 如果缓存对象存在，判断初始化对象是否存在代理：
  - 如果不存在代理，暴露对象使用早期对象。
  - 如果存在代理，判断有无实际注入依赖的其他对象：
    - 如果有实际注入依赖的其他对象，抛出循环依赖异常。
    - 如果没有实际注入依赖的其他对象，暴露对象使用存在代理的初始化对象。
3.3.2.6.4.9 返回暴露对象。
3.3.2.6.5 标记新的单例对象。
3.3.2.6.6 标记单例对象完成创建。
3.3.2.6.7 判断是否新的单例对象：
- 如果不是新的单例对象，返回对象。
- 如果是新的单例对象，缓存单例对象。
3.3.2.6.7.1 对一级缓存加锁，保证并发安全。
3.3.2.6.7.2 将成熟对象放到一级缓存。
3.3.2.6.7.3 从二级缓存移除早期对象。
3.3.2.6.7.4 从三级缓存移除代理工厂。
3.3.2.6.8 返回单例对象。

2 源码分析

2.1 容器实例化

从创建AnnotationConfigApplicationContext对象开始：

java

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    // 初始化基本对象
    this();
    // 注册配置类
    register(componentClasses);
    // 启动容器刷新流程
    refresh();
}

调用AnnotationConfigApplicationContext的this()方法，初始化基本对象：

java

public AnnotationConfigApplicationContext() {
    // 创建注解对象定义读取器，用于处理配置类
    this.reader = new AnnotatedBeanDefinitionReader(this);
    // 创建类路径对象定义扫描器，用于处理对象类
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

2.2 注册配置类

调用AnnotationConfigApplicationContext的register()方法，注册配置类：

java

public void register(Class<?>... componentClasses) {
    // 通过读取器注册配置类
    this.reader.register(componentClasses);
}

调用AnnotatedBeanDefinitionReader的register()方法，注册配置类：

java

public void register(Class<?>... componentClasses) {
    // 遍历类名列表
    for (Class<?> componentClass : componentClasses) {
        // 解析注解元数据，生成对象名称，完善注解属性配置，将对象定义注册到容器
        registerBean(componentClass);
    }
}

2.3 刷新容器

2.3.1 启动流程

调用AbstractApplicationContext的refresh()方法，启动容器刷新流程，这是整个容器启动的核心：

java

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 准备刷新上下文，初始化自定义属性
        prepareRefresh();
        // 获取对象工厂
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // 配置对象工厂
        prepareBeanFactory(beanFactory);
        try {
            // 执行对象工厂后置处理器，修改对象定义
            invokeBeanFactoryPostProcessors(beanFactory);
            // 注册对象后置处理器
            registerBeanPostProcessors(beanFactory);
            // 注册监听器
            registerListeners();
            // 实例化对象
            finishBeanFactoryInitialization(beanFactory);
            // 发布容器刷新完成事件
            finishRefresh();
        } catch (BeansException ex) {
            // 销毁已创建的对象
            destroyBeans();
            // 重置标志
            cancelRefresh(ex);
            // 抛出异常
            throw ex;
        } finally {
            // 重置缓存
            resetCommonCaches();
        }
    }
}

2.3.2 处理对象工厂

2.3.2.1 获取对象工厂

调用AbstractApplicationContext的obtainFreshBeanFactory()方法，获取对象工厂：

java

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 刷新对象工厂
    refreshBeanFactory();
    // 获取对象工厂，这里获取的是DefaultListableBeanFactory对象工厂
    return getBeanFactory();
}

2.3.2.2 配置对象工厂

调用AbstractApplicationContext的prepareBeanFactory()方法，配置对象工厂：

java

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置表达式解析器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 设置属性编辑器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    // 添加核心后置处理器
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 忽略依赖接口的自动注入，由专用后置处理器处理
    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.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    // 添加监听后置处理器，将内部对象作为应用监听器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
}

2.3.3 后置处理器

2.3.3.1 执行对象工厂后置处理器

调用AbstractApplicationContext的invokeBeanFactoryPostProcessors()方法，执行对象工厂后置处理器：

java

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 执行对象工厂后置处理器，修改对象定义
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}

2.3.3.2 注册对象后置处理器

调用AbstractApplicationContext的registerBeanPostProcessors()方法，注册对象后置处理器：

java

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 注册对象后置处理器
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

2.3.4 注册监听器

调用AbstractApplicationContext的registerListeners()方法，注册监听器：

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);
    }
}

2.3.5 实例化对象

调用AbstractApplicationContext的finishBeanFactoryInitialization()方法，实例化对象：

java

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 缓存对象定义，禁止修改对象定义
    beanFactory.freezeConfiguration();
    // 预创建对象
    beanFactory.preInstantiateSingletons();
}

调用DefaultListableBeanFactory的preInstantiateSingletons()方法，预创建对象：

java

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()) {
            // 根据对象名称判断是否工厂对象
            if (isFactoryBean(beanName)) {
                // 如果是工厂对象，使用工厂前缀获取对象
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                // 判断工厂对象是否工厂类型
                if (bean instanceof FactoryBean) {
                    // 如果是工厂类型，使用对象名称获取对象
                    getBean(beanName);
                }
            } else {
                // 如果不是工厂对象，使用对象名称获取对象
                getBean(beanName);
            }
        }
    }
}

调用AbstractBeanFactory的getBean()方法，获取对象：

java

public Object getBean(String name) throws BeansException {
    // 获取对象
    return doGetBean(name, null, null, false);
}

调用AbstractBeanFactory的doGetBean()方法，获取对象：

java

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    // 解析对象名称，去除工厂前缀
    String beanName = transformedBeanName(name);
    Object bean;
    // 获取缓存对象
    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)) {
            // 使用上级工厂创建对象
            return parentBeanFactory.getBean( ... );
        }
        try {
            // 获取对象定义
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 检查对象定义
            checkMergedBeanDefinition(mbd, beanName, args);
            // 获取对象的显示依赖对象
            String[] dependsOn = mbd.getDependsOn();
            // 判断是否存在显示依赖对象
            if (dependsOn != null) {
                // 遍历显示依赖对象
                for (String dep : dependsOn) {
                    // 判断是否存在循环显示依赖
                    if (isDependent(beanName, dep)) {
                      // 抛出循环显示依赖异常
                      throw new BeanCreationException( ... );
                    }
                    // 注册显示依赖关系
                    registerDependentBean(dep, beanName);
                    // 创建显示依赖对象
                    getBean(dep);
                }
            }
            // 根据作用域使用不同策略创建对象
            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 {
                // 如果是其他模式，通过作用域创建原型对象
                Object scopedInstance = scope.get(beanName, () -> {
                    // 标记原型对象正在创建
                    beforePrototypeCreation(beanName);
                    try {
                        // 创建原型对象
                        return createBean(beanName, mbd, args);
                    } finally {
                        // 标记原型对象创建完成
                        afterPrototypeCreation(beanName);
                    }
                });
                // 转换原型对象，返回工厂对象或者实际对象
                bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
            }
        } catch (BeansException ex) {
            // 清理创建失败的对象
            cleanupAfterBeanCreationFailure(beanName);
            // 抛出异常
            throw ex;
        }
    }
    // 返回对象
    return (T) bean;
}

2.3.5.1 获取缓存对象

调用DefaultSingletonBeanRegistry的getSingleton()方法，获取缓存对象：

java

public Object getSingleton(String beanName) {
    // 获取缓存对象
    return getSingleton(beanName, true);
}

调用DefaultSingletonBeanRegistry的getSingleton()方法，获取缓存对象：

java

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;
}

2.3.5.2 获取单例对象

调用DefaultSingletonBeanRegistry的getSingleton()方法，获取单例对象：

java

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    // 保证单例缓存的线程安全，避免并发环境下缓存数据不一致
    synchronized (this.singletonObjects) {
        // 从一级缓存获取成熟对象
        Object singletonObject = this.singletonObjects.get(beanName);
        // 判断成熟对象是否存在
        if (singletonObject == null) {
            // 标记单例对象正在创建
            beforeSingletonCreation(beanName);
            // 标记是否新的单例对象
            boolean newSingleton = false;
            try {
                // 通过单例工厂创建单例对象
                singletonObject = singletonFactory.getObject();
                // 标记新的单例对象
                newSingleton = true;
            } catch (IllegalStateException ex) {
                // 从一级缓存获取成熟对象
                singletonObject = this.singletonObjects.get(beanName);
                // 如果没有成熟对象，抛出异常
                if (singletonObject == null) {
                    throw ex;
                }
            } finally {
                // 标记单例对象完成创建
                afterSingletonCreation(beanName);
            }
            // 如果新的单例对象，缓存单例对象
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        // 返回单例对象
        return singletonObject;
    }
}

2.3.5.3 缓存单例对象

调用DefaultSingletonBeanRegistry的addSingleton()方法，缓存单例对象：

java

protected void addSingleton(String beanName, Object singletonObject) {
    // 保证单例缓存的线程安全，避免并发环境下缓存数据不一致
    synchronized (this.singletonObjects) {
        // 将成熟对象放到一级缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 从二级缓存移除早期对象
        this.singletonFactories.remove(beanName);
        // 从三级缓存移除代理工厂
        this.earlySingletonObjects.remove(beanName);
        // 注册对象名称，添加到已注册列表
        this.registeredSingletons.add(beanName);
    }
}

2.3.6 创建对象

调用AbstractAutowireCapableBeanFactory的createBean()方法，创建对象：

java

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    // 获取对象定义
    RootBeanDefinition mbdToUse = new RootBeanDefinition(mbd);
    // 支持对象后置处理器返回
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    // 如果对象存在，返回对象
    if (bean != null) {
        return bean;
    }
    // 创建对象
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    // 返回对象
    return beanInstance;
}

调用AbstractAutowireCapableBeanFactory的doCreateBean()方法，创建对象：

java

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    // 实例化包装对象，可以更方便的处理属性的类型转换和嵌套访问
    BeanWrapper instanceWrapper = null;
    // 如果是单例对象，获取包装对象
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // 如果包装对象不存在，或者不是单例对象，实例化包装对象
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 获取原始对象，完成原始对象的实例化
    Object bean = instanceWrapper.getWrappedInstance();
    // 允许对象后置处理器修改注解元数据
    synchronized (mbd.postProcessingLock) {
        // 保证对象后置处理器只执行一次
        if (!mbd.postProcessed) {
            // 将注解元数据缓存到对象定义中
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            // 标记对象后置处理器已经执行
            mbd.postProcessed = true;
        }
    }
    // 只有单例对象，并且允许循环依赖，并且对象正在创建，才允许提前释放对象
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
    // 判断是否允许提前释放对象
    if (earlySingletonExposure) {
        // 如果允许提前释放对象，缓存代理工厂，支持代理
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // 将暴露对象设置为原始对象
    Object exposedObject = bean;
    // 填充属性值，成为早期对象
    populateBean(beanName, mbd, instanceWrapper);
    // 初始化对象，成为成熟对象，支持代理
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    // 判断是否允许提前释放对象
    if (earlySingletonExposure) {
        // 获取缓存对象，获取早期对象
        Object earlySingletonReference = getSingleton(beanName, false);
        // 判断早期对象是否存在
        if (earlySingletonReference != null) {
            // 如果早期对象存在，说明其他对象依赖早期对象，判断初始化对象是否存在代理
            if (exposedObject == bean) {
                // 初始化对象不存在代理，需要返回早期对象，保证使用相同早期对象
                exposedObject = earlySingletonReference;
            } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                // 初始化对象存在代理，获取依赖早期对象的其他对象列表，包括实际注入依赖和类型检查依赖
                String[] dependentBeans = getDependentBeans(beanName);
                // 记录实际注入依赖的其他对象列表
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                // 遍历其他对象列表，过滤类型检查依赖，保留实际注入依赖
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // 初始化对象存在代理，并且存在实际注入依赖的其他对象，说明早期对象已被使用，抛出异常
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException( ... );
                }
            }
        }
    }
    // 注册单例对象的销毁方法
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
    // 返回暴露对象
    return exposedObject;
}

调用DefaultSingletonBeanRegistry的addSingletonFactory()方法，缓存代理工厂：

java

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);
        }
    }
}

2.3.7 填充属性值

调用AbstractAutowireCapableBeanFactory的populateBean()方法，填充属性值：

java

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // 获取装配类型
    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    // 处理自动装配
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        // 包装原有属性值
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // 按名称自动装配
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // 按类型自动装配
        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        // 更新属性值
        pvs = newPvs;
    }
}

2.3.7.1 按名称自动装配

调用AbstractAutowireCapableBeanFactory的autowireByName()方法，按名称自动装配：

java

protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    // 获取非简单属性名称列表
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    // 遍历属性名称列表
    for (String propertyName : propertyNames) {
        // 判断是否存在名称相同的对象
        if (containsBean(propertyName)) {
            // 创建对象
            Object bean = getBean(propertyName);
            // 将引用对象添加到属性值
            pvs.add(propertyName, bean);
            // 注册显示依赖关系
            registerDependentBean(propertyName, beanName);
        }
    }
}

2.3.7.2 按类型自动装配

调用AbstractAutowireCapableBeanFactory的autowireByType()方法，按类型自动装配：

java

protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    // 获取类型转换器
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }
    // 存储自动装配的属性名称
    Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
    // 获取非简单属性名称列表
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    // 遍历属性名称列表
    for (String propertyName : propertyNames) {
        // 获取当前属性的描述符
        PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
        // 过滤Object类型的属性
        if (Object.class != pd.getPropertyType()) {
            // 获取属性写方法
            MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
            // 确定是否允许提前初始化
            boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
            // 构建按类型自动装配的依赖描述符
            DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
            // 解析依赖，按类型匹配并获取对象
            Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
            // 如果存在匹配的对象，将对象添加到属性值
            if (autowiredArgument != null) {
                pvs.add(propertyName, autowiredArgument);
            }
            // 遍历匹配的对象列表
            for (String autowiredBeanName : autowiredBeanNames) {
                // 注册显示依赖关系
                registerDependentBean(autowiredBeanName, beanName);
            }
            // 清空自动装配的对象列表
            autowiredBeanNames.clear();
        }
    }
}

2.3.8 初始化对象

调用AbstractAutowireCapableBeanFactory的initializeBean()方法，初始化对象：

java

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // 给对象注入容器相关信息
    invokeAwareMethods(beanName, bean);
    // 定义包装对象
    Object wrappedBean = bean;
    // 执行对象后置处理器，在对象初始化之前执行
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    // 执行对象初始化方法
    invokeInitMethods(beanName, wrappedBean, mbd);
    // 执行对象后置处理器，在对象初始化之后执行
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    // 返回包装对象
    return wrappedBean;
}

3 流程归纳

3.1 普通情况

普通情况部分执行流程：

获取对象A。
获取缓存对象A，缓存不存在。
获取单例对象A。
通过单例工厂创建单例对象A。
允许提前释放对象A，将代理工厂放到三级缓存。
填充属性值，成为早期对象。
- 获取对象B。
- 获取缓存对象B，缓存不存在。
- 获取单例对象B。
- 通过单例工厂创建单例对象B。
- 允许提前释放对象B，将代理工厂放到三级缓存。
- 填充属性值，成为早期对象。
- 初始化对象，成为成熟对象。
- 允许提前释放对象B，从二级缓存获取早期对象。
- 将成熟对象放到一级缓存。
- 返回对象B。
初始化对象，成为成熟对象。
允许提前释放对象A，从二级缓存获取早期对象。
将成熟对象放到一级缓存。
返回对象A。

3.2 循环依赖

循环依赖部分执行流程：

获取对象A。
获取缓存对象A，缓存不存在。
获取单例对象A。
通过单例工厂创建单例对象A。
允许提前释放对象A，将代理工厂放到三级缓存。
填充属性值，成为早期对象。
- 获取对象B。
- 获取缓存对象B，缓存不存在。
- 获取单例对象B。
- 通过单例工厂创建单例对象B。
- 允许提前释放对象B，将代理工厂放到三级缓存。
- 填充属性值，成为早期对象。
  - 获取对象A。
  - 获取缓存对象A，从三级缓存获取代理工厂，将早期对象放到二级缓存。
  - 返回对象A。
- 初始化对象，成为成熟对象。
- 允许提前释放对象B，从二级缓存获取早期对象。
- 将成熟对象放到一级缓存。
- 返回对象B。
初始化对象，成为成熟对象。
允许提前释放对象A，从二级缓存获取早期对象。
将成熟对象放到一级缓存。
返回对象A。

4 三级缓存

通过三级缓存解决循环依赖问题：

singletonObjects：一级缓存，存放完成初始化的成熟对象。
earlySingletonObjects：二级缓存，存放尚未完成填充属性值和初始化的早期对象。
singletonFactories：三级缓存，存放完成实例化的代理工厂。