[Spring]Spring的getBean路线-doCreateBean

前言

createBean进行了一些创建Bean实例前的工作:

• 检查当前BeanDefinition的Class是否可以被解析.
• 检查当前BeanDefinition的Lookup method是否存在，并且确认重载状态.
• 激活Bean实例化前的后置处理器.

随后，进行doCreateBean的调用.那么本文就来分析doCreateBean的代码逻辑.

doCreateBean的总体流程

• 根据当前Bean的构造策略进行实例化,此时的bean未进行依赖注入: createBeanInstance.
• 解析Bean中被Spring注解标记的成员变量,如@AutoWired、@Value、Resource: applyMergedBeanDefinitionPostProcessors.
• 判断是否要暴露早期引用的bean,为了解决循环依赖: addSingletonFactory.
• 填充bean实例属性: populateBean.
• 生命周期函数回调: initializeBean.
• 判断在循环依赖的情况下Bean的引用是否一致: allowRawInjectionDespiteWrapping
• 注册销毁方法: registerDisposableBeanIfNecessary

1. 根据当前Bean的构造策略进行实例化

在讲Bean的实例化前,需要简单了解一下什么是BeanWrapper.

1.1 BeanWrapper

JavaDoc: 提供用于分析和操作标准JavaBean的操作：获得和设置属性值（单独或批量），获取属性描述符以及查询属性的可读性/可写性的能力。
此接口支持嵌套属性，使子属性上的属性设置达到无限深度.
来看看接口清单.

public interface BeanWrapper extends ConfigurablePropertyAccessor {

    // 指定数组和集合自动增长的限制。默认不限制,即无限.
    void setAutoGrowCollectionLimit(int autoGrowCollectionLimit);

    // 返回数组和集合自动增长的限制.
    int getAutoGrowCollectionLimit();

    // 返回当前BeanWrapper包装的Bean实例
    Object getWrappedInstance();

    // 返回当前BeanWrapper包装的Bean类型-Class
    Class getWrappedClass();

    // 获取包装对象的PropertyDescriptors（由标准JavaBean自省确定）
    PropertyDescriptor[] getPropertyDescriptors();
    
    // 获取包装对象的PropertyDescriptor
    PropertyDescriptor getPropertyDescriptor(String propertyName) throws InvalidPropertyException;

}

简单来说，通过这个接口视图，可以获取Bean的信息.例如:对象实例、Class、Property.
OK，简单了解过后，我们来看看实例化Bean的第一步-createBeanInstance,调用构造函数获取一个对象实例。注意，这个对象实例并未是完整的Bean.

• AbstractAutowireCapableBeanFactory#doCreateBean

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

        // Instantiate the bean.
        // bean实例化包装类
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            // 从未完成创建的包装bean缓存中清理并获取相关的包装bean实例,单例，不可以重复
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 创建bean的方式有三种:
            // 1.Factory method 2.constructor 3. supplier
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        // 获取被包装的Bean，后续对bean的改动等于对wrapper进行改动,即对wrapper的改动也会改动bean
        Object bean = instanceWrapper.getWrappedInstance();
        // 获取实例化对象的类型
        Class beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

举例说明: 假设有一个Bean是这样定义的.

@Controller
public class HelloController {
    @Autowired
    private HelloService helloService;

    public void hello(){
        System.out.println(helloService.hello()+",this is controller");
    }
}

那么当我们getBean("helloController"),我们是希望HelloController中的helloService是被实例化的(依赖注入).这时，我们才认为这是一个完整的Bean.而createBeanInstance执行完后,仅仅是new HelloController而已,此时并未将helloService注入进来.(便于理解，其实Spring会做较为复杂的推断.)

• AbstractAutowireCapableBeanFactory#createBeanInstance

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // Make sure bean class is actually resolved at this point.
        // 获取Class对象,前面在createBean已经进行过解析了，这里会直接从mbd.getBeanClass()返回
        Class beanClass = resolveBeanClass(mbd, beanName);
        // 检查是否可以破环private的保护进行反射创建实例
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
        // 是否通过lambda的方式进行创建.在AbstractBeanDefinition中存储了此值.
        Supplier instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        // 通过工厂方法创建,factory-method
        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // Shortcut when re-creating the same bean...
        boolean resolved = false;
        boolean autowireNecessary = false;
        // 空参构造
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                // 如果已缓存的解析构造函数或者factoryMethod不为空
                // 那么可以利用构造函数解析
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            // 自动注入,调用构造函数自动注入
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                // 使用默认的构造函数构造
                return instantiateBean(beanName, mbd);
            }
        }

        // Candidate constructors for autowiring?
        // 根据参数解析确定构造函数
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        // 解析的构造器不为空 | 注入类型为AUTOWIRE_CONSTRUCTOR | 有参 | 传入的参数不为空
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            // 进行对象实例化
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // Preferred constructors for default construction?
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }

        // No special handling: simply use no-arg constructor.
        // 如果没有推断出特殊的构造方法，使用这个默认的模式
        // 无参的默认构造方法,内部使用JDK的反射.
        return instantiateBean(beanName, mbd);
    }

这里的逻辑在依赖注入概览的时候大概讲过，现在来重温一篇:

1. 获取Class对象，校验是否为public、如果不是再判断是否为可以无视private的，也就是能否获取private的授权.
2. 推断构造方法.查看BeanDefinition是否提供了类初始化的Supplier(lambda).如果提供，按照此方法进行实例化.
3. 查看BeanDefinition是否需要工厂方法进行初始化,如果是，使用factory-method进行初始化.
4. 查看BeanDefinition是否已经解析过构造方法,如果constructorArgumentsResolved为true,那么直接使用解析好的构造方法进行实例化.
5. 如果都没有，那么看看构造注入策略是否为构造注入，并且是有参的形式.如果符合.进行自动注入autowireConstructor(beanName, mbd, ctors, args)
6. 如果以上条件都不符合，那么使用默认的JDK无参构造方法-instantiateBean

• AbstractAutowireCapableBeanFactory#instantiateBean

根据初始化策略获取实例进行初始化,默认为SimpleInstantiationStrategy

    protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged(
                        (PrivilegedAction