Spring启动流程（三）之Bean的初始化（非懒加载的单例Bean）

上一篇Spring启动流程（二）之Spring加载Bean Definition的流程主要分析了如何从xml配置中读取Bean的配置，然后加载生成对应的Bean Definition。

主要代码为：

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

obtainFreshBeanFactory()最终返回一个存放了Bean Definition信息的Bean工厂——DefaultListableBeanFactory。

1、准备DefaultListableBeanFactory

后面的几步，也都是往DefaultListableBeanFactory里加东西，让它可扩展。（如何做到可扩展可单独成篇叙述）

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);


// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
registerListeners();

2、初始化Bean实例，返回Bean Wrapper

到这一步，准备工作做完了，扩展也设置好了，真正的开始实例化Bean对象了：

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

Spring默认创建的实例是单例的，代码从AbstractBeanFactory.doGetBean()开始，下面是部分代码

// Create bean instance.
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			// Explicitly remove instance from singleton cache: It might have been put there
			// eagerly by the creation process, to allow for circular reference resolution.
			// Also remove any beans that received a temporary reference to the bean.
			destroySingleton(beanName);
			throw ex;
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

上面代码看createBean方法，这个方法是AbstractAutowireCapableBeanFactory中的。

看createBean的方法注释

Central method of this class: creates a bean instance,populates the bean instance, applies post-processors

可以知道，这个方法的核心方法是：创建bean实例、填充bean 实例（填充实例内部引用的其他实例）、应用扩展方法

createBean内部：

try {
	// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
	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 {
	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);
}

上面代码是createBean的部分内容。忽略try catch，

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

上面这行是调用初始化前的扩展点。

接着看doCreateBean方法，方法注释为

Actually create the specified bean. Pre-creation processing has already happened at this point, e.g. checking postProcessBeforeInstantiation callbacks.
Differentiates between default bean instantiation, use of a factory method, and autowiring a constructor.

 这里说bean实例开始真正创建了，==||

if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

查看createBeanInstance方法签名和注释

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

Create a new instance for the specified bean, using an appropriate instantiation strategy: factory method, constructor autowiring, or simple instantiation.

可知，这里面做的应该就是创建bean实例的勾当了吧？！

而且这里说明了有三种初始化策略：使用工厂方法实例化、使用构造方法实例化、简单初始化（默认构造函数）。

涉及到的类和接口如下图：

最终会使用反射API来初始化或者CglibAPI来创建子类然后初始化

ReflectionUtils.makeAccessible(ctor);
return (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
		KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));

// Must generate CGLIB subclass...
return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);

如何决定使用哪种方式来实例化呢？可以看看SimpleInstantiationStrategy类中的instantiate方法。

@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (!bd.hasMethodOverrides()) {
	Constructor constructorToUse;
	synchronized (bd.constructorArgumentLock) {
		constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
		if (constructorToUse == null) {
			final Class clazz = bd.getBeanClass();
			if (clazz.isInterface()) {
				throw new BeanInstantiationException(clazz, "Specified class is an interface");
			}
			try {
				if (System.getSecurityManager() != null) {
					constructorToUse = AccessController.doPrivileged(
							(PrivilegedExceptionAction>) clazz::getDeclaredConstructor);
				}
				else {
					constructorToUse = clazz.getDeclaredConstructor();
				}
				bd.resolvedConstructorOrFactoryMethod = constructorToUse;
			}
			catch (Throwable ex) {
				throw new BeanInstantiationException(clazz, "No default constructor found", ex);
			}
		}
	}
	return BeanUtils.instantiateClass(constructorToUse);
}
else {
	// Must generate CGLIB subclass.
	return instantiateWithMethodInjection(bd, beanName, owner);
}

Bean definition中没有overrides的方法，就会使用反射API，否则使用CGLIB 的API。

不管是使用上面哪种策略，最终产生的实例是一个BeanWrapper。一个用来包装Bean实例的对象。

为什么要包装一下呢？

3、填充Bean实例的属性值

继续看看获取到BeanWrapper后Spring做的事情。

再回到AbstractAutowireCapableBeanFactory的doCreateBean方法

if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
	mbd.resolvedTargetType = beanType;
}

// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
	if (!mbd.postProcessed) {
		try {
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Post-processing of merged bean definition failed", ex);
		}
		mbd.postProcessed = true;
	}
}

createBeanInstance方法上面已经分析过了，会通过反射或者Cgilib创建子类实例化一个BeanWrapper返回。

// Initialize the bean instance.
Object exposedObject = bean;
try {
	populateBean(beanName, mbd, instanceWrapper);
	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);
	}
}

populateBean方法开始填充我们刚刚生成的BeanWrapper实例的属性值。

if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
	MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
	// Add property values based on autowire by name if applicable.
	if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
		autowireByName(beanName, mbd, bw, newPvs);
	}
	// Add property values based on autowire by type if applicable.
	if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
		autowireByType(beanName, mbd, bw, newPvs);
	}
	pvs = newPvs;
}

上面的代码会将By Name和By Type注入的属性给newPvs——MutablePropertyValues类型。

populateBean最后执行applyPropertyValues方法

if (pvs != null) {
	applyPropertyValues(beanName, mbd, bw, pvs);
}

 applyPropertyValues关键代码如下：

// Set our (possibly massaged) deep copy.
try {
	bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
	throw new BeanCreationException(
			mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}

 上面的setPropertyValues内部会循环调用setPropertyValue,即遍历属性，逐个拷贝。

@Override
public void setPropertyValue(PropertyValue pv) throws BeansException {
	PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
	if (tokens == null) {
		String propertyName = pv.getName();
		AbstractNestablePropertyAccessor nestedPa;
		try {
			nestedPa = getPropertyAccessorForPropertyPath(propertyName);
		}
		catch (NotReadablePropertyException ex) {
			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
					"Nested property in path '" + propertyName + "' does not exist", ex);
		}
		tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
		if (nestedPa == this) {
			pv.getOriginalPropertyValue().resolvedTokens = tokens;
		}
		nestedPa.setPropertyValue(tokens, pv);
	}
	else {
		setPropertyValue(tokens, pv);
	}
}

nestedPa.setPropertyValue方法内部，主要是通过反射设置属性值。

BeanWrapperImpl.setValue()：

@Override
public void setValue(final @Nullable Object value) throws Exception {
	final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
			((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
			this.pd.getWriteMethod());
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction