解析 Spring 启动流程与 Bean 生命周期:结合源码介绍 IOC 容器启动

2024-07-27后端23 分钟255 次阅读
AI 摘要salmon-ai

本文详细解析了 Spring 启动流程与 Bean 生命周期,

前言

在 Spring 框架中,Bean 的生命周期是指从创建到销毁的整个过程。在这个过程中,Spring 提供了丰富的扩展点,允许开发者在不同阶段插入自定义逻辑。为了深入理解 Spring 的启动流程和 Bean 生命周期,本文将结合源码详细介绍 Spring IOC 容器的启动过程,并探讨 Bean 生命周期的各个阶段及其实现细节。

为了更好地学习源码,理解 Spring 的思想,可以看看一个开源项目:mini-spring。这是由字节跳动的一位大佬编写的开源项目,保留了 Spring 的核心代码,同时简化了一些不影响我们学习的核心逻辑。推荐用这套代码进行学习。

在本文中,我将通过 Spring 源码与 mini-spring 两个版本来介绍 Spring 的启动过程,以帮助大家更好地理解 Spring IOC 容器的加载与 Bean 的生命周期。

Spring 源码

为了清楚了解 Bean 的实例化是在哪发生的,以及前面做了哪些准备工作,先带大家了解下 Spring 的启动过程。Spring 容器启动流程主要包括两个过程:容器初始化和容器刷新。

常用的容器有如下两种:

  • 基于 XML 配置 Bean (ClassPathXmlApplicationContext)
  • 基于注解配置 Bean (AnnotationConfigApplicationContext)

1、加载配置文件

首先,Spring 会根据配置文件(如 XML、Java 配置类)或注解(如 @Component、@Bean)来读取 Bean 的定义信息。

我这里以 ClassPathXmlApplicationContext 为例:
image.png
会解析当前配置的路径:
image.png
完成后开始执行 refresh() 方法,即 IOC 容器启动过程。

2、加载 IOC 容器

首先,我先总体说下 refresh() 主要干了什么事:

  1. 记录下容器的启动时间、标记“已启动”状态
  2. 创建容器DefaultListableBeanFactory,并加载beanDefinitions
  3. 对容器进行配置,比如注册类加载器ClassLoader和post-processors
  4. 调用 BeanFactoryPostProcessor 的 postProcessBeanFactory ,可对beanDefinition进行修改
  5. 注册 BeanPostProcessor 的实现类,可用于拦截bean的创建过程
  6. 国际化,事件广播器
  7. 初始化所有的 singleton beans(重点重点)
  8. 最后,广播事件,ApplicationContext 初始化完成

下面是 Spring 源码部分,我加上了中文注释:

java 复制代码
@Override
public void refresh() throws BeansException, IllegalStateException {
    // 加锁,防止在refresh的时候出现启动或销毁容器的操作。
    synchronized (this.startupShutdownMonitor) {
        // 准备工作,记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
        prepareRefresh();

        // 初始化 BeanFactory,先创建DefaultListableBeanFactory 实例,然后将配置信息解析成 beanDefinition,并封装成 beanName -> beanDefinition 的 ConcurrentHashMap 放在 BeanFactory 中
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // BeanFactory 后置器处理
        prepareBeanFactory(beanFactory);

        try {
            // 加载、注册 Bean,添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
            postProcessBeanFactory(beanFactory);

            // 在bean实例化之前,执行 BeanFactoryPostProcessor
            // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法,可修改beanDefinition
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册 BeanPostProcessor 的实现类,注意看和 BeanFactoryPostProcessor 的区别
            // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
            // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意,到这里 Bean 还没初始化
            registerBeanPostProcessors(beanFactory);

            // 初始化当前 ApplicationContext 的 MessageSource,对不同语言的消息体进行国际化处理
            initMessageSource();

            // 初始化事件发布者
            initApplicationEventMulticaster();

            // 从方法名就可以知道,典型的模板方法(钩子方法),
            // 具体的子类可以在这里初始化一些特殊的 Bean(在初始化 singleton beans 之前)
            onRefresh();

            // 注册事件监听器,检查监听Bean并且将这些Bean向容器注册,监听器需要实现 ApplicationListener 接口。
            registerListeners();

            // 重点!!! 注册类型转换器和提前实例化单例bean(lazy-init 的除外)
            finishBeanFactoryInitialization(beanFactory);

            // 最后,发布事件,ApplicationContext 初始化完成
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("上下文初始化期间遇到异常 - 取消刷新尝试: " + ex);
            }

            // 销毁已经创建的 bean,避免有些 bean 会一直占用资源
            destroyBeans();

            // 重置“active”标志
            cancelRefresh(ex);

            // 将异常传播给调用者
            throw ex;
        }

        finally {
            // 重置 Spring 核心中的常用缓存,因为我们可能不再需要单例 Bean 的元数据了
            resetCommonCaches();
        }
    }
}

