Spring IOC实现原理笔记（三） -- 加载bean实例

本篇分析Spring如何加载bean的实例，
从ClassPathXmlApplicationContext的getBean开始分析

//抽象方法
Object getBean(String var1) throws BeansException;

public Object getBean(String name) throws BeansException {
    this.assertBeanFactoryActive();
    return this.getBeanFactory().getBean(name);
}

会进入BeanFactory接口的getBean，根据继承图找到AbstractApplicationContext的getBean方法

上篇文章Spring IOC实现原理笔记（二） – 加载XML配置提过，ClassPathXmlApplicationContext中的BeanFactory成员实际是DefaultListableBeanFactory

public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
    final String beanName = this.transformedBeanName(name);
    //【标记1】尝试获取
    Object sharedInstance = this.getSingleton(beanName);//
    Object bean;
    if(sharedInstance != null && args == null) {
        ...
//返回对应的实例，有时候存在诸如BeanFactory的情况并不是直接返回实例本身   
//而是返回指定方法返回的实例
        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
    } else {
//原型模式（Prototype）下存在循环依赖，不能解决（因为原型模式是直接创建新的实例的）
        if(this.isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        ...如果父BeanFactory不为空，并且当前没有相应bean的  
BeanDefinition，那就交由父BeanFactory加载bean,并返回。

        if(!typeCheckOnly) {
            this.markBeanAsCreated(beanName);//标志当前bean已经创建
        }
        try {
//将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition
            final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
            this.checkMergedBeanDefinition(mbd, beanName, args);
            String[] dependsOn = mbd.getDependsOn();
            String[] var11;
            if(dependsOn != null) {
                for(String dependsOnBean:dependsOn) {
                    String dependsOnBean = var11[var13];
                    if(this.isDependent(beanName, dependsOnBean)) {
                        ...说明有循环依赖，要报异常（构造方法注入循环依赖）
                    }
        //这里记录要创建的依赖的bean，用于循环依赖检测
                    this.registerDependentBean(dependsOnBean, beanName);
        //递归实例化依赖的bean
                    this.getBean(dependsOnBean);
                }
            }

            if(mbd.isSingleton()) {//单例模式
                //【标记2】
                sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                    public Object getObject() throws BeansException {
                        try {
                            //【标记3】
                            return this.createBean(beanName, mbd, args);//真正创建实例
                        } catch (BeansException var2) {
                            this.destroySingleton(beanName);
                            throw var2;
                        }
                    }
                });
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else ...省略其他模式
        } catch (BeansException var23) {
            this.cleanupAfterBeanCreationFailure(beanName);
            throw var23;
        }
    }
    if(requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
//对应类型的转换
            return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            ...
    } else {
        return bean;
    }
}

