createBean方法分析

1：写在前面

在spring使用bean定义初始化bean分析
中已经详细分析了bean真正创建前的操作，本文，就来分析，springbean到底是如何创建的。

2：createBean

最终会执行AbstractAutowireCapableBeanFactory类对该方法的默认实现，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
	// 启用trace日志，则打印开始创建bean实例的日志信息
	if (logger.isTraceEnabled()) {
		logger.trace("Creating instance of bean '" + beanName + "'");
	}
	RootBeanDefinition mbdToUse = mbd;

	// 解析出beandefinition的class的类型，即当前beanName对应的
	// 要创建的实例的类型
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		// 重新定义一个RootBeanDefinition，并设置class类型
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	try {
		// <2021-03-18 17:39>
		// 处理beandefinition的methodOverrides属性,主要是对
		// 方法做一些校验工作，如果是校验不通过则异常
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
		// <2021-03-19 14:10>
		// 给BeanPostProcessor一个机会来返回bean的代理类
		// 而非类本身，spring的其中一个核心功能AOP就是基于这里
		// 来实现的
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		// 这里的if判断就比较重要了，代表直接让用户使用代理类
		// 如果是BeanPostProcessor返回的bean不为空，则返回
		// 生成的代理bean
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		// 发生异常，抛出因为BeanPostProcessor初始化bean的异常信息
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}

	try {
		// <2021-03-19 14:55>,创建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);
	}
}

<2021-03-18 17:39>处是处理beandefinition的methodOverrides属性，定义如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#methodOverrides
private MethodOverrides methodOverrides = new MethodOverrides();

在spring解析bean标签过程分析
文章我们分析了bean的主要子标签，其中replace-method和lookup-method解析出的信息会被存储到该属性中，如下相关解析代码段：

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

该代码段就是执行具体解析，然后将解析的信息存储到methodOverrides属性中的。
该处源码如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#prepareMethodOverrides
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
	// <2021-03-19 10:18>
	if (hasMethodOverrides()) {
		// <2021-03-19 10:19>
		getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
	}
}

<2021-03-19 10:18>查看是否有methodOverrides的信息，源码如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#hasMethodOverrides
public boolean hasMethodOverrides() {
	// 不为空即为存在
	return !this.methodOverrides.isEmpty();
}

<2021-03-19 10:19>处是获取methodOverrides属性，然后循环调用方法org.springframework.beans.factory.support.AbstractBeanDefinition#prepareMethodOverride,因此我们来看下这个方法做了哪些处理，源码如下：

org.springframework.beans.factory.support.AbstractBeanDefinition#prepareMethodOverride
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
	// 检测方法被重载的次数，因为不管是通过lookup-method调用bean的方法
	// 获取一个bean，还是replace-method使用MethodReplacer的实现类
	// 动态替换bean的方法，都首先必须有这个方法
	int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
	// 当count为0时，代表没有需要的方法，直接抛出异常
	if (count == 0) {
		throw new BeanDefinitionValidationException(
				"Invalid method override: no method with name '" + mo.getMethodName() +
				"' on class [" + getBeanClassName() + "]");
	}
	// 如果是1个方法，则设置没有重载版本，这样的话后续就不需要通过
	// 判断参数来确定到底是哪个方法了，算是一种优化手段
	else if (count == 1) {
		mo.setOverloaded(false);
	}
}

<2021-03-19 14:10>是执行bean的前置处理器们BeanPostProcessor，其中AOP返回代理类就是在这里实现的，详细参考2.1：BeanPostProcessor处理,<2021-03-19 14:55>处是创建bean，具体参考2.2：创建bean。

2.1：BeanPostProcessor处理

这里是处理Bean后置处理器，BeanPostProcessor，其中AOP代理对象的返回就是通过这里完成的，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// Make sure bean class is actually resolved at this point.
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			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;
}

这段代码不会影响bean创建的主逻辑，先放在这里，不做深入分析。

2.2：创建bean

源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

	// BeanWrapper是用来对bean简单包装的，具有以下的的功能
	// 1：获取被包装的bean 2：获取被包装的bean的类型 
	// 3：获取被包装的bean的属性描述器
	BeanWrapper instanceWrapper = null;
	// 如果是单例模式，则清除缓存？？？
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	// <2021-03-20 09:39>
	// 使用合适的初始化策略来创建bean，如构造器，工厂方法
	// 主要完成的工作是将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;
	}

	// 应用mergedbeandefinition的后置处理，详细略
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				// 通过merged beandefinition的后置处理修改BeanDefinition
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	// <2021-03-20 10:11>
	// 单例模式的循环依赖的处理
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isTraceEnabled()) {
			logger.trace("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 到这里创建bean结束，但是bean还没有初始化，开始初始化bean
	Object exposedObject = bean;
	try {
		// <2021-03-20 10:27>
		// 处理Bean对应的BeanWrapper，填充属性到bean中
		// 存在ref依赖bean的话则递归处理
		populateBean(beanName, mbd, instanceWrapper);
		// <2021-03-20 11:06>
		// 调用初始化方法
		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<>(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.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

<2021-03-20 09:39>处参考spring通过不同的方式创建bean。<2021-03-20 10:11>处参考spring关于单例模式循环依赖的处理。<2021-03-20 10:27>处参考处理BeanWrapper填充bean属性。<2021-03-20 11:06>处参考spring调用bean的初始化方法分析。