以上是 Spring IOC 容器启动流程的核心源码部分。下面我先简单结合源码介绍下 Bean 的生命周期。

3、Bean 的生命周期

在 Spring IOC 容器中,Bean 的生命周期大致如下:

  1. 实例化:当启动 Spring 应用时,IOC 容器会为在配置文件中声明的每个 <bean> 创建一个实例。
  2. 属性赋值:实例化后,Spring 会通过反射机制给 Bean 的属性赋值。
  3. 调用初始化方法:如果 Bean 配置了初始化方法,Spring 会调用它。初始化方法是在 Bean 创建并赋值之后调用,可以在这个方法里写一些业务处理代码或做一些初始化工作。
  4. Bean 运行期:此时,Bean 已经准备好被程序使用,它已经被初始化并赋值完成。
  5. 应用程序关闭:当关闭 IOC 容器时,Spring 会处理配置了销毁方法的 Bean。
  6. 调用销毁方法:如果 Bean 配置了销毁方法,Spring 会在所有 Bean 都已使用完毕且 IOC 容器关闭之前调用它。可以在销毁方法里做一些资源释放的工作,比如关闭连接、清理缓存等。

下图展示了 Spring Bean 的生命周期:

Spring Bean Lifecycle

3.1 finishBeanFactoryInitialization

java 复制代码
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 设置类型转换器
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // 如果没有注册值解析器,则注册一个默认的嵌入值解析器
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }

    // 提前初始化 LoadTimeWeaverAware beans
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // 停止使用临时类加载器进行类型匹配
    beanFactory.setTempClassLoader(null);

    // 冻结所有的 bean 定义,表示已注册的 bean 定义不会被修改或后置处理
    beanFactory.freezeConfiguration();

    // 实例化所有剩余的(非延迟初始化)单例 bean
    beanFactory.preInstantiateSingletons();
}

在这个方法中,Spring 完成了以下几项工作:

  1. 设置类型转换器
  2. 注册一个默认的嵌入值解析器,用于解析注解中的属性值
  3. 提前初始化 LoadTimeWeaverAware beans
  4. 停止使用临时类加载器进行类型匹配
  5. 冻结所有的 bean 定义,以防止后续修改
  6. 实例化所有非延迟初始化的单例 bean(重点!)。

通过这些步骤,Spring IOC 容器完成了对 Bean 的初始化工作,并准备好 Bean 供应用程序使用。

3.2 preInstantiateSingletons

该方法准备实例化并初始化所有非延迟加载的 Bean 的源码部分:

java 复制代码
public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }

    // 获取当前 BeanFactory 中所有的 Bean 定义名称
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    Iterator<String> iterator = beanNames.iterator();

    // 遍历所有 Bean 定义
    while (iterator.hasNext()) {
        String beanName = iterator.next();
        RootBeanDefinition bd = this.getMergedLocalBeanDefinition(beanName);

        // 忽略抽象 Bean 定义
        if (bd.isAbstract()) {
            continue;
        }

        // 忽略非单例和懒加载的 Bean
        if (!bd.isSingleton() || bd.isLazyInit()) {
            continue;
        }

        // 如果是 FactoryBean,需要特别处理
        if (this.isFactoryBean(beanName)) {
            final FactoryBean<?> factory = (FactoryBean<?>) this.getBean("&" + beanName);
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () -> ((SmartFactoryBean<?>) factory).isEagerInit(), this.getAccessControlContext());
            } else {
                isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit();
            }

            // 如果 FactoryBean 需要急切初始化
            if (isEagerInit) {
                this.getBean(beanName);
            }
        } else {
            // 非 FactoryBean,直接实例化
            this.getBean(beanName);
        }
    }

    // 再次遍历所有 Bean,检查是否实现了 SmartInitializingSingleton 接口
    iterator = beanNames.iterator();
    while (iterator.hasNext()) {
        String beanName = iterator.next();
        Object singletonInstance = this.getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, this.getAccessControlContext());
            } else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

