Spring-IOC加载Bean【七】bean对象的实例化准备

不管是单例还是原型模式，bean原始实例都是通过createBean方法创建，在AbstractBeanFactory中，createBean是一个抽象方法：

//为给定的合并bean定义(和参数)创建bean实例。对于子定义，bean定义已经与父定义合并。所有bean检索方法都将委托给该方法进行实际的bean创建。
    protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException;

该方法的默认实现在AbstractAutowireCapableBeanFactory中定义。

//该类的中心方法:创建bean实例、填充bean实例、应用后处理程序等。
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        if (logger.isTraceEnabled()) {
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;

        // 确保此时bean类已实际解析，并克隆bean定义，
        // 以防无法在共享合并bean定义中存储动态解析的类。
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // 准备方法覆盖。
        try {
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            // 让BeanPostProcessors有机会返回代理而不是目标bean实例。
			// AOP 的功能就是基于这个地方
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        } catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }

        try {
            //实际创建指定的bean。
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
            // A previously detected exception with proper bean creation context already,
            // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
            throw ex;
        } catch (Throwable ex) {
            throw new BeanCreationException(
                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }

1、流程

• 解析指定 BeanDefinition 的 class
• 处理 override 属性
• 实例化的前置处理
• doCreateBeanresolveBeforeInstantiation

本篇先分析前三个，最核心的创建bean下次分析。

1.1、resolveBeanClass

RootBeanDefinition mbdToUse = mbd;
// 确保此时bean类已实际解析，并克隆bean定义，以防无法在共享合并bean定义中存储动态解析的类。
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    mbdToUse = new RootBeanDefinition(mbd);
    mbdToUse.setBeanClass(resolvedClass);
}

就是获取BeanDifinition的类，并保存到RootBeanDefinition中，以供后面使用。

1.2、prepareMethodOverrides

这个方法在AbstractBeanDifinition中定义，主要功能就是将override标记为未重载，以避免arg类型检查的开销。

//验证并准备给定的方法覆盖。检查具有指定名称的方法是否存在，如果没有找到，则将其标记为未重载。
	protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
		//返回给定类和/或其超类的具有给定名称(带有任何参数类型)的方法的数量。包括非公开的方法。
		int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
		if (count == 0) {
			throw new BeanDefinitionValidationException(
					"Invalid method override: no method with name '" + mo.getMethodName() +
					"' on class [" + getBeanClassName() + "]");
		}
		else if (count == 1) {
			// 将override标记为未重载，以避免arg类型检查的开销。
			mo.setOverloaded(false);
		}
	}

1.3、resolveBeforeInstantiation

让BeanPostProcessors有机会返回代理而不是目标bean实例。AOP 的功能就是基于这个地方

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {return bean;}

如果代理对象不为空，则直接返回代理对象。

//应用实例化前后处理程序，解决指定bean是否有实例化前快捷方式。
    @Nullable
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        //包可见字段，指示实例化前后处理程序已启动。
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            // 确保此时bean类已经被解析。
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                //确定给定bean定义的目标类型。
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    //实例化前的后处理器应用
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        //实例化后的后处理器应用
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }
	
/** BeanPostProcessors to apply in createBean. */
	private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
	
 /**
     * 将InstantiationAwareBeanPostProcessors应用到指定的bean定义(通过类和名称)，
     * 调用它们的{@code postProcessBeforeInstantiation}方法。
     * 任何返回的对象都将用作bean，而不是实际实例化目标bean。
     * 来自后处理器的{@code null}返回值将导致实例化目标bean。
     *
     * @param beanClass 要实例化的bean的类
     * @param beanName bean的名称
     * @return 要使用的bean对象，而不是目标bean的默认实例，或{@code null}
     * @see InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
     */
    @Nullable
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        //返回将应用于此工厂创建的bean的BeanPostProcessor列表。
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
 @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }