当前位置 : 主页 > 编程语言 > java >

Spring5 IOC容器解析——getBean()方法分析

来源:互联网 收集:自由互联 发布时间:2023-02-04
前言 接着Spring5IOC容器解析--refresh()方法分析,我们正式开始学习获取 bean 实例方法,该方法是 Spring 最核心的方法。 正文 进入refresh()方法跟进实例化所有的类方法finishBeanFactoryInitiali

前言

接着Spring5IOC容器解析--refresh()方法分析,我们正式开始学习获取 bean 实例方法,该方法是 Spring 最核心的方法。

正文

进入refresh()方法跟进实例化所有的类方法finishBeanFactoryInitialization()方法,然后继续跟进finishBeanFactoryInitialization方法,接着单击 preInstantiateSingletons 方法里的 getBean(beanName) 代码,进入该方法。

getBean

@Override public Object getBean(String name) throws BeansException { // 获取name对应的bean实例,如果不存在,则创建一个 return doGetBean(name, null, null, false); }

doGetBean

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { // 1.解析beanName,主要是解析别名、去掉FactoryBean的前缀“&” final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. // 2.尝试从缓存中获取beanName对应的实例 Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { // 3.如果beanName的实例存在于缓存中 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 + "'"); } } // 3.1 返回beanName对应的实例对象(主要用于FactoryBean的特殊处理,普通Bean会直接返回sharedInstance本身) bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. // 4.scope为prototype的循环依赖校验:如果beanName已经正在创建Bean实例中,而此时我们又要再一次创建beanName的实例,则代表出现了循环依赖,需要抛出异常。 // 例子:如果存在A中有B的属性,B中有A的属性,那么当依赖注入的时候,就会产生当A还未创建完的时候因为对于B的创建再次返回创建A,造成循环依赖 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. // 5.获取parentBeanFactory BeanFactory parentBeanFactory = getParentBeanFactory(); // 5.1 如果parentBeanFactory存在,并且beanName在当前BeanFactory不存在Bean定义,则尝试从parentBeanFactory中获取bean实例 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. // 5.2 将别名解析成真正的beanName String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } // 5.3 尝试在parentBeanFactory中获取bean对象实例 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); } } if (!typeCheckOnly) { // 6.如果不是仅仅做类型检测,而是创建bean实例,这里要将beanName放到alreadyCreated缓存 markBeanAsCreated(beanName); } try { // 7.根据beanName重新获取MergedBeanDefinition(步骤6将MergedBeanDefinition删除了,这边获取一个新的) final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 7.1 检查MergedBeanDefinition checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. // 8.拿到当前bean依赖的bean名称集合,在实例化自己之前,需要先实例化自己依赖的bean String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { // 8.1 遍历当前bean依赖的bean名称集合 for (String dep : dependsOn) { // 8.2 检查dep是否依赖于beanName,即检查是否存在循环依赖 if (isDependent(beanName, dep)) { // 8.3 如果是循环依赖则抛异常 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // 8.4 将dep和beanName的依赖关系注册到缓存中 registerDependentBean(dep, beanName); try { // 8.5 获取dep对应的bean实例,如果dep还没有创建bean实例,则创建dep的bean实例 getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance. // 9.针对不同的scope进行bean的创建 if (mbd.isSingleton()) { // 9.1 scope为singleton的bean创建(新建了一个ObjectFactory,并且重写了getObject方法) sharedInstance = getSingleton(beanName, () -> { try { // 9.1.1 创建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. destroySingleton(beanName); throw ex; } }); // 9.1.2 返回beanName对应的实例对象 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. // 9.2 scope为prototype的bean创建 Object prototypeInstance = null; try { // 9.2.1 创建实例前的操作(将beanName保存到prototypesCurrentlyInCreation缓存中) beforePrototypeCreation(beanName); // 9.2.2 创建Bean实例 prototypeInstance = createBean(beanName, mbd, args); } finally { // 9.2.3 创建实例后的操作(将创建完的beanName从prototypesCurrentlyInCreation缓存中移除) afterPrototypeCreation(beanName); } // 9.2.4 返回beanName对应的实例对象 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { // 9.3 其他scope的bean创建,可能是request之类的 // 9.3.1 根据scopeName,从缓存拿到scope实例 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 { // 9.3.2 其他scope的bean创建(新建了一个ObjectFactory,并且重写了getObject方法) Object scopedInstance = scope.get(beanName, () -> { // 9.3.3 创建实例前的操作(将beanName保存到prototypesCurrentlyInCreation缓存中) beforePrototypeCreation(beanName); try { // 9.3.4 创建bean实例 return createBean(beanName, mbd, args); } finally { // 9.3.5 创建实例后的操作(将创建完的beanName从prototypesCurrentlyInCreation缓存中移除) afterPrototypeCreation(beanName); } }); // 9.3.6 返回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) { // 如果创建bean实例过程中出现异常,则将beanName从alreadyCreated缓存中移除 cleanupAfterBeanCreationFailure(beanName); throw ex; } } // Check if required type matches the type of the actual bean instance. // 10.检查所需类型是否与实际的bean对象的类型匹配 if (requiredType != null && !requiredType.isInstance(bean)) { try { // 10.1 类型不对,则尝试转换bean类型 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()); } } // 11.返回创建出来的bean实例对象 return (T) bean; } }
  • 1、解析 beanName,主要是解析别名、去掉 FactoryBean 的修饰符 “&”。

  • 2、尝试从缓存中获取 beanName 对应的实例。

  • 3.1、返回 beanName 对应的实例对象(主要用于 FactoryBean 的特殊处理,普通 bean 会直接返回 sharedInstance 本身)。

  • 6、如果不是仅仅做类型检测,而是创建 bean 实例,这里要将 beanName 放到 alreadyCreated 缓存。

  • 7、根据 beanName 重新获取 MergedBeanDefinition。

  • 8.2、检查 dep 是否依赖于 beanName,即检查是否存在循环依赖。

  • 8.4、将 dep 和 beanName 的依赖关系注册到缓存中。

  • 9.1、scope 为 singleton 的 bean 创建(新建了一个 ObjectFactory,并且重写了 getObject 方法)。

  • 9.1.1、9.2.2、9.3.4、创建 bean 实例。

  • 9.1.2、9.2.4、9.3.6、返回 beanName 对应的实例对象。

  • 9.2.1、scope 为 prototype 时创建实例前的操作、9.2.3 scope 为 prototype 时 创建实例后的操作,相对应的两个方法。

Object sharedInstance = getSingleton(beanName)

尝试从缓存中获取beanName对应的实例

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { /** Cache of singleton objects: bean name to bean instance. */ //一级缓存:单例对象缓存池,beanName->Bean,其中存储的就是实例化,属性赋值成功之后的单例对象 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /** Cache of singleton factories: bean name to ObjectFactory. */ //三级缓存:单例工厂的缓存,beanName->ObjectFactory,添加进去的时候实例还未具备属性 // 用于保存beanName和创建bean的工厂之间的关系map,单例Bean在创建之初过早的暴露出去的Factory, // 为什么采用工厂方式,是因为有些Bean是需要被代理的,总不能把代理前的暴露出去那就毫无意义了 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /** Cache of early singleton objects: bean name to bean instance. */ //二级缓存:早期的单例对象,beanName->Bean,其中存储的是实例化之后,属性未赋值的单例对象 // 执行了工厂方法生产出来的Bean,bean被放进去之后, // 那么当bean在创建过程中,就可以通过getBean方法获取到 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); @Override @Nullable public Object getSingleton(String beanName) { return getSingleton(beanName, true); } @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 1.从单例对象缓存中获取beanName对应的单例对象 Object singletonObject = this.singletonObjects.get(beanName); // 2.如果单例对象缓存中没有,并且该beanName对应的单例bean正在创建中 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // 3.加锁进行操作 synchronized (this.singletonObjects) { // 4.从早期单例对象缓存中获取单例对象(之所称成为早期单例对象,是因为earlySingletonObjects里 // 的对象的都是通过提前曝光的ObjectFactory创建出来的,还未进行属性填充等操作) singletonObject = this.earlySingletonObjects.get(beanName); // 5.如果在早期单例对象缓存中也没有,并且允许创建早期单例对象引用 if (singletonObject == null && allowEarlyReference) { // 6.从单例工厂缓存中获取beanName的单例工厂 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { // 7.如果存在单例对象工厂,则通过工厂创建一个单例对象 singletonObject = singletonFactory.getObject(); // 8.将通过单例对象工厂创建的单例对象,放到早期单例对象缓存中 this.earlySingletonObjects.put(beanName, singletonObject); // 9.移除该beanName对应的单例对象工厂,因为该单例工厂已经创建了一个实例对象,并且放到earlySingletonObjects缓存了, // 因此,后续获取beanName的单例对象,可以通过earlySingletonObjects缓存拿到,不需要在用到该单例工厂 this.singletonFactories.remove(beanName); } } } } // 10.返回单例对象 return singletonObject; } }

这段代码很重要,在正常情况下,该代码很普通,只是正常的检查下我们要拿的 bean 实例是否存在于缓存中,如果有就返回缓存中的 bean 实例,否则就返回 null。

 

这段代码之所以重要,是因为该段代码是 Spring 解决循环引用的核心代码。

 

解决循环引用逻辑:使用构造函数创建一个 “不完整” 的 bean 实例(之所以说不完整,是因为此时该 bean 实例还未初始化),并且提前曝光该 bean 实例的 ObjectFactory(提前曝光就是将 ObjectFactory 放到 singletonFactories 缓存),通过 ObjectFactory 我们可以拿到该 bean 实例的引用,如果出现循环引用,我们可以通过缓存中的 ObjectFactory 来拿到 bean 实例,从而避免出现循环引用导致的死循环。这边通过缓存中的 ObjectFactory 拿到的 bean 实例虽然拿到的是 “不完整” 的 bean 实例,但是由于是单例,所以后续初始化完成后,该 bean 实例的引用地址并不会变,所以最终我们看到的还是完整 bean 实例。

 

另外这个代码块中引进了4个重要缓存:

  • singletonObjects 缓存:beanName -> 单例 bean 对象。
  • earlySingletonObjects 缓存:beanName -> 单例 bean 对象,该缓存存放的是早期单例 bean 对象,可以理解成还未进行属性填充、初始化。
  • singletonFactories 缓存:beanName -> ObjectFactory。
  • singletonsCurrentlyInCreation 缓存:当前正在创建单例 bean 对象的 beanName 集合。

singletonObjects、earlySingletonObjects、singletonFactories 在这边构成了一个类似于 “三级缓存” 的概念。

getObjectForBeanInstance

返回beanName对应的实例对象(主要用于FactoryBean的特殊处理,普通Bean会直接返回sharedInstance本身)

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { // Don't let calling code try to dereference the factory if the bean isn't a factory. if (BeanFactoryUtils.isFactoryDereference(name)) { if (beanInstance instanceof NullBean) { return beanInstance; } // 1.如果name以“&”为前缀,但是beanInstance不是FactoryBean,则抛异常 if (!(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass()); } if (mbd != null) { mbd.isFactoryBean = true; } return beanInstance; } // Now we have the bean instance, which may be a normal bean or a FactoryBean. // If it's a FactoryBean, we use it to create a bean instance, unless the // caller actually wants a reference to the factory. // 2.1 如果beanInstance不是FactoryBean(也就是普通bean),则直接返回beanInstance if (!(beanInstance instanceof FactoryBean)) { return beanInstance; } //FactoryBean创建出bean实例返回 // 3.走到这边,代表beanInstance是FactoryBean,但name不带有“&”前缀,表示想要获取的是FactoryBean创建的对象实例 Object object = null; if (mbd != null) { mbd.isFactoryBean = true; } else { // 4.如果mbd为空,则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例 object = getCachedObjectForFactoryBean(beanName); } if (object == null) { // Return bean instance from factory. // 5.只有beanInstance是FactoryBean才能走到这边,因此直接强转 FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // Caches object obtained from FactoryBean if it is a singleton. if (mbd == null && containsBeanDefinition(beanName)) { // 6.mbd为空,但是该bean的BeanDefinition在缓存中存在,则获取该bean的MergedBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); } // 7.mbd是否是合成的(这个字段比较复杂,mbd正常情况都不是合成的,也就是false,有兴趣的可以自己查阅资料看看) boolean synthetic = (mbd != null && mbd.isSynthetic()); // 8.从FactoryBean获取对象实例 object = getObjectFromFactoryBean(factory, beanName, !synthetic); } // 9.返回对象实例 return object; } }

getObjectFromFactoryBean

从FactoryBean获取对象实例

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry { protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { // 1.如果是单例,并且已经存在于单例对象缓存中 if (factory.isSingleton() && containsSingleton(beanName)) { //又见双重检查锁机制,尝试再从缓存中获取,防止多线程下可能有别的线程已完成该单例Bean的创建 synchronized (getSingletonMutex()) { // 2.从FactoryBean创建的单例对象的缓存中获取该bean实例 Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { // 3.调用FactoryBean的getObject方法获取对象实例 object = doGetObjectFromFactoryBean(factory, beanName); // Only post-process and store if not put there already during getObject() call above // (e.g. because of circular reference processing triggered by custom getBean calls) Object alreadyThere = this.factoryBeanObjectCache.get(beanName); // 4.如果该beanName已经在缓存中存在,则将object替换成缓存中的 if (alreadyThere != null) { object = alreadyThere; } else { if (shouldPostProcess) { if (isSingletonCurrentlyInCreation(beanName)) { // Temporarily return non-post-processed object, not storing it yet.. return object; } beforeSingletonCreation(beanName); try { // 5.对bean实例进行后置处理,执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法 //触发BeanPostProcessor,第三方框架可以在此用AOP来包装Bean实例 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex); } finally { //创建完成后,从缓存锁定的名字里清除 afterSingletonCreation(beanName); } } if (containsSingleton(beanName)) { // 6.将beanName和object放到factoryBeanObjectCache缓存中 this.factoryBeanObjectCache.put(beanName, object); } } } // 7.返回object对象实例 return object; } } else { // 8.调用FactoryBean的getObject方法获取对象实例 Object object = doGetObjectFromFactoryBean(factory, beanName); if (shouldPostProcess) { try { // 9.对bean实例进行后置处理,执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex); } } // 10.返回object对象实例 return object; } } }

主要步骤:

  • 调用 FactoryBean 的 getObject 方法获取对象实例。

  • 对 bean 实例进行后续处理,执行所有已注册的 BeanPostProcessor 的 postProcessAfterInitialization 方法。

doGetObjectFromFactoryBean

用FactoryBean的getObject方法获取对象实例

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry { private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) throws BeanCreationException { Object object; try { // 1.调用FactoryBean的getObject方法获取bean对象实例 if (System.getSecurityManager() != null) { AccessControlContext acc = getAccessControlContext(); try { // 1.1 带有权限验证的 object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { // 1.2 不带权限 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. // 2.getObject返回的是空值,并且该FactoryBean正在初始化中,则直接抛异常, // 不接受一个尚未完全初始化的FactoryBean的getObject返回的空值 if (object == null) { if (isSingletonCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException( beanName, "FactoryBean which is currently in creation returned null from getObject"); } object = new NullBean(); } // 3.返回创建好的bean对象实例 return object; } }

很简单的方法,就是直接调用 FactoryBean 的 getObject 方法来获取到对象实例。

 

细心的同学可以发现,该方法是以 do 开头,以 do 开头的方法是最终进行实际操作的方法,例如本方法就是 FactoryBean 最终实际进行创建 bean 对象实例的方法。

postProcessObjectFromFactoryBean

对bean实例进行后置处理,执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { @Override protected Object postProcessObjectFromFactoryBean(Object object, String beanName) { return applyBeanPostProcessorsAfterInitialization(object, beanName); } @Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException { Object result = existingBean; // 1.遍历所有注册的BeanPostProcessor实现类,调用postProcessAfterInitialization方法 for (BeanPostProcessor processor : getBeanPostProcessors()) { // 2.在bean初始化后,调用postProcessAfterInitialization方法 Object current = processor.postProcessAfterInitialization(result, beanName); if (current == null) { // 3.如果返回null,则不会调用后续的BeanPostProcessors return result; } result = current; } return result; } }

这边走的是 AbstractAutowireCapableBeanFactory 里的方法。通过前面的介绍,我们知道创建的 BeanFactory 为 DefaultListableBeanFactory,而 DefaultListableBeanFactory 继承了 AbstractAutowireCapableBeanFactory,因此这边会走 AbstractAutowireCapableBeanFactory 的重写方法。

 

在registerBeanPostProcessors 详解 中已经学过 BeanPostProcessor,在创建完 bean 实例后,会执行 BeanPostProcessor 的 postProcessAfterInitialization 方法。

markBeanAsCreated

如果不是仅仅做类型检测,而是创建bean实例,这里要将beanName放到alreadyCreated缓存

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { protected void markBeanAsCreated(String beanName) { if (!this.alreadyCreated.contains(beanName)) { synchronized (this.mergedBeanDefinitions) { // 1.如果alreadyCreated缓存中不包含beanName if (!this.alreadyCreated.contains(beanName)) { // Let the bean definition get re-merged now that we're actually creating // the bean... just in case some of its metadata changed in the meantime. // 2.将beanName的MergedBeanDefinition从mergedBeanDefinitions缓存中移除, // 在之后重新获取MergedBeanDefinition,避免BeanDefinition在创建过程中发生变化 clearMergedBeanDefinition(beanName); // 3.将beanName添加到alreadyCreated缓存中,代表该beanName的bean实例已经创建(或即将创建) this.alreadyCreated.add(beanName); } } } } protected void clearMergedBeanDefinition(String beanName) { RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName); if (bd != null) { bd.stale = true; } } }

这边会将 beanName 对应的 MergedBeanDefinition 移除,然后在之后的代码重新获取,主要是为了使用最新的 MergedBeanDefinition 来进行创建操作。

isDependent

检查dep是否依赖于beanName,即检查是否存在循环依赖

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { /** Map between dependent bean names: bean name to Set of dependent bean names. */ //dependentBeanMap(被依赖关系:key被value所依赖) private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64); protected boolean isDependent(String beanName, String dependentBeanName) { synchronized (this.dependentBeanMap) { return isDependent(beanName, dependentBeanName, null); } } private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) { // 已经检查过的直接跳过 if (alreadySeen != null && alreadySeen.contains(beanName)) { return false; } // 1.将别名解析为真正的名称 String canonicalName = canonicalName(beanName); // 2.拿到依赖canonicalName的beanName集合 Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName); // 3.如果dependentBeans为空,则两者必然还未确定依赖关系,返回false if (dependentBeans == null) { return false; } // 4.如果dependentBeans包含dependentBeanName,则表示两者已确定依赖关系,返回true if (dependentBeans.contains(dependentBeanName)) { return true; } // 5.循环检查,即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的(即隔层依赖) for (String transitiveDependency : dependentBeans) { if (alreadySeen == null) { alreadySeen = new HashSet<>(); } // 6.已经检查过的添加到alreadySeen,避免重复检查 alreadySeen.add(beanName); if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { return true; } } return false; } }

这边引入了一个缓存 dependentBeanMap:beanName -> 所有依赖 beanName 对应的 bean 的 beanName 集合。内容比较简单,就是检查依赖 beanName 的集合中是否包含 dependentBeanName,隔层依赖也算。例如:A 依赖了 B,B 依赖了 C,则 A 也算依赖了 C。

registerDependentBean

将dep和beanName的依赖关系注册到缓存中

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { /** Map between dependent bean names: bean name to Set of dependent bean names. */ //dependentBeanMap(被依赖关系:key被value所依赖) private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64); /** Map between depending bean names: bean name to Set of bean names for the bean's dependencies. */ //依赖关系:key依赖于value private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64); public void registerDependentBean(String beanName, String dependentBeanName) { // 1.解析别名 String canonicalName = canonicalName(beanName); // computeIfAbsent:若key对应的value为空,会将第二个参数的返回值存入并返回 //dependentBeanMap中存放着当前Bean被引用的Bean的集合 //比如当前需要实例化的是Bean的名字是userInfo,userInfo中有个Human类型的属性human, // 那么就有human被userInfo引用的关系 human=[userInfo] synchronized (this.dependentBeanMap) { //dependenciesForBeanMap中存放的是当前Bean所依赖的Bean的集合 Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8)); // 3.如果dependentBeans包含dependentBeanName,则表示依赖关系已经存在,直接返回 if (!dependentBeans.add(dependentBeanName)) { return; } } // 4.如果依赖关系还没有注册,则将两者的关系注册到dependentBeanMap和dependenciesForBeanMap缓存 synchronized (this.dependenciesForBeanMap) { Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8)); dependenciesForBean.add(canonicalName); } } }

这边又引入了一个跟 dependentBeanMap 类似的缓存,dependenciesForBeanMap:beanName -> beanName 对应的 bean 依赖的所有 bean 的 beanName 集合。

 

这两个缓存很容易搞混,举个简单例子:例如 B 依赖了 A,则 dependentBeanMap 缓存中应该存放一对映射:其中 key 为 A,value 为含有 B 的 Set;而 dependenciesForBeanMap 缓存中也应该存放一对映射:其中 key 为:B,value 为含有 A 的 Set。

getSingleton

scope为singleton的bean创建(新建了一个ObjectFactory,并且重写了getObject方法)

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); // 1.加锁,避免重复创建单例对象 synchronized (this.singletonObjects) { // 2.首先检查beanName对应的bean实例是否在缓存中存在,如果已经存在,则直接返回 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { // 3.beanName对应的bean实例不存在于缓存中,则进行Bean的创建 if (this.singletonsCurrentlyInDestruction) { // 4.当bean工厂的单例处于destruction状态时,不允许进行单例bean创建,抛出异常 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 + "'"); } // 5.创建单例前的操作 beforeSingletonCreation(beanName); boolean newSingleton = false; // suppressedExceptions用于记录异常相关信息 boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { // 6.执行singletonFactory的getObject方法获取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; } // 7.创建单例后的操作 afterSingletonCreation(beanName); } if (newSingleton) { // 8.如果是新的单例对象,将beanName和对应的bean实例添加到缓存中(singletonObjects、registeredSingletons) addSingleton(beanName, singletonObject); } } // 9.返回创建出来的单例对象 return singletonObject; } } }

beforeSingletonCreation、afterSingletonCreation

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { protected void beforeSingletonCreation(String beanName) { // 先校验beanName是否为要在创建检查排除掉的(inCreationCheckExclusions缓存),如果不是, // 则将beanName加入到正在创建bean的缓存中(Set),如果beanName已经存在于该缓存,会返回false抛出异常(这种情况出现在构造器的循环依赖) if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } } protected void afterSingletonCreation(String beanName) { // 先校验beanName是否为要在创建检查排除掉的(inCreationCheckExclusions缓存),如果不是, // 则将beanName从正在创建bean的缓存中(Set)移除,如果beanName不存在于该缓存,会返回false抛出异常 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } } }

inCreationCheckExclusions 是要在创建检查排除掉的 beanName 集合,正常为空,可以不管。这边主要是引入了 singletonsCurrentlyInCreation 缓存:当前正在创建的 bean 的 beanName 集合。在 beforeSingletonCreation 方法中,通过添加 beanName 到该缓存,可以预防出现构造器循环依赖的情况。

 

为什么无法解决构造器循环依赖? 我们之前在之前的三层缓存提过,getSingleton 方法是解决循环引用的核心代码。解决逻辑的第一句话:“我们先用构造函数创建一个 “不完整” 的 bean 实例”,从这句话可以看出,构造器循环依赖是无法解决的,因为当构造器出现循环依赖,我们连 “不完整” 的 bean 实例都构建不出来。Spring 能解决的循环依赖有:通过 setter 注入的循环依赖、通过属性注入的循环依赖。

addSingleton

如果是新的单例对象,将beanName和对应的bean实例添加到缓存中(singletonObjects、registeredSingletons)

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { /** * Add the given singleton object to the singleton cache of this factory. * <p>To be called for eager registration of singletons. * 添加给定单例对象到工厂的单例缓存中 * 用来被提早注册的单例调用 * @param beanName the name of the bean * @param singletonObject the singleton object */ protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { //singletonObjects是一个ConcurrentHashMap // 1.添加到单例对象缓存,用来缓存单例对象,Bean实例完成创建之后,只保留一级缓存以及注册beanName的顺序,其余的清除 this.singletonObjects.put(beanName, singletonObject); //singletonFactories是一个HashMap // 2.将单例工厂缓存移除(已经不需要)里面缓存着单例工厂 this.singletonFactories.remove(beanName); //earlySingletonObjects是一个HashMap // 3.将早期单例对象缓存移除(已经不需要) this.earlySingletonObjects.remove(beanName); //registeredSingletons是一个LinkedHashSet // 4.添加到已经注册的单例对象缓存,被注册单例的集合,以注册的顺序包含着bean name this.registeredSingletons.add(beanName); } } }

beforePrototypeCreation、afterPrototypeCreation

  • beforePrototypeCreation:创建实例前的操作(将beanName保存到prototypesCurrentlyInCreation缓存中)

  • afterPrototypeCreation:创建实例后的操作(将创建完的beanName从prototypesCurrentlyInCreation缓存中移除)

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { protected void beforePrototypeCreation(String beanName) { // 1.拿到当前线程中正在创建的prototype的bean的beanName集合 Object curVal = this.prototypesCurrentlyInCreation.get(); // 2.如果为空,则将ThreadLocal设置成当前的beanName if (curVal == null) { this.prototypesCurrentlyInCreation.set(beanName); } // 3.如果不为空,并且是String类型,则代表目前只有一个beanName,将之前和当前的一起封装成Set<String>,设置到ThreadLocal中 else if (curVal instanceof String) { Set<String> beanNameSet = new HashSet<>(2); beanNameSet.add((String) curVal); beanNameSet.add(beanName); this.prototypesCurrentlyInCreation.set(beanNameSet); } // 4.如果不为空,并且不是String,则必然是Set<String>类型,将当前的beanName加到Set中去 else { Set<String> beanNameSet = (Set<String>) curVal; beanNameSet.add(beanName); } } protected void afterPrototypeCreation(String beanName) { // 1.拿到当前线程中正在创建的prototype的bean的beanName集合 Object curVal = this.prototypesCurrentlyInCreation.get(); // 2.如果是String类型,则代表目前只有一个beanName,则直接移除 if (curVal instanceof String) { this.prototypesCurrentlyInCreation.remove(); } else if (curVal instanceof Set) { // 3.如果是Set类型,则从Set从移除beanName Set<String> beanNameSet = (Set<String>) curVal; beanNameSet.remove(beanName); if (beanNameSet.isEmpty()) { this.prototypesCurrentlyInCreation.remove(); } } } }

该方法主要是在进行 bean 实例的创建前,将 beanName 添加到 prototypesCurrentlyInCreation 缓存;bean 实例创建后,将 beanName 从 prototypesCurrentlyInCreation 缓存中移除。这边 prototypesCurrentlyInCreation 存放的类型为 Object,在只有一个 beanName 的时候,直接存该 beanName,也就是 String 类型;当有多个 beanName 时,转成 Set 来存放。

总结:

本文介绍了获取 bean 实例的大部分内容,包括先从缓存中检查、 FactoryBean 的 bean 创建、实例化自己的依赖(depend-on 属性)、创建 bean 实例的前后一些标记等,在下篇文章中,将解析创建 bean 的内容。

 

参考: https://zhuanlan.zhihu.com/p/83489878

网友评论