3.3 doGetBean

该方法负责获取 Bean 实例,这个过程可能会从单例缓存中获取实例或者创建新的实例。

java 复制代码
/**
 * 返回指定 bean 的实例,该实例可以是共享的也可以是独立的。
 * @param name 要检索的 bean 的名称
 * @param requiredType 要检索的 bean 的所需类型
 * @param args 使用显式参数创建 bean 实例时使用的参数(仅在创建新实例时适用,而不是检索现有实例时)
 * @param typeCheckOnly 是否仅为类型检查获取实例,而不是实际使用
 * @return bean 的实例
 * @throws BeansException 如果无法创建 bean
 */
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // 调用getSingleton判断容器中有没有实例或者该bean有没有再创建的过程中
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            } else {
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        // 如果当前正在创建这个原型 bean 实例,则失败:
        // 我们可能在一个循环引用中。
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 检查这个工厂中是否存在 bean 定义。
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 未找到 -> 检查父工厂。
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                // 使用显式参数委托给父工厂。
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } else {
                // 没有参数 -> 委托给标准 getBean 方法。
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

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

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 确保当前 bean 依赖的 bean 已初始化。
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn) {
                    if (isDependent(beanName, dependsOnBean)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                    }
                    registerDependentBean(dependsOnBean, beanName);
                    getBean(dependsOnBean);
                }
            }

            // 创建 bean 实例。
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    @Override
                    public Object getObject() throws BeansException {
                        try {
                            return createBean(beanName, mbd, args);
                        } catch (BeansException ex) {
                            // 明确地从单例缓存中移除实例:它可能已被创建过程急切地放入,以允许解决循环引用。
                            // 同时移除任何已接收该 bean 临时引用的 bean。
                            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();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            } finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; consider " +
                            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        } catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // 检查所需类型是否与实际 bean 实例的类型匹配。
    if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
        try {
            return getTypeConverter().convertIfNecessary(bean, requiredType);
        } catch (TypeMismatchException ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to convert bean '" + name + "' to required type [" +
                        ClassUtils.getQualifiedName(requiredType) + "]", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

3.4 getSingleton

获取缓存中的 Bean 实例

该方法尝试从单例缓存中获取 Bean 实例的源码,这里面有三级缓存,这里先简单过一下。

java 复制代码
// 一级缓存,存放完全实例化的 Bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 三级缓存,存放提前暴露的 bean 工厂,用于解决循环依赖
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 二级缓存,用于存放早期暴露的不完全实例化的 Bean
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 缓存正在创建的单例 Bean 的名称
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从一级缓存中获取完全实例化的 Bean
    Object singletonObject = this.singletonObjects.get(beanName);

    // 如果一级缓存中没有找到,并且该 Bean 被标记正在创建中
    if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
        synchronized(this.singletonObjects) {
            // 尝试从二级缓存中获取早期暴露的不完全实例化的 Bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果二级缓存中没有找到,并且允许早期引用
            if (singletonObject == null && allowEarlyReference) {
                // 从三级缓存中获取对应的 ObjectFactory
                ObjectFactory<?> singletonFactory = (ObjectFactory<?>) this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 通过 ObjectFactory 创建 Bean 实例
                    singletonObject = singletonFactory.getObject();
                    // 将创建的实例放入二级缓存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从三级缓存中移除已创建的 Bean 工厂
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }

    // 返回创建的 Bean 实例,如果为空对象则返回 null
    return singletonObject != NULL_OBJECT ? singletonObject : null;
}
创建 bean 实例

如果缓冲中获取不到A,也不在创建过程中,则调用该方法创建并获取 bean

java 复制代码
/**
 * 返回给定名称的单例 bean 实例,如果当前还没有,则创建并注册一个新的实例。
 * @param beanName bean 的名称
 * @param singletonFactory 如果没有找到实例,则创建一个新实例的工厂
 * @return 单例 bean 实例
 */
protected Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        // 首先从缓存中获取单例对象
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            // 如果没有获取到,说明该 bean 还没有被创建过
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            // 标记为创建中
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<Exception>();
            }
            try {
                // 从 ObjectFactory 中创建对象
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

3.5 createBean

该方法会在 Bean 实例化之前做一些处理,之后对 Bean 进行实例化。

java 复制代码
/**
 * 该类的核心方法:创建一个 bean 实例,填充 bean 实例的属性,应用后处理器等。
 * @param beanName 要检索的 bean 的名称
 * @param mbd 用于创建 bean 的合并 bean 定义
 * @param args 用于构造函数或工厂方法调用的显式参数
 * @return bean 的一个新实例
 * @throws BeanCreationException 如果无法创建 bean
 */
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;

    // 确保此时已经解析了 bean 类,如果是动态解析的类,克隆 bean 定义
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // 准备方法覆盖
    try {
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // 允许 BeanPostProcessors 在目标 bean 实例化之前返回代理
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    } catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }

    // 实际创建 bean 实例
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

3.6 doCreateBean

该方法负责创建一个 bean 实例并进行初始化过程。这个方法是 Spring 中的一个核心方法,用于处理 bean 的创建和初始化的具体步骤。其主要任务包括实例化 bean、填充 bean 属性以及处理各种初始化回调,可以参考下流程图:

img
java 复制代码
/**
 * 实际创建指定的 bean。在此时已经进行了预创建处理,例如检查 postProcessBeforeInstantiation 回调。
 * @param beanName bean 的名称
 * @param mbd bean 的合并 bean 定义
 * @param args 用于构造函数或工厂方法调用的显式参数
 * @return bean 的一个新实例
 * @throws BeanCreationException 如果无法创建 bean
 */
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    // 实例化 bean
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 通过反射或者代理创建bean实例
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

    // 允许后处理器修改合并后的 bean 定义
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }

    // 预先缓存单例,以便在生命周期接口(如 BeanFactoryAware)触发时解析循环引用
    // 当前 bean 是否需要提前曝光 = isSingleton 是否单例 && allowCircularReferences 允许循环依赖 && isSingletonCurrentlyInCreation 当前 bean 正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isDebugEnabled()) {
            logger.debug("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
        // 这里主要是调用该方法,往三级缓存中放入一个当前 bean 的 ObjectFactory
        // 以便之后其他 bean 对当前 bean 有依赖时,可以通过里边的 getEarlyBeanReference 获取到当前 bean 实例的引用
        // 从而解决循环依赖
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }

    // 初始化 bean 实例
    Object exposedObject = bean;
    try {
        // 填充 bean 的属性,将各个属性值注入,其中可能存在依赖于其他bean的属性,会递归初始化
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            // 填充属性后对 bean 进一步初始化
            // 如注入 Aware相关对象,调用后置处理器 
            // 调用 后置处理器 BeanPostProcessor 里面的postProcessBeforeInitialization方法
            // 调用 initialzingBean,调用实现的 afterPropertiesSet()
            // 调用 init-mothod,调用相应的init方法				
            // 调用 后置处理器 BeanPostProcessor 里面的调用实现的postProcessAfterInitialization方法	
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    } catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        } else {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    // 处理早期单例暴露的情况
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        // earlySingletonReference 只有在检测到有循环依赖的情况下才会不为空
        if (earlySingletonReference != null) {
            // 如果exposedObject 没有在初始化方法中被改变,也就是没有被增强
            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);
                    }
                }
                // 到这一步的话,正常 bean 是已经实例化和初始化完成了,也就是它所依赖的其他 bean 已经创建完成了
                // 如果还有依赖的 bean没有创建,那双方相当于构成了循环依赖,从而导致没有创建完成,则抛异常
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other beans [" +
                                    StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                    "] in its raw version as part of a circular reference, but has eventually been " +
                                    "wrapped. This means that said other beans do not use the final version of the " +
                                    "bean. This is often the result of over-eager type matching - consider using " +
                                    "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    // 注册可销毁的 bean
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    } catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

