（4）Bean的加载

心已赠人 2022-05-30 08:51 184阅读 0赞

![这里写图片描述][70]  
![这里写图片描述][70 1]

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;
    
        // Eagerly check singleton cache for manually registered singletons.
        /*检查缓存中或者实例工厂中是否有对应的实例 *因为在创建单例bean的时候会存在依赖注入的情况，为了避免循环引用 *Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光 *即将ObjectFactory加入到缓存之中，一旦下一个bean创建的时候需要依赖上一个bean则直接 *使用beanFactory */
        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 {
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            // 原型类型的bean是不允许循环依赖的，所以Exception
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
    
            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }
            //如果不仅仅是做类型检查，则需要进行记录
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }
    
            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);
    
                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        if (isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException("Circular depends-on relationship between '" +
                                    beanName + "' and '" + dependsOnBean + "'");
                        }
                        registerDependentBean(dependsOnBean, beanName);
                        getBean(dependsOnBean);
                    }
                }
    
                // Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                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;
                            }
                        }
                    });
                    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();
                    final Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope '" + 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;
            }
        }
    
        // Check if required type matches the type of the actual bean instance.
        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;
    }

实际的doGetBean过程很复杂，拆成步骤来分析  
1.转换对应的beanName

![这里写图片描述][70 2]  
因为这里传入的参数可能是别名，也可能是FactoryBean，所以要进行一系列的解析，解析的内容包括：  
去除FactoryBean的修饰符，也就是如果name=”&aa”,那么会首先去除&而使name=”aa”  
取置顶alias所表示的最终beanName，例如别名A指向名称为B的bean则返回B，如果A指向B，B又指向C则返回C  
  
![这里写图片描述][70 3]

2.尝试从缓存中加载bean

![这里写图片描述][70 4]  
![这里写图片描述][70 5]  
![这里写图片描述][70 6]  
默认allowEarlyReference是设置为true的  
这个的作用是为了处理singleton bean的依赖注入的情况，在创建依赖的时候为了避免循环依赖，Spring创建bean的原则是不等bean创建完成就会将创建的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时需要依赖上一个bean，则直接使用ObjectFactory

注：定义bean的时候是可以指定scope的，默认是单例

先说一下各个缓存的作用：

![这里写图片描述][70 7]  
singletonObjects:  
用于保存BeanName和创建bean实例之间的关系，bean name -> bean instance  
singletonFactories:  
用于保存BeanName和创建bean的工厂之间的关系，bean name -> ObjectFactory  
earlySingletonObjects:  
也是保存BeanName和创建bean实例之间的关系，与SingletonObjects的不同之处在于，当一个实例bean被放到这里面后，那么当bean还在创建的过程中，就可以通过getBean方法获取到了，其目的是用来检测循环引用  
registeredSingletons:  
用来保存当前所有已注册的bean

在缓存之中没有拿到bean  
![这里写图片描述][70 8]

3.Bean的实例化，如果从缓存中得到了bean的原始状态，则需要对bean进行实例化。

强调：缓存中记录的只是最原始的bean状态，并不一定是我们最终想要的bean。  
切记

![这里写图片描述][70 9]  
在getBean方法中，getObjectForBeanInstance是个高频率使用的方法，无论是从缓存中获得bean还是根据不同的scope策略加载bean。总之，得到bean的实例后要做的第一件事就是调用这个方法来检测一下正确性。  
![这里写图片描述][70 10]  
![这里写图片描述][70 11]  
![这里写图片描述][70 12]  
这里为什么会有&作为前缀？通常使用的FactoryBean也是直接用BeanName来获取的。  
当使用&作为前缀的时候表示用户想要的是直接获取FactoryBean工厂实例而不是FactoryBean.getObject()对应的实例。

处理FactoryBean

![这里写图片描述][70 13]  
先是从缓存中拿FactoryBean，如果拿不到真正的获取FactoryBean的逻辑委托给getObjectFromFactoryBean  
![这里写图片描述][70 14]  
这里还是就判定一下是否单例，是单例需要保证全局唯一，并且使用缓存。实际的创建逻辑在doGetObjectFromFactoryBean之中  
![这里写图片描述][70 15]  
终于看到了factory.getObject()  
不过在调用factory.getObject()获取bean之后并没有直接返回bean，还有下面一部分：  
![这里写图片描述][70 16]  
调用的是AbstractAutowireCapableBeanFactory之中的postProcessObjectFromFactoryBean()  
![这里写图片描述][70 17]  
![这里写图片描述][70 18]  
这里是调用了后处理器，这里可以了解Spring获取bean的规则中的一条：  
尽可能保证所有bean初始化后都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理，在实际的开发工程中大可以针对此特性设计自己的业务逻辑。

同时说一下applyBeanPostProcessorsBeforeInitialization  
![这里写图片描述][70 19]  
暂时还没有看到调用的时机

到此全部是从缓存中寻找是否有singletonbean，已经从FactoryBean之中获取bean

如果都失败了，那么进入else  
![这里写图片描述][70 20]  
只有在单例情况下才会尝试解决循环依赖，如果A依赖B，B依赖A，那么造成循环依赖，引起BeanCurrentlyInCreationException

[70]: /images/20220530/e926bb05c86349e1b17214280f5967c3.png
[70 1]: /images/20220530/1c2429f35e724d0a88d081df2ac0baac.png
[70 2]: /images/20220530/a8e71464236b4a24b904c2230b13553a.png
[70 3]: /images/20220530/0be7b694cbae43b881b67fe9494670dd.png
[70 4]: /images/20220530/6b07c28bf4ae4c50934f9d412ebeab34.png
[70 5]: /images/20220530/66e36da52874496194d85898eb764a1a.png
[70 6]: /images/20220530/1dea24313244479d85c45e6d992c57c4.png
[70 7]: /images/20220530/faaef1ecd1954bfca75f972c7a5a0e18.png
[70 8]: /images/20220530/fcf07e9fde7241218d7330c3a362b22e.png
[70 9]: /images/20220530/e473dec32ec24dadae3713365f8c7d2b.png
[70 10]: /images/20220530/0c4c85d3926b4f909d8ab23671d29b51.png
[70 11]: /images/20220530/2443d9bb3c2147d88d6bedd16484b6a0.png
[70 12]: /images/20220530/233be2cfce8c4a8a96d5c3a2c7b21fa4.png
[70 13]: /images/20220530/3ea39a897d964ed89996b186ca59d689.png
[70 14]: /images/20220530/b842f31e27f14e0684bbc815ee502490.png
[70 15]: /images/20220530/cc3048111a5d4e078afd0218b7995f5f.png
[70 16]: /images/20220530/71cf9ca5d66f4be3ae75fb4d7b5188f9.png
[70 17]: /images/20220530/7ee2922cd1ae4da9aafff6e7942ddcd3.png
[70 18]: /images/20220530/b6701930cc5c478da4fe9df1fa3763ea.png
[70 19]: /images/20220530/f46548a91ac24bfe89d71ef476f6651a.png
[70 20]: /images/20220530/9ca606bb43ef4da680469d769386ab83.png