SPRING FRAMEWORK(2) BEAN INITIALIZATION

快来打我* 2022-05-31 23:28 191阅读 0赞

## bean的加载 ##

默认情况下，bean是懒加载的，即在使用时才进行实例化。

IService xxService = (IService)bf.getBean("xxService")

在AbstractBeanFactory中定义了getBean()方法：  
![这里写图片描述][SouthEast]

public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null）
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
    
    
    protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        //提取对应的beanName
        final String beanName = this.transformedBeanName(name);
        /* *检查缓存中或者实例工厂中是否有对应的实例 *为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖， *Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光，也就是将ObjectFactory加入到缓存中，bean创建时候则直接使用ObjectFactory */
        //直接尝试从缓存获取或者singletonFactories中的ObjectFactory中获取
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if(sharedInstance != null && args == null) {
            //返回对应的实例
            //有时候返回ObjectFactory的指定方法用于生成实例
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            //只有在单例情况下才会尝试解决循环依赖，原型模式情况下，如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生当A还未创建完的时候因为B的创建再次返回创建A，造成循环依赖，也就是下面的情况
            if(this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            //如果BeanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
            if(parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String var19 = this.originalBeanName(name);
                //递归到BeanFactory中寻找
                if(args != null) {
                    return parentBeanFactory.getBean(var19, args);
                }
    
                return parentBeanFactory.getBean(var19, requiredType);
            }
            //如果不是仅仅做类型检查,则创建bean
            if(!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }
            //将存储XML配置文件转换为RootBeanDefinition，如果指定BeanName是子Bean的话同时会合并父类的相关属性
            final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
            this.checkMergedBeanDefinition(mbd, beanName, args);
            String[] dependsOn = mbd.getDependsOn();
            String scopeName;
            //若存在依赖则需要递归实例化依赖的bean
            if(dependsOn != null) {
                String[] var14 = dependsOn;
                int ex = dependsOn.length;
    
                for(int scope = 0; scope < ex; ++scope) {
                    scopeName = var14[scope];
                    this.getBean(scopeName);
                    //缓存依赖调用
                     this.registerDependentBean(scopeName, beanName);
                }
            }
        ....
         return bean;
    }

对于Spring加载bean的过程，大致分为以下几步：

*  转换对应beanName  
    这里传入的参数name不一定就是beanName，有可能是别名或FactoryBean，所以需要进行一系列的解析，这些解析内容包括如下内容
    
     *  去除FactoryBean的修饰符，也就是如果name=”&aa”，那么会首先去除&而使name=”aa”
     *  取指定alias所表示的最终beanName
 *  尝试从缓存中加载单例  
    单例在Spring的同一个容器内只会被创建一次，后续再获取bean，就直接从单例缓存中获取了。这里只是尝试加载，首先尝试从缓存中加载，如果加载不成功则再次尝试从singletonFactories中加载，因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，在Spring中创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时候需要依赖上一个bean则直接使用ObjectFactory
    
     *  bean的实例化  
        如果从缓存中得到了bean的早期early状态，则需要对bean进行实例化，这里有必要强调一下，在getSingleton方法返回可能是bean的early状态，并不一定是我们最终想要的bean。
     *  原型模式的依赖检查  
        只有在单例情况下才会尝试解决循环依赖，如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成无限循环依赖，也就是情况：isPrototypeCurrentlyInCreation(beanName)判断true

尝试从parentBeanFactory获取从代码上来看，如果缓存没有数据的话直接转到父类工厂上去加载，!this.containsBeanDefinition(beanName检测如果当前加载的XML配置文件中不包含beanName所对应的配置，就只能到parentBeanFactory去尝试，然后再去递归的调用getBean方法

*  将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition  
    因为从XML配置文件中读取到的Bean信息是存储在GernericBeanDefinition中的，但是所有的Bean后续处理都是针对于RootBeanDefinition的，所以这里需要进行一个转换，转换的同时如果父类bean不为空的话，则会一并合并父类属性
 *  寻找依赖  
    因为bean的初始化过程很可能会用到某些属性，而某些属性很可能是动态配置的，并且配置成依赖于其他的bean，那么这个时候就有必要先加载依赖的bean，所以，在Spring的加载顺寻中，在初始化某一个bean的时候首先会初始化这个bean所对应的依赖
 *  针对不同的scope进行bean的创建

在Spring中存在着不同的scope，其中默认的是singleton，但是还有些其他的配置诸如prototype、request之类的，在这个步骤中，Spring会根据不同的配置进行不同的初始化策略

*  类型转换

程序到这里返回bean后已经基本结束了，通常对该方法的调用参数requiredType是为空的，但是可能会存在这样的情况，返回的bean其实是个String，但是requiredType却传入Integer类型，那么这时候本步骤就会起作用了，它的功能是将返回的bean转换为requiredType所指定的类型，当然，Spring转换为Integer是最简单的一种转换，在Spring中提供了各种各样的转换器，用户也可以自己扩展转换器来满足需求。

[SouthEast]: /images/20220601/4ae4c3bfaf7b4022be5b5f71b3da6383.png