3.7 populateBean

该方法主要会给实例化后的 bean 填充属性,在这之前会将 bean 所有需注入的属性进行获取。

java 复制代码
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();
    if (bw == null) {
        if (!pvs.isEmpty()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        } else {
            // 对于 null 实例,跳过属性填充阶段。
            return;
        }
    }
    // 让任何 InstantiationAwareBeanPostProcessors 有机会在设置属性之前修改 bean 的状态。
    // 例如,这可以用来支持字段注入的风格。
    boolean continueWithPropertyPopulation = true;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }
    // 如果后处理器发出停止填充命令则终止后续的执行
    if (!continueWithPropertyPopulation) {
        return;
    }
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // 如果适用,基于按名称自动装配添加属性值。
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
            // 根据名称自动注入
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // 如果适用,基于按类型自动装配添加属性值。
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            // 根据类型自动注入
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }
    // 后处理器是否已经初始化
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 是否需要依赖检查
    boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    if (hasInstAwareBpps || needsDepCheck) {
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        if (hasInstAwareBpps) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 对所有需要依赖检查的属性进行后处理
                    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            }
        }
        if (needsDepCheck) {
            // 依赖检查,对应depends-on属性,3.0已经弃用此属性
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
    }
    // 将属性应用到bean中
		// 将所有ProtertyValues中的属性填充至BeanWrapper中
    applyPropertyValues(beanName, mbd, bw, pvs);
}

3.8 applyPropertyValues

到这一步时,我们已经完成了对所有注入属性的获取,但是获取的属性是以 PropertyValues 形式存在的,还并没有应用到已经实例化的bean中,故由此方法处理。

java 复制代码
/**
 * 应用给定的属性值,解析对该 bean 工厂中其他 bean 的任何运行时引用。必须使用深拷贝,因此我们不会永久修改此属性。
 *
 * @param beanName 传递 bean 名称以获得更好的异常信息
 * @param mbd      合并的 bean 定义
 * @param bw       包装目标对象的 BeanWrapper
 * @param pvs      新的属性值
 */
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    if (pvs == null || pvs.isEmpty()) {
        return;
    }
    MutablePropertyValues mpvs = null;
    List<PropertyValue> original;
    if (System.getSecurityManager() != null) {
        if (bw instanceof BeanWrapperImpl) {
            ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
        }
    }
    if (pvs instanceof MutablePropertyValues) {
        mpvs = (MutablePropertyValues) pvs;
        // 如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanwapper中
        if (mpvs.isConverted()) {
            // 快捷方式:使用预转换的值。
            try {
                bw.setPropertyValues(mpvs);
                return;
            } catch (BeansException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Error setting property values", ex);
            }
        }
        original = mpvs.getPropertyValueList();
    } else {
        original = Arrays.asList(pvs.getPropertyValues());
    }
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }
    // 获取对应的解析器
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
    // 创建深拷贝,解析值的任何引用。
    List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
    boolean resolveNecessary = false;
    // 遍历属性,将属性转换为对应类的对应属性的类型
    for (PropertyValue pv : original) {
        if (pv.isConverted()) {
            deepCopy.add(pv);
        } else {
            String propertyName = pv.getName();
            Object originalValue = pv.getValue();
            Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
            Object convertedValue = resolvedValue;
            boolean convertible = bw.isWritableProperty(propertyName) &&
                    !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
            if (convertible) {
                convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
            }
            // 可能在合并的 bean 定义中存储转换后的值,以避免每个创建的 bean 实例的重新转换。
            if (resolvedValue == originalValue) {
                if (convertible) {
                    pv.setConvertedValue(convertedValue);
                }
                deepCopy.add(pv);
            } else if (convertible && originalValue instanceof TypedStringValue &&
                    !((TypedStringValue) originalValue).isDynamic() &&
                    !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                pv.setConvertedValue(convertedValue);
                deepCopy.add(pv);
            } else {
                resolveNecessary = true;
                deepCopy.add(new PropertyValue(pv, convertedValue));
            }
        }
    }
    if (mpvs != null && !resolveNecessary) {
        mpvs.setConverted();
    }
    // 设置我们(可能已处理的)深拷贝。
    try {
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    } catch (BeansException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

3.9 initializeBean

到这一步是,bean 已经完成了实例化 createBeanInstance(),并填充了属性 populateBean()

java 复制代码
/**
 * 初始化给定的 bean 实例,应用工厂回调、初始化方法和 bean 后置处理器。
 * <p>该方法在 {@link #createBean} 方法中调用以初始化传统定义的 bean,
 * 并在 {@link #initializeBean} 方法中调用以初始化现有的 bean 实例。
 * @param beanName 工厂中的 bean 名称(用于调试目的)
 * @param bean 需要初始化的新 bean 实例
 * @param mbd 创建该 bean 的 bean 定义(如果给定现有的 bean 实例,也可以为 {@code null})
 * @return 初始化后的 bean 实例(可能被包装过)
 * @see BeanNameAware
 * @see BeanClassLoaderAware
 * @see BeanFactoryAware
 * @see #applyBeanPostProcessorsBeforeInitialization
 * @see #invokeInitMethods
 * @see #applyBeanPostProcessorsAfterInitialization
 */
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    // 对特殊的 bean 进行处理:如实现了 Aware、BeanClassLoaderAware、BeanFactoryAware 的处理
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                // 激活 Aware 方法
                invokeAwareMethods(beanName, bean);
                return null;
            }
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 bean 初始化前的 BeanPostProcessor 方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 激活自定义的init的方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 bean 初始化后的 BeanPostProcessor 方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