获取bean实例时,首先尝试获取单例（对应上面【标记1】）

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//尝试从缓存池中获取
    Object singletonObject = this.singletonObjects.get(beanName);
    if(singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
//获取不到，但正在创建
        synchronized(this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
//如果此bean不是正在加载且允许提前引用
            if(singletonObject == null && allowEarlyReference) {
    //当某些方法需要提前初始化的时候，会调用addSingletonFactory方法，  
    //将对应的ObjectFactory初始化策略存储在singletonFactories
                ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                if(singletonFactory != null) {
        //调用预设定的getObject方法
                    singletonObject = singletonFactory.getObject();
        //记录缓存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject != NULL_OBJECT?singletonObject:null;
}

获取单例bean:（对应【标记2】）

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    ...
    synchronized(this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if(singletonObject == null) {
...
//把beanName放入singletonsCurrentlyInCreation
            this.beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = this.suppressedExceptions == null;
            if(recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet();
            }
            try {
    //调用工厂的getObject方法获取实例
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch ...
            } finally {
                ...
    //把beanName从singletonsCurrentlyInCreation移除
                this.afterSingletonCreation(beanName);
            }
            if(newSingleton) {
                this.addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject != NULL_OBJECT?singletonObject:null;
    }
}
//把beanName缓存到singletonsCurrentlyInCreation，对应的isSingletonCurrentlyInCreation方法会返回true
protected void beforeSingletonCreation(String beanName) {
    if(!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}
//把beanName从singletonsCurrentlyInCreation移除
protected void afterSingletonCreation(String beanName) {
    if(!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

ObjectFactory工厂的getObject方法实现调用的是createBean方法(对应【标记3】)

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    ...
    RootBeanDefinition mbdToUse = mbd;
    Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if(resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    ...
    //验证及准备覆盖的方法
        mbdToUse.prepareMethodOverrides();
    ...
    Object beanInstance;
    ...
//给BeanPostProcessors（需要是InstantiationAwareBeanPostProcessor的实例）机会返回代理来代替真正的实例(AOP实现就用这)
        beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        if(beanInstance != null) {
            return beanInstance;
        }
    ...
    //真正创建bean实例
    beanInstance = this.doCreateBean(beanName, mbdToUse, args);
    ...
    return beanInstance;
}

真正创建bean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) {
    BeanWrapper instanceWrapper = null;
    if(mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }
    if(instanceWrapper == null) {
//【标记4】根据指定bean使用对应的策略创建新的实例，如工厂方法，构造函数自动注入，简单初始化
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper != null?instanceWrapper.getWrappedInstance():null;
    Class<?> beanType = instanceWrapper != null?instanceWrapper.getWrappedClass():null;
    synchronized(mbd.postProcessingLock) {
        if(!mbd.postProcessed) {
//应用MergedBeanDefinitionPostProcessor
            this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }
//是否需要提早曝光:单例&允许循环依赖&当前bean正在创建中，检查循环依赖
    boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
    if(earlySingletonExposure) {
        ...
//为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory工厂加入工厂
        this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
            public Object getObject() throws BeansException {
//对bean再一次依赖应用，主要应用SmartInstantiationAwareBeanPostProcessor
//AOP就是在这里将advice动态织入bean中，没有就直接返回bean，不做处理
                return this.getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }
    Object exposedObject = bean;
    try {
//【标记5】对bean进行填充，将各个属性值注入，其中可能存在依赖于其他bean的属性，则会递归初始依赖的bean
        this.populateBean(beanName, mbd, instanceWrapper);
        if(exposedObject != null) {
//【标记6】调用初始化方法，如init-method，InitializingBean的afterPropertiesSet
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        }
    } catch...
    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);
                for(String dependentBean:dependentBeans) {
        //检测依赖,bean实例化后，其依赖的bean也需要被实例化
                    if(!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if(!actualDependentBeans.isEmpty()) {
                    ...存在循环依赖
                }
            }
        }
    }

    try {
        //根据scope注册bean
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    } catch ...
}

单例的循环依赖解决：如果是在构造函数循环依赖那解决不了；如果是通过setter方法的循环依赖，那会调addSingletonFactory加入一个ObjectFactory,其getObject实现会返回一个实例引用来解决循环依赖

根据指定bean使用对应的策略创建新的实例（对应【标记4】）

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if(beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        ...非公开类
    } else if(mbd.getFactoryMethodName() != null) {
//如果工厂方法不为空则使用工厂方法初始化策略
        return this.instantiateUsingFactoryMethod(beanName, mbd, args);
    } else {
        boolean resolved = false;
        boolean autowireNecessary = false;
        if(args == null) {
            synchronized(mbd.constructorArgumentLock) {
    //一个类有多个构造函数，每个构造函数都有不同的参数，所以调用前根据参数锁定构造函数或对应的工厂方法
                if(mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
//如果已经解析过则使用解析好的构造函数
        if(resolved) {
//autowireNecessary为true则用构造函数自动注入，否则使用默认构造函数构造
            return autowireNecessary?this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null):this.instantiateBean(beanName, mbd);
        } else {
//根据参数解析构造函数
            Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
//ctors为空就用默认构造函数，否则使用用构造函数自动注入
            return ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)?this.instantiateBean(beanName, mbd):this.autowireConstructor(beanName, mbd, ctors, args);
        }
    }
}

根据参数解析构造函数逻辑很复杂，因为有很多不确定性；而使用默认构造方法实例化则会分两种情况：第一种,beanDefinition的getMethodOverrides方法返回空（即没有使用replace或lookup配置），那就直接使用反射。第二种，使用CGlib进行动态代理，覆盖或动态替换方法

上面实例化的bean，接着就是对bean进行属性填充，看populateBean方法（对用【标记5】）

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();
    if(bw == null) {
        if(!((PropertyValues)pvs).isEmpty()) {
            ...空对象不能填充属性
        }
    } else {
//给InstantiationAwareBeanPostProcessors最后一次机会在属性设置前改变bean
        boolean continueWithPropertyPopulation = true;
        if(!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Iterator it = this.getBeanPostProcessors().iterator();
            while(it.hasNext()) {
                BeanPostProcessor bp = (BeanPostProcessor)it.next();
                if(bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                    if(!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }
//continueWithPropertyPopulation为true，说明InstantiationAwareBeanPostProcessors没有中断属性注入
        if(continueWithPropertyPopulation) {
            if(mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
                MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
    //根据名称自动注入
                if(mbd.getResolvedAutowireMode() == 1) {
                    this.autowireByName(beanName, mbd, bw, newPvs);
                }
    //根据类型自动注入
                if(mbd.getResolvedAutowireMode() == 2) {
                    this.autowireByType(beanName, mbd, bw, newPvs);
                }
                pvs = newPvs;
            }
            boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
//依赖检查
            boolean needsDepCheck = mbd.getDependencyCheck() != 0;
            if(hasInstAwareBpps || needsDepCheck) {
//调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
                PropertyDescriptor[] filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                if(hasInstAwareBpps) {
                    Iterator it = this.getBeanPostProcessors().iterator();
                    while(it.hasNext()) {
                        BeanPostProcessor bp = (BeanPostProcessor)it.next();
                        if(bp instanceof InstantiationAwareBeanPostProcessor) {
                            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                            pvs = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                            if(pvs == null) {
                                return;
                            }
                        }
                    }
                }
                if(needsDepCheck) {
                    this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
                }
            }
//将属性应用到bean中
            this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
        }
    }
}

填充好bean的属性后，会调用initializeBean方法会对各种aware等接口进行调用（对应【标记6】）

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    ...
    this.invokeAwareMethods(beanName, bean);
    Object wrappedBean = bean;
    if(mbd == null || !mbd.isSynthetic()) {
//调用BeanPostProcessors的postProcessBeforeInitialization
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    }
    try {
//调用init-method，InitializingBean的afterPropertiesSet
        this.invokeInitMethods(beanName, wrappedBean, mbd);
    } catch...
    if(mbd == null || !mbd.isSynthetic()) {
//调用BeanPostProcessors的postProcessAfterInitialization
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

Spring IOC实现原理笔记（一）这篇中的例子输出结果可以在从上面里验证了

大致总结bean实例的加载流程：

• 尝试从单例缓存池中取，成功的话返回进行实际需要的实例（如在beanName前加&可以得到该bean的beanFactory）
• 单例缓存池取不到则进行实例化，需要判断能否解决循环引用，不同的scope不同地生命周期。
• 进行实例化前，如果工厂方法不为空则使用工厂方法初始化策略；否则可以通过InstantiationAwareBeanPostProcessor来实例化（AOP借此实现），如果InstantiationAwareBeanPostProcessor返回实例化对象不为空那就直接返回。
• InstantiationAwareBeanPostProcessor没返回实例，则继续进行bean实例操作，解析构造函数，用其进行反射实例化或CGlib代理实例化
• 实例化后，对实例进行属性填充，填充前还会最后一次交由InstantiationAwareBeanPostProcessor决定是否继续填充，
• 填充完属性，还会让InstantiationAwareBeanPostProcessor进行属性检验，接着就进行对各种Aware接口，init-method等进行调用
• 最后注册DisposeableBean，用户可通过配置属性destroy-method方法后之策后处理器DestructAwareBeanPostProcessor来统一处理bean的销毁方法

参考：

Spring源码（4.2.2.RELEASE）

《Spring源码深度解析》