侧边栏壁纸
博主头像
一定会去到彩虹海的麦当

说什么呢?约定好的事就一定要做到啊!

  • 累计撰写 63 篇文章
  • 累计创建 16 个标签
  • 累计收到 3 条评论

目 录CONTENT

文章目录

[Spring源码]——Bean的加载

一定会去到彩虹海的麦当
2022-01-20 / 0 评论 / 0 点赞 / 68 阅读 / 19,710 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-02-11,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

📚笔记整理自《Spring源码深度解析》(第2版),同时也参考了一些网上资源,具体参考链接在文末

整体分析

从以下代码入手分析bean的加载过程

MyTestBean bean=(MyTestBean) bf.getBean("myTestBean");

doGetBan分析

源码解析

ClassPathResource.java
@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

进入到doGetBean

@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    // 转换beanName
    final String beanName = transformedBeanName(name);
    Object bean;

     /**
     *检查缓存中或者实例工厂中是否有对应的实例
     *因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖
     *Spring创建bean的原则是不等bean创建完成就会将创建bean的OjectFactory提早曝光
     *也就是将ObjectFactory加入到缓中,一旦下个bean创建时候需要依赖上个bean则直		*接使用ObjectFactory
     */
    //尝试从缓存中获取或者 singletonFactories中的ObjectFactory中获取
    Object sharedInstance = getSingleton(beanName);
    // 单例对象是否存在参数是否为空
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                             "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        //从FactoryBean实例中获取对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    //如果缓存中没有的话,则需要从头开始bean的创建过程
    else {
        //只有在单例情况才会尝试解决循环依赖,原型模式情况下,如果存在
        //A中有B的属性,B中有A的属性,那么当依赖注入的时候,就会产生A还未创建完的时候
        //因为对于B的创建再次返回创建A,造成循环依赖,也就是下面的情况
        // 循环依赖的问题
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        
        BeanFactory parentBeanFactory = getParentBeanFactory();
 	 //如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从
     //parentBeanFactory中检测
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            //递归到BeanFactory中寻找
            // 父bean工厂 类型判断
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                // 再次获取
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        //如果不是仅仅做类型检查则是创建bean,这里要进行记录
        if (!typeCheckOnly) {
            // 将bean 标记为已创建
            markBeanAsCreated(beanName);
        }

        try {
          //将存储XML配置文件的GErnericBeanDefinition转换为RootBeanDefinition
          //如果指定BeanName是子Bean的话同时会合并父类的相关属性
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            // 需要依赖的bean
            String[] dependsOn = mbd.getDependsOn();
            //若存在依赖则需要递归实例化依赖的bean
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // 是否依赖
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 缓存依赖调用
                    registerDependentBean(dep, beanName);
                    try {
                        // 获取bean
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

             //实例化依赖的bean后便可以实例化mbd本身了
            //singleton模式的创建
            if (mbd.isSingleton()) {
                // 获取bean单例bean
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 创建bean
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        // Explicitly remove instance from singleton cache: It might have been put there
                        // eagerly by the creation process, to allow for circular reference resolution.
                        // Also remove any beans that received a temporary reference to the bean.
                        // 摧毁单例的bean
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                // 获取 bean 实例
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            // 原型模式创建
            // 是否是原型模式
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                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
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    // 从 scope 接口卓获取
                    Object scopedInstance = scope.get(beanName, () -> {
                        // 创建之前做的行为
                        beforePrototypeCreation(beanName);
                        try {
                            // 创建 bean
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            // 创建之后做的行为
                            afterPrototypeCreation(beanName);
                        }
                    });
                    // 获取 bean 实例
                    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) {
            // bean 创建失败后的处理
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }


    // 类型和需要的类型是否匹配
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            // 获取类型转换器 , 通过类型转换器进行能转换
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

时序图解析

bean的获取过程

步骤流程

第一步:转换对应beanName

传入的参数可能为别名、FactoryBean,所以要进行一系列解析

  • 去除FactoryBean的修饰符,也就是如果name="&aa",那么会首先去除&而使name="a".
  • 取指定alias所表示的最终beanName,例如别名A指向名称为B的bean则返回B;若别名A指向别名B,别名B又指向名称为C的bean则返回C

第二步:尝试从缓存中加载单例

单例只会被创建一次,后续再获取bean,就直接从单例缓存中获取了。

  • 如果存在

    从FactoryBean实例中获取对象( 缓存中有 )

    如果从缓存中得到了bean的原始状态,则需要从FactoryBean实例中获取对象

    缓存中记录的只是最原始的bean状态,并不一定是最终想要的bean。

  • 不存在,从头开始创建

    • 原型模式的依赖检查(缓存中没有,从头开始创建)

      只有在单例情况下才会尝试解决循环依赖。

    • 检测parentBeantFactory

      如果检测到当前加载的XML配置文件中不包含beanName所对应的配置,且存在父类工厂的话,就只能到parentBeanFactory去尝试加载

    • 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition

      因为从XML配置文件中读取到的bean信息是存储在GernericBeanDefinition中的,但是所有的bean后续处理都是针对于RooiBeanDefinition的,所以这里需要进行一个转换,转换的同时如果父类bean不为空的话,则会一并合并父类的属性。

    • 寻找依赖

      初始化过程中很有可能某些属性依赖于其他的bean,需要先加载依赖的bean

    • 针对不同的scope进行bean的创建

      默认的是singleton,还有prototype、request等

第三步:类型转换

返回的类型可能跟需要的类型不一致,需要进行转换

源码分析

getSingleton

缓存中获取单例bean

DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName) {
		//参数设置标识允许早期依赖
		return getSingleton(beanName, true);
	}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //检查缓存中是否存在实例
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        //如果缓存中没有,且当前bean正在创建的话,则可以从earlySingletonObjects中获取
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            //如果则可以从earlySingletonObjects中没有,且允许早期依赖;这锁定全局并进行处理
            synchronized (this.singletonObjects) {
                //再次检查缓存是否存在实例
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    //再次检查earlySingletonObjects是否存在bean
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        //当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的ObjectFactory初始话策略存储在singletonFactories中
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            //调用预先设定的getObject方法
                            singletonObject = singletonFactory.getObject();
                            //记录在缓存中,earlySingletonObjects跟singletonFactories互斥
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

总结:

  • 先从一级缓存singletonObjects中去获取。(如果获取到就直接return)
  • 如果获取不到或者对象正在创建中(isSingletonCurrentlyInCreation()),那就再从二级缓存earlySingletonObjects中获取。(如果获取到就直接return)
  • 如果还是获取不到,且允许singletonFactories(allowEarlyReference=true)通过getObject()获取。就从三级缓存singletonFactory.getObject()获取。(如果获取到了就从singletonFactories中移除,并且放进earlySingletonObjects。其实也就是从三级缓存移动(是剪切、不是复制哦~)到了二级缓存)

使用到的各个map

  • singletonObjects:用于保存BeanName和创建bean实例之间的关系,bean name—> bean instance.

  • singletonFactories:用于保存BeanName和创建bean的工厂之间的关系,bean name->ObjectFactory

    加入singletonFactories三级缓存的前提是执行了构造器,所以构造器的循环依赖没法解决

  • earlySingletonObjects:也是保存BeanName和创建bean实例之间的关系,与singletonObjects的不同之处在于,当一个单例bean被放到这里面后,那么当bean还在创建过程中,就可以通过getBean方法获取到了,其目的是用来检测循环引用

  • registeredSingletons:用来保存当前所有已注册的bean.

getObjectForBeanInstance

从bean实例中获取对象

当我们得到bean的实例后要做的第一步就是调用这个方法检测当前bean是否是FactoryBean的Bean,如果是,那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。这里的返回值是处理过的对象。

AbstractBeanFactory.java
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
       //如果是工厂相关(以&为前缀)
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
            //工厂相关且不是FactoryBean类型,验证不通过
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
            //是FactoryBean类型
			if (mbd != null) {
				mbd.isFactoryBean = true;
			}
			return beanInstance;
		}
    	//如果不是工厂实现类,不处理
		if (!(beanInstance instanceof FactoryBean)) {
			return beanInstance;
		}
    	//加载FactoryBean
		Object object = null;
		if (mbd != null) {
			mbd.isFactoryBean = true;
		}
		else {
            //尝试从缓存中加载bean
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			//到这里明确知道beanInstance一定是FactoryBean类型
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			//containsBeanDefinition检测beanDEfinitionMap中也就是在所有已经加载的类中检测是否定义beanName
			if (mbd == null && containsBeanDefinition(beanName)) {
                //将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefiniton,如果指定BeanName是子Bean的话会同时合并父类的相关属性
				mbd = getMergedLocalBeanDefinition(beanName);
			}
            //是否是用户定义的而不是应用程序本身定义的
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

流程如下:

  1. 对Factory正确性的验证
  2. 对非FactoryBean不做任何处理
  3. 对bean进行转换
  4. 将从Factory中解析bean的工作委托给getObjectFromFactoryBean

核心代码在getObjectFromFactoryBean,但进入方法后发现该方法只是保证返回的单例的bean是全局唯一。真正工作移交到了doGetObjectFromFactoryBean方法中。

FactoryBeanRegistrySupport.java
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
		Object object;
		try {
			//需要权限验证
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				//直接调用getObject方法
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}

		// Do not accept a null value for a FactoryBean that's not fully
		// initialized yet: Many FactoryBeans just return null then.
		if (object == null) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(
						beanName, "FactoryBean which is currently in creation returned null from getObject");
			}
			object = new NullBean();
		}
		return object;
	}

可以看到在这里调用了factory.getObject(),返回处理过的对象。

getSingleton(重载方法)

如果缓存中没有已经加载的单例bean,则需要从头开始bean的加载过程。使用getSingleton的重载方法实现bean的加载过程

DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    //全局变量需要同步
    synchronized (this.singletonObjects) {
        //首先检查对应的bean是否已经加载过,因为singleton模式其实就是复用以创建的bean
        Object singletonObject = this.singletonObjects.get(beanName);
        //如果为空才可以进行singleton的bean初始化
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                                                          "Singleton bean creation not allowed while 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<>();
            }
            try {
                //初始化bean
                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;
    }
}

流程分析:

  1. 检查缓存是否已经加载过,已经加载过直接返回

  2. 若没有加载,则记录beanName的正在加载状态。

    • 通过调用 参数传入的ObjectFactory的 个体Object方法实例化bean

    • 加载单例后的处理方法调用

      当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录

    • 将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态

    • 返回处理结果

createBean

准备创建Bean

AbstractAutowireCapableBeanFactory.java
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		...
		RootBeanDefinition mbdToUse = mbd;

		//锁定class,根据设置的class属性或者根据className来解析Class
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		//验证及准备覆盖的方法
    	//对override属性进行标记及验证
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			...
		}

		try {
            //应用初始化的前的后处理器
			//给BeanPostProcessors一个机会来返回代理来替代真正的实例
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			//短路判断,如果经过前置处理后的结果不为空,就直接返回
            if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
		  ...
		}

		try {
			//核心代码,常规bean的创建
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			...
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			...
		}
		
	}

流程分析:

  1. 根据设置的class属性或者根据className来解析Class
  2. 对override属性进行标记及验证。
  3. 应用初始化前的后处理器,如果经过前置处理后的结果不为空,就直接返回
  4. 创建常规bean

对override属性进行标记及验证的作用:

  1. 在Spring配置中存在lookup-method和replace-method两个配置功能,而这两个配置的加载其实就是将配置统一存放在BeanDefinition的methodOverrrides属性里。这里就是对这个歌属性进行配置

  2. 如果当前类没有被重载时,这里会做标记,后续调用的时候就不用太通过参数类型进行匹配了,因为方法只有一个。

  3. 可以提前对方法存在性进行验证

resolveBeforeInstantiation

AbstractAutowireCapableBeanFactory.java
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

重点关注两个地方

1.applyBeanPostProcessorsBeforeInstantiation

这个是bean实例化前的后处理器,实例化前调用,也就是将AbstractBeanDefinition转换为BeanWrapper处理。给子类一个修改BeanDefinition的机会。

经过这个方法后,bean可能成为一个经过处理的代理bean,可能是通过cglib生成的,也可能是通过其他技术。

2.applyBeanPostProcessorsAfterInitialization

实例化后的后处理器应用

doCreateBean

AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

     // 第一部分
    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        //如果是单例则需要清除缓存
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
     //instanceWrapper不存在的话
    if (instanceWrapper == null) {
        //根据指定bean使用对应的策略创建新的实例,如:工厂方法、构造函数自动注入、简单初始化
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    
     // 第二部分
   // 获取 实例
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                //应用MergedBeanDefinitionPostProcessor
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                ...
            }
            mbd.postProcessed = true;
        }
    }

     // 第三部分
    /**
		 * 是否需要提早曝光:单例 & 允许循环依赖 & 当前bean正在创建中,检查循环依赖
		 */
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        ...
      //为避免后期循环依赖,可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
      //给调用者个机会,自己去实现暴露这个bean的应用的逻辑,比如在getEarlyBeanReference()里可以实现AOP的逻辑
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

     // 第四部分
   // 实例化bean
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        //对bean进行填充,将各个属性值自动注入,其中,可能存在依赖于其他bean的属性,则会递归初始化依赖bean
        populateBean(beanName, mbd, instanceWrapper);
        //调用初始化方法,比如init-method
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        ...
    }
    
     // 第五部分
   // 依赖相关处理
    //earlySingletonExposure:如果你的bean允许被早期暴露出去 也就是说可以被循环引用  那这里就会进行检查
    if (earlySingletonExposure) {
        //第二参数为false  表示不会再去三级缓存里查了
        Object earlySingletonReference = getSingleton(beanName, false);
        //只有在检测到有循环依赖的情况下才会不为空
        if (earlySingletonReference != null) {
            //如果exposedObject没有在初始化方法中被改变,也就是没有被增强
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                // 当前bean的依赖列表
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                //它如果判断到该dependentBean并没有在创建中的了的情况下,那就把它从所有缓存中移除~~~  并且返回true,否则(比如确实在创建中) 那就返回false 进入我们的if里面~  表示所谓的真正依赖
                //就是真的需要依赖它先实例化,才能实例化自己的依赖
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        //actualDependentBeans未创建的bean
                        actualDependentBeans.add(dependentBean);
                    }
                }
                /**
					 * 因为bean创建后其所依赖的bean一定是已经创建的,actualDependentBeans不为空则表示当前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.");

                }
            }
        }
    }

    // 第六部分
    // Register bean as disposable.
    try {
        //根据scopse注册bean
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        ...
    }

    return exposedObject;
}
// 虽然是remove方法 但是它的返回值也非常重要
// 该方法唯一调用的地方就是循环依赖的最后检查处~~~~~
protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {
    // 如果这个bean不在创建中  比如是ForTypeCheckOnly的  那就移除掉
    if (!this.alreadyCreated.contains(beanName)) {
        removeSingleton(beanName);
        return true;
    }
    else {
        return false;
    }
}

流程分析:

第一部分

  1. 如果是单例则需要首先清除缓存

  2. 实例化bean,将BeanDefinition转换为BeanWrapper

    • 如果存在工厂方法则使用工厂方法进行初始化。
    • 一个类有多个构造函数,每个构造函数都有不同的参数,所以需要根据参数锁定构造函数并进行初始化。
    • 如果既不存在工厂方法也不存在带有参数的构造函数,则使用默认的构造函数进行bean的实例化。
  3. MergedBeanDefinitionPostProcessor的应用

    bean合并后的处理,Autowired注解正是通过此方法实现诸如类型的预解析

  4. 依赖处理

  5. 属性填充。将所有的属性填充至bean的实例中

  6. 调用用户设定的初始方法,即init-method属性配置的方法,来初始化bean

    同时还做了一些其他工作

    • 激活Aware方法

    • 应用处理器

      在调用客户自定义初始化方法前以及调用自定义初始化方法后分别会调用
      BeanPostProcessor的postProcess BeforeInitialization和postProcessAfterInitialization方法,使用户可以根据自己的业务需求进行响应的处理。

    • 激活自定义的init方法

      这个跟init-method配置不同,这个是自定义的bean实现InitializingBean接口,并在afterPropertiesSet中实现自己的初始化业务逻辑。

      执行顺序是afterPropertiesSet先执行,init-method后执行

  7. 循环依赖检查

    检测已经加载的bean是否已经出现了依赖循环,并判断是否需要抛出异常

  8. 注册DisposableBean

    • 如果配置destroy-method,这里需要注册以便于在销毁的时候调用
    • 注册后处理器DestructionAwareBeanPostProcessor来统一处理bean的销毁方法
  9. 完成创建并返回

从代码中深入分析如何解决循环依赖

重点关注这个地方的代码

//为避免后期循环依赖,可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

img

在B中创建依赖A时通过Objetfactory提供的实例化方法来中断A中的属性填充,使B中持有的A仅仅是刚刚初始化并没有填充任何属性的A

而这正初始化A的步骤还是在最开始创建A的时候进行的,但是因为A与B中的A所表示的属性地址是一样的,所以在A中创建好的属性填充自然可以通过B中的A获取,这样就解决了循环依赖的问题。

参考链接:

Spring AbstractAutowireCapableBeanFactory 分析

0

评论区