4、实例演示

下面简单演示下 Spring Bean 的实例化、初始化、销毁过程。

4.1、准备项目

这边我就直接使用 Spring Boot 项目来演示。

4.2、编写 Bean 类

java 复制代码
package com.salmon.demo;


public class MyBean {
    public MyBean() {
        System.out.println("MyBean 实例化");
    }

    public void init() {
        System.out.println("MyBean 初始化");
    }

    public void destroy() {
        System.out.println("MyBean 销毁");
    }
}

4.3、编写配置类

java 复制代码
package com.salmon.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBeanConfig {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public MyBean myBean() {
        return new MyBean();
    }
}

4.4、编写主类

java 复制代码
package com.salmon.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

4.5、运行项目

运行项目后,可以看到控制台输出如下信息:

image-20240728001754209

mini-spring 源码

在上边,如果觉得跟踪源码比较复杂,可以看看这个精简版的 Spring,下边我将贴上这个精简版的 Spring 核心启动过程,和加载 IOC 容器、Bean 的生命周期。

1、加载配置文件

这里我还是以读取 xml 文件来加载 bean 定义信息为例

image-20240728002250135

2、加载 IOC 容器

接下来是加载 IOC 容器的核心过程。

image-20240728002431045

2.1 refreshBeanFactory

主要是创建 DefaultListableBeanFactory,往 DefaultListableBeanFactory 载入 BeanDefinition

image-20240728002529677

从配置文件中加载 bean 的定义信息

image-20240728002552963

2.2 getBeanFactory

将刚刚创建的 DefaultListableBeanFactory 返回,里面已经封装着我们的 bean 定义信息了

image-20240728002904913

2.3 addBeanPostProcessor

添加 ApplicationContextAwareProcessor,让继承自 ApplicationContextAware的 bean 能感知 bean,Spring 会在这些 bean 初始化时调用它们的 setApplicationContext 方法,从而注入 ApplicationContext 实例。

image-20240728003208752

2.4 invokeBeanFactoryPostProcessors

在 bean 实例化之前,执行 BeanFactoryPostProcessor,BeanFactoryPostProcessor 是 Spring 提供的一种扩展点,它允许在 bean 实例化之前对 BeanFactory 进行修改,这个方法会遍历所有的 BeanFactoryPostProcessor 并执行它们的 postProcessBeanFactory 方法

image-20240728003443320

2.5 registerBeanPostProcessors

将所有的 BeanPostProcessor 提前注册到 BeanFactory 中,在其他 bean 实例化之前。BeanPostProcessor 是 Spring 的另一种扩展点,允许在 bean 的初始化前后进行自定义操作。比如,AutowiredAnnotationBeanPostProcessor 会处理 @Autowired 注解。这个方法会将所有实现了 BeanPostProcessor 接口的 bean 提前注册到 BeanFactory 中,以确保它们在其他 bean 初始化过程中能够被正确应用。

image-20240728003708512

BeanPostProcessor 接口如下:

image-20240728003851922

2.6 initApplicationEventMulticaster

初始化事件发布者 ApplicationEventMulticaster。ApplicationEventMulticaster 是 Spring 的事件发布机制的核心组件,它负责将事件发布给所有注册的监听器。

image-20240728004349987

在 AbstractApplicationContext 中维护着一个单例的全局的事件发布者。

image-20240728004439116

2.7 registerListeners

注册所有的事件监听器。这个方法会查找并注册所有实现了 ApplicationListener 接口的 bean。注册后,这些监听器将能够接收到由 ApplicationEventMulticaster 发布的事件,并对事件做出响应。

image-20240728004550438

2.8 finishBeanFactoryInitialization

这是 IOC 容器的核心的方法,也是 Bean 生命周期的过程。该方法会注册类型转换器和提前实例化所有的单例 bean(不处理懒加载)

image-20240728005222540

2.9 finishRefresh

发布容器刷新完成事件
image-20240728004728810

让全局的事件发布者发布事件,通知它们 IOC 容器加载完成啦

image-20240728004753278

让所有事件监听器收到该事件并处理

image-20240728004854832

到这里,我就介绍完 IOC 容器的加载过程了,接下来,我会讲一下 bean 的生命周期,也就是在准备实例化和初始化 bean 的过程。

3、Bean 的生命周期

bean 的生命周期如下:

image-20240728013639034

3.1 preInstantiateSingletons

准备实例化与初始化所有的单例且非懒加载的 bean

image-20240728010346052

3.2 getBean

创建实例化的 bean 并初始化

image-20240728010545627

其中会先从三级缓存中去获取实例化的 bean,为了解决循环依赖

执行完 createBean 后,会判断 Bean 是否实现了 FactoryBean 接口,如果实现了,则会调用 getObject ,如果是单例,则会放入缓存中,之后从缓存获取

image-20240728011104323

3.3 createBean

开始创建 bean,在这之前,会先判断是否该 bean 需要代理对象,如果需要,则直接返回代理对象

image-20240728013148296

执行 bean 实例化前和实例化后处理的方法,返回该 bean 的代理对象,比如生成 aop 的代理对象

image-20240728013254244

3.4 doCreateBean

该方法会进行 bean 的实例化,属性填充、bean 的初始化

image-20240728013956393
image-20240728014036290
3.4.1 createBeanInstance

首先先创建 bean 的实例,此时的 bean 实例是不完整的

image-20240728014210793

会根据当前 bean 的情况来根据反射或者 cglib 来创建 bean 实例

image-20240728014418674

通过反射创建实例

image-20240728014452569

通过 cglib 创建实例

image-20240728014534557
3.4.2 addSingletonFactory

为了解决循环依赖问题,提前暴露 bean 对象,放入三级缓存中

image-20240728014806222
image-20240728014833678
image-20240728015035318
3.4.3 applyBeanPostProcessorsAfterInstantiation

bean 实例化后的一些处理

image-20240728020052952
3.4.4 applyBeanPostProcessorsBeforeApplyingPropertyValues

在设置 bean 属性之前,允许 BeanPostProcessor 修改属性值

image-20240728015801118

将 BeanPostProcessor 的属性值添加到 BeanDefinition 中所维护的 PropertyValues

image-20240728015942708
3.4.5 applyPropertyValues

为 bean 填充属性,并在此注入属性或者依赖的 bean 对象,最后通过反射设置属性值

image-20240728020814851
3.4.6 initializeBean

执行 bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法

image-20240728021006008
3.4.7 registerDisposableBeanIfNecessary

注册有销毁方法的 bean

image-20240728021150499
3.4.8 addSingleton

将实例化后的单例 bean 添加到一级缓存中,同时删除二三级缓存

image-20240728021326423
image-20240728021354591

至此,mini-spring 的 Spring 启动流程的核心代码部分就讲解完了。

