SpringIoc源码（十七）- BeanFactory（六）- getBean（doCreateBean总览）

目录

1、doCreateBean总览

2、将BeanDefinition转化为BeanWrapper

3、MergedBeanDefinitionPostProcessor回调

4、循环依赖实现

5、循环依赖检查

6、注册DisposableBean

---

1、doCreateBean总览

    继续doCreateBean方法，经历了大致一下步骤（核心步骤（红色部分）后面专门分析）：

    1、单利模式需要清除factoryBeanInstanceCache缓存（FactoryBean名称与BeanWrapper关系缓存）

    2、实例化Bean，将BeanDefinition转化为BeanWrapper（装饰器模式）

    3、允许MergedBeanDefinitionPostProcessor修改merged后的BeanDefinition

    4、依赖处理（循环依赖处理）

    5、属性填充（名称和类型）

    6、实例化方法回调（生命周期）

    7、循环依赖检查（下面删除了try catch异常）

    8、注册DisposableBean（销毁回调）

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {
    // Instantiate the bean.（装饰器模式）
    BeanWrapper instanceWrapper = null;
    // 单利模式清楚缓存
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // 实例化，将BeanDefinition转换为BeanWrapper
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // 允许MergedBeanDefinitionPostProcessor修改merged后的BeanDefinition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            // 回调MergedBeanDefinitionPostProcessor
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    // 核心步骤-填充属性
    populateBean(beanName, mbd, instanceWrapper);
    // 核心步骤-初始化Bean实例
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    // 循环以来检查
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
            }
        }
    }
    // 注册disposable（实现了DisposableBean接口）
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
    return exposedObject;
}

2、MergedBeanDefinitionPostProcessor回调

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof MergedBeanDefinitionPostProcessor) {
            MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
            bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
        }
    }
}

    回调比较简单，拿到所有的BeanPostProcess，如果为MergedBeanDefinitionPostProcessor类型则回调postProcessMergedBeanDefinition方法。意义在与允许对merged后的BeanDefinition进行修改（处理）。@Autowired、@Resource等注解都在这里实现（详细可以参见：Spring源码 - @Resource原理分析（CommonAnnotationBeanPostProcessor）），非常的重要，实现了的子类有：

3、循环依赖实现

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

    依赖注入概念：就是A在getBean初始化时，如果依赖了另一个bean B，那么会先去调用B的getBean初始化B。但是B再去getBean时又依赖A。那么就出现了死循环。Spring按照域（Scope）进行处理，如果是非单利模式则抛出异常。

    虽然只有短短的几行代码，但是这是单利模式循环依赖的实现。上面判断了三个条件：

    1、当前Bean为单利Scope

    2、容器级别的allowCircularReferences（是否允许循环依赖），默认为true

    3、当前Bean是否标记为正在创建中，存放在（singletonsCurrentlyInCreation容器中）

按照上面的例子分析，当A初始化时，依赖注入了B。就把A自己提前暴露为创建中，那么当前为B的初始化到这一步时，检查当前B为单利，并且容器级别允许循环依赖，并且把B自己也标记为正在创建的容器中。那么执行下面的操作，将B执行下面的getEarlyBeanReference方法初始化一个单利工厂：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

    如果有SmartInstantiationAwareBeanPostProcessor类型处理，则返回处理后的Bean，否则返回原来的Bean。Aop就是在这里将createBeanInstance创建的对象包装返回代理对象。

addSingletonFactory方法操作，处理工厂和Bean名称关系：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

    1、将当前B的Bean名称和单利工厂

    2、将提前暴露的B，从提前暴露容器（earlySingletonObjects）中移除

    3、把当前的Bean名称标记为已创建，放入容器（registeredSingletons）中

 

4、循环依赖检查

if (earlySingletonExposure) {
    Object earlySingletonReference = getSingleton(beanName, false);
    // 只有循环依赖时当前才不为空
    if (earlySingletonReference != null) {
        if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
        }
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
                if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                    actualDependentBeans.add(dependentBean);
                }
            }
            if (!actualDependentBeans.isEmpty()) {
                throw new BeanCurrentlyInCreationException(beanName, "省略");
            }
        }
    }
}

    在上面的getEarlyBeanReference方法时，调用了SmartInstantiationAwareBeanPostProcessor的处理，比如AsjectJ类型Aop的AnnotationAwareAspectJAutoProxyCreator的回调，创建返回的是代理对象。则会将代理对象赋值给当前对象返回。

 

5、注册DisposableBean

registerDisposableBeanIfNecessary(beanName, bean, mbd);

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        if (mbd.isSingleton()) {
            // Register a DisposableBean implementation that performs all destruction
            // work for the given bean: DestructionAwareBeanPostProcessors,
            // DisposableBean interface, custom destroy method.
            registerDisposableBean(beanName,
                    new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
        // 省略非单利
    }
}

    其中registerDisposableBean比较简单，将关系放入DefaultSingletonBeanRegistry的disposableBeans中即可：

public void registerDisposableBean(String beanName, DisposableBean bean) {
    synchronized (this.disposableBeans) {
        this.disposableBeans.put(beanName, bean);
    }
}

    我们可以直接在Bean上实现DisposableBean接口接口实现销毁时回调。但是Spring为我们注入的确是适配器模式的DisposableBeanAdapter类型，很多时候销毁回调也需要处理容器级别的销毁。所以讲所以BeanPostProcess都进行传入调用filterPostProcessors方法将销毁时候关注的DestructionAwareBeanPostProcessor类型放入容器beanPostProcessors中。

public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
                             List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
    this.bean = bean;
    this.beanName = beanName;
    this.invokeDisposableBean =
            (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
    this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
    this.acc = acc;
    String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
    if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
            !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
        this.destroyMethodName = destroyMethodName;
        Method destroyMethod = determineDestroyMethod(destroyMethodName);
        if (destroyMethod == null) {
            if (beanDefinition.isEnforceDestroyMethod()) {
                throw new BeanDefinitionValidationException("省略");
            }
        }
        else {
            Class<?>[] paramTypes = destroyMethod.getParameterTypes();
            if (paramTypes.length > 1) {
                throw new BeanDefinitionValidationException("省略");
            }
            else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) {
                throw new BeanDefinitionValidationException("省略");
            }
            destroyMethod = ClassUtils.getInterfaceMethodIfPossible(destroyMethod);
        }
        this.destroyMethod = destroyMethod;
    }
    this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
}

        filterPostProcessors方法如下：

private List<DestructionAwareBeanPostProcessor> filterPostProcessors(List<BeanPostProcessor> processors, Object bean) {
    List<DestructionAwareBeanPostProcessor> filteredPostProcessors = null;
    if (!CollectionUtils.isEmpty(processors)) {
        filteredPostProcessors = new ArrayList<>(processors.size());
        for (BeanPostProcessor processor : processors) {
            if (processor instanceof DestructionAwareBeanPostProcessor) {
                DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
                if (dabpp.requiresDestruction(bean)) {
                    filteredPostProcessors.add(dabpp);
                }
            }
        }
    }
    return filteredPostProcessors;
}

    实现的子类有：