Spring Bean生命周期-createBean(十一)

不管是何种类型的bean，最终都要通过createBean方法来创建，处理，createBean方法可以说是beanFactory最重要的方法之一，其实现在AbstractAutowireCapableBeanFactory类中。

创建bean实例，计算bean实例，post-processors处理等等。

分析

1. createBean创建bean的时候调用的是doCreateBean方法。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {        // Instantiate the bean.
        // 实例化bean 
        BeanWrapper instanceWrapper = null;        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);        // Allow post-processors to modify the merged bean definition.
        // 使用post-processors修改bean difinition，获取类型MergedBeanDefinitionPostProcessor的PostProcessor调用postProcessMergedBeanDefinition方法。
        synchronized (mbd.postProcessingLock) {            if (!mbd.postProcessed) {
                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) {            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, new ObjectFactory<Object>() {                @Override
                public Object getObject() throws BeansException {                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }        // Initialize the bean instance.
        // 将刚才获取的beanInstance指向exposedObject。
        Object exposedObject = bean;        try {
            populateBean(beanName, mbd, instanceWrapper);            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }        catch (Throwable ex) {            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {                throw (BeanCreationException) ex;
            }            else {                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }        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<String>(dependentBeans.length);                    for (String dependentBean : dependentBeans) {                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }                    if (!actualDependentBeans.isEmpty()) {                        throw new BeanCurrentlyInCreationException(beanName,                                "Bean with name '" + beanName + "' has been injected into other beans [" +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                                "] in its raw version as part of a circular reference, but has eventually been " +                                "wrapped. This means that said other beans do not use the final version of the " +                                "bean. This is often the result of over-eager type matching - consider using " +                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }        // Register bean as disposable.
        // 如果bean实现了disposable接口，注册这些bean。
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }        catch (BeanDefinitionValidationException ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }        return exposedObject;
    }

1. 初始化bean的实例，在doCreateBean内部，创建bena之后，需要对bean做一些初始化的工作。

Object exposedObject = bean;        try {           //从bean difinition中计算bean实例的属性值
            populateBean(beanName, mbd, instanceWrapper);            if (exposedObject != null) {               //初始化bean，应用Factory 回调，init方法，和bean post processors
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }        catch (Throwable ex) {            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {                throw (BeanCreationException) ex;
            }            else {                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }        
// 初始化bean的实例       protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {                @Override
                public Object run() {
                    invokeAwareMethods(beanName, bean);                    return null;
                }
            }, getAccessControlContext());
        }        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }        catch (Throwable ex) {            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }        return wrappedBean;
    }

2.1 首先设置bean的aware，如果bean实现了Aware方法，那么依次设置

• BeanNameAware

• BeanClassLoaderAware

• BeanFactoryAware

private void invokeAwareMethods(final String beanName, final Object bean) {        if (bean instanceof Aware) {            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }            if (bean instanceof BeanClassLoaderAware) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
            }            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

2.2 调用bean的init方法。invokeInitMethods

• 如果bean实现了InitializingBean方法，或者配置的方法为afterPropertiesSet，那么调用afterPropertiesSet方法

• 如果bean的初始化方法是自定义的，那么调用自定义的初始化方法

有些bean会在调用invokeInitMethods前后使用beanPostProcessors进行postProcessBeforeInitialization，postProcessAfterInitialization处理

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
            throws Throwable {        boolean isInitializingBean = (bean instanceof InitializingBean);        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {            if (logger.isDebugEnabled()) {
                logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }            if (System.getSecurityManager() != null) {                try {
                    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                        @Override
                        public Object run() throws Exception {
                            ((InitializingBean) bean).afterPropertiesSet();                            return null;
                        }
                    }, getAccessControlContext());
                }                catch (PrivilegedActionException pae) {                    throw pae.getException();
                }
            }            else {
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

1. 注册实现了DisposableBean或者配置了销毁方法的bean

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));
            }            else {                // A bean with a custom scope...
                Scope scope = this.scopes.get(mbd.getScope());                if (scope == null) {                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName,                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
        }
    }

1. 返回bean

回顾

在创建bean，并且初始化bean的过程基本经历：

• 实例化bean，通过反射创建一个对象出来

• 设置bean的属性populateBean

• 调用initAware方法，配置一些bean的aware

• (根据条件)beanProcessor.postProcessBeforeInitialization方法

• 调用afterPropertiesSet或者自定义的其它初始化的方法

• (根据条件)beanProcessor.postProcessAfterInitialization方法

• 注册实现了销毁方法的bean，可能是实现DisposableBean接口，或者定义了销毁方法

总结

可以看到在createBean的时候，基本上完成了bean生命周期的配置，创建，初始化，注册需要销毁的bean。