Spring 如何解决循环依赖

为了理解 Spring 如何解决循环依赖的问题,我们可以通过一段具体的代码流程来详细解析其中的过程。假设我们有两个类 A 和 B,它们互相依赖:

java 复制代码
@Component
public class A {
    @Autowired
    private B b;
}

@Component
public class B {
    @Autowired
    private A a;
}

当 Spring 尝试实例化这两个类时,会触发循环依赖的处理机制。我们将通过源码深入分析这个过程:

步骤 1:实例化 A

Spring 首先尝试实例化 A,调用 doGetBean 方法:

java 复制代码
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = this.transformedBeanName(name);
    Object sharedInstance = this.getSingleton(beanName);
    // 省略部分代码
}

调用 getSingleton 方法判断容器中是否已有 A:

java 复制代码
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<Exception>();
            }
            try {
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch (IllegalStateException ex) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            } catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            } finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

在 getSingleton 方法中,首先检查 singletonObjects 中是否已有 A,如果没有,再检查是否在创建中(通过 singletonsCurrentlyInCreation 集合),然后调用 beforeSingletonCreation(beanName) 将 A 标记为创建中。

步骤 2:实例化 B

在 createBean 方法中,当创建 A 时,需要填充其依赖的属性,这时会调用 populateBean 方法:

java 复制代码
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }

    if (instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    synchronized(mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            } catch (Throwable var17) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
            }

            mbd.postProcessed = true;
        }
    }

    boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
    if (earlySingletonExposure) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
        }
        this.addSingletonFactory(beanName, () -> {
            return this.getEarlyBeanReference(beanName, mbd, bean);
        });
    }

    Object exposedObject = bean;

    try {
        this.populateBean(beanName, mbd, instanceWrapper);
        exposedObject = this.initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable var18) {
        if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
            throw (BeanCreationException)var18;
        }

        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
    }

    if (earlySingletonExposure) {
        Object earlySingletonReference = this.getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                String[] dependentBeans = this.getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                String[] var12 = dependentBeans;
                int var13 = dependentBeans.length;

                for(int var14 = 0; var14 < var13; ++var14) {
                    String dependentBean = var12[var14];
                    if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }

                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    try {
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    } catch (BeanDefinitionValidationException var16) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
    }
}

在 populateBean 方法中,Spring 发现 A 需要依赖 B,于是再次调用 getBean(B) 方法。

步骤 3:再次调用 getBean 方法实例化 B

同样的,调用 doGetBean 方法,然后进入 getSingleton 方法:

java 复制代码
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<Exception>();
            }
            try {
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch (IllegalStateException ex) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            } catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            } finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

此时 B 还未被创建,于是 Spring 开始创建 B,但在创建 B 时发现 B 依赖 A,于是再调用 getBean(A)。

步骤 4:处理循环依赖

这时 A 已经在创建过程中,因此进入 isSingletonCurrentlyInCreation(beanName) 判断:

java 复制代码
protected boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

发现 A 已经在创建过程中,于是从 singletonFactories 中获取 A 的工厂对象,调用 getEarlyBeanReference:

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

这样,Spring 从 singletonFactories 中获取到 A 的半成品对象,并将其放入 earlySingletonObjects 中,从而解决了循环依赖问题。

三个缓存的作用

  1. 一级缓存(singletonObjects):用于存储完整的单例对象。
  2. 二级缓存(earlySingletonObjects):用于存储对象的早期引用,防止重复创建。
  3. 三级缓存(singletonFactories):用于存储对象工厂,解决循环依赖时生成代理对象。

通过这三个缓存,Spring 能够有效地解决循环依赖问题,确保对象在创建过程中能够正确注入依赖并最终形成完整的 Bean 实例。(依赖的 Bean 必须是单例,依赖注入的方式,必须不全是构造器注入,且 beanName 字母在前的不能是构造器注入 )

结语

通过这次分析两种源码的过程中,无论是原版的 Spring 还是 mini-spring,都可以发现 Spring 的启动流程和 Bean 的生命周期是很复杂的,不过相信大家通过阅读简化版的 Spring,也能有不错的收货吧。

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句