百木园Spring Ioc源码分析系列--Bean实例化过程(二)
前言
上篇文章Spring Ioc源码分析系列--Bean实例化过程(一)简单分析了getBean()方法，还记得分析了什么吗？不记得了才是正常的，记住了才是怪人，忘记了可以回去翻翻，翻不翻都没事， 反正最后都会忘了。
这篇文章是给上篇填坑的，上篇分析到真正创建Bean的createBean(beanName, mbd, args)就没有继续深入去分析了，绕得太深，说不清楚。那么这一篇，就续上这个口子，去分析createBean(beanName, mbd, args)方法。
源码分析
话不多说，我们直接来到createBean(beanName, mbd, args)方法的源码。具体的实现是在AbstractAutowireCapableBeanFactory#createBean(beanName, mbd, args)里，可以直接定位到这里。
createBean()方法
跟进代码查看，这个方法也比较简单，主要分为了以下几点：
- 初始化化
Class对象。调用resolveBeanClass(mbd, beanName)方法获取class对象，这里会去解析类全限定名，最终是通过反射方法Class<?> resolvedClass = ClassUtils.forName(className, classLoader)获取Class对象。 - 检查覆盖方法。对应的是
mbdToUse.prepareMethodOverrides()方法，这里会对一些重载方法进行标记预处理，如果同方法名的方法只存在一个，那么会将覆盖标记为未重载，以避免 arg 类型检查的开销。 - 应用后置处理器。在实例化对象前，会经过后置处理器处理，这个后置处理器的提供了一个短路机制，就是可以提前结束整个Bean的生命周期，直接从这里返回一个Bean。
- 创建Bean。调用
doCreateBean()方法进行Bean的创建，在Spring里面，带有do开头的一般是真正干活的方法，所以Ioc创建Bean到这里，才是真正要到干活的地方了。
我们庖丁解牛先把方法不同的功能按照逻辑拆分了，那接下来，就详细分析一下每个部分。
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
*
* 此类的中心方法：创建 bean 实例、填充 bean 实例、应用后处理器等。
*
* @see #doCreateBean
*/
@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;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
//锁定class ，根据设置的 class 属性或者根据 className 来解析 Class
// 解析得到beanClass，为什么需要解析呢？如果是从XML中解析出来的标签属性肯定是个字符串嘛
// 所以这里需要加载类，得到Class对象
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.验证及准备覆盖的方法
// 对XML标签中定义的lookUp属性进行预处理，
// 如果只能根据名字找到一个就标记为非重载的，这样在后续就不需要去推断到底是哪个方法了，
// 对于@LookUp注解标注的方法是不需要在这里处理的，
// AutowiredAnnotationBeanPostProcessor会处理这个注解
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, \"Validation of method overrides failed\", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//给BeanPostProcessors一个露脸的机会
// 在实例化对象前，会经过后置处理器处理
// 这个后置处理器的提供了一个短路机制，就是可以提前结束整个Bean的生命周期，直接从这里返回一个Bean
// 不过我们一般不会这么做，它的另外一个作用就是对AOP提供了支持，
// 在这里会将一些不需要被代理的Bean进行标记，就本IoC系列文章而言，你可以暂时理解它没有起到任何作用
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//若果有自定义bean则直接返回了bean，不会再走后续的doCreateBean方法
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
\"BeanPostProcessor before instantiation of bean failed\", ex);
}
try {
// 不存在提前初始化的操作，开始正常的创建流程
// doXXX方法，真正干活的方法，doCreateBean，真正创建Bean的方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace(\"Finished creating instance of bean \'\" + beanName + \"\'\");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// 省略部分异常..
}
}
}
初始化Class对象
很显然初始化Class对象的代码在resolveBeanClass(mbd, beanName)方法里，跟进代码查看。
/**
* Resolve the bean class for the specified bean definition,
* resolving a bean class name into a Class reference (if necessary)
* and storing the resolved Class in the bean definition for further use.
*
* 为指定的 bean 定义解析 bean 类，将 bean 类名称解析为 Class 引用（如果需要）并将解析的 Class 存储在 bean 定义中以供进一步使用。
*
* @param mbd the merged bean definition to determine the class for
* @param beanName the name of the bean (for error handling purposes)
* @param typesToMatch the types to match in case of internal type matching purposes
* (also signals that the returned {@code Class} will never be exposed to application code)
* 在内部类型匹配的情况下要匹配的类型（也表示返回的 {@code Class} 永远不会暴露给应用程序代码）
* @return the resolved bean class (or {@code null} if none)
* @throws CannotLoadBeanClassException if we failed to load the class
*/
@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
// 如果已经创建过，直接返回
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
}
else {
// 否则进行创建
return doResolveBeanClass(mbd, typesToMatch);
}
}
catch (PrivilegedActionException pae) {
// 省略部分异常处理
}
}
跟进doResolveBeanClass(mbd, typesToMatch)方法，我们这里传入的typesToMatch参数对象数组为空，所以不会走排除部分类的逻辑，接下来是使用evaluateBeanDefinitionString()方法计算表达式如果传入的className有占位符，会在这里被解析，最终正常我们会走到mbd.resolveBeanClass(beanClassLoader)方法里。
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
throws ClassNotFoundException {
// 获取类加载器
ClassLoader beanClassLoader = getBeanClassLoader();
ClassLoader dynamicLoader = beanClassLoader;
boolean freshResolve = false;
if (!ObjectUtils.isEmpty(typesToMatch)) {
// When just doing type checks (i.e. not creating an actual instance yet),
// use the specified temporary class loader (e.g. in a weaving scenario).
// 当只是进行类型检查（即尚未创建实际实例）时，请使用指定的临时类加载器（例如在编织场景中）。
ClassLoader tempClassLoader = getTempClassLoader();
if (tempClassLoader != null) {
dynamicLoader = tempClassLoader;
freshResolve = true;
if (tempClassLoader instanceof DecoratingClassLoader) {
DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
for (Class<?> typeToMatch : typesToMatch) {
dcl.excludeClass(typeToMatch.getName());
}
}
}
}
String className = mbd.getBeanClassName();
if (className != null) {
Object evaluated = evaluateBeanDefinitionString(className, mbd);
if (!className.equals(evaluated)) {
// A dynamically resolved expression, supported as of 4.2...
if (evaluated instanceof Class) {
return (Class<?>) evaluated;
}
else if (evaluated instanceof String) {
className = (String) evaluated;
freshResolve = true;
}
else {
throw new IllegalStateException(\"Invalid class name expression result: \" + evaluated);
}
}
if (freshResolve) {
// When resolving against a temporary class loader, exit early in order
// to avoid storing the resolved Class in the bean definition.
// 当针对临时类加载器解析时，请提前退出以避免将解析的类存储在 bean 定义中。
if (dynamicLoader != null) {
try {
// 使用临时动态加载器加载 class 对象
return dynamicLoader.loadClass(className);
}
catch (ClassNotFoundException ex) {
if (logger.isTraceEnabled()) {
logger.trace(\"Could not load class [\" + className + \"] from \" + dynamicLoader + \": \" + ex);
}
}
}
// 反射加载 class 对象
return ClassUtils.forName(className, dynamicLoader);
}
}
// Resolve regularly, caching the result in the BeanDefinition...
// 正常解析，将结果缓存在 BeanDefinition...
return mbd.resolveBeanClass(beanClassLoader);
}
跟进mbd.resolveBeanClass(beanClassLoader)方法，可以看到这里就是使用反射初始化Class对象，然后缓存在BeanDefinition中。到这里，已经完成了从一个字符串的类名到一个Class对象的转换了，我们已经得到了一个可以使用的Class对象。
/**
* Determine the class of the wrapped bean, resolving it from a
* specified class name if necessary. Will also reload a specified
* Class from its name when called with the bean class already resolved.
*
* 确定被包装的 bean 的类，必要时从指定的类名解析它。当使用已解析的 bean 类调用时，还将从其名称中重新加载指定的类。
*
* @param classLoader the ClassLoader to use for resolving a (potential) class name
* @return the resolved bean class
* @throws ClassNotFoundException if the class name could be resolved
*/
@Nullable
public Class<?> resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {
String className = getBeanClassName();
if (className == null) {
return null;
}
Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
this.beanClass = resolvedClass;
return resolvedClass;
}
检查覆盖方法
初始化class对象已经完成了，接下来会去处理重载方法，处理的逻辑在mbdToUse.prepareMethodOverrides()方法里。
摘取《Spring源码深度解析》里面的一段话：
很多读者可能会不知道这个方法的作用，因为在 Spring 的配置里面根本就没有诸如
override-method之类的配置， 那么这个方法到底是干什么用的呢？ 其实在 Spring 中确实没有override-method这样的配置，但是在 Spring 配置中是存在lookup-method和replace-method的，而这两个配置的加载其实就是将配置统一存放在BeanDefinition中的methodOverrides属性里，而这个函数的操作其实也就是针对于这两个配置的。
lookup-method通常称为获取器注入，spring in action 中对它的描述是，一种特殊的方法注入，它是把一个方法声明为返回某种类型的 bean，而实际要返回的 bean 是在配置文件里面配置的，可用在设计可插拔的功能上，解除程序依赖。 这里会对一些重载方法进行标记预处理，如果同方法名的方法只存在一个，那么会将覆盖标记为未重载，以避免 arg 类型检查的开销。
这种骚操作我们基本是不会使用的，所以简单看一下代码，浅尝辄止，有兴趣可以去翻翻。
/**
* Validate and prepare the method overrides defined for this bean.
* Checks for existence of a method with the specified name.
*
* 验证并准备为此 bean 定义的方法覆盖。检查具有指定名称的方法是否存在。
*
* @throws BeanDefinitionValidationException in case of validation failure
*/
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// Check that lookup methods exist and determine their overloaded status.
// 检查查找方法是否存在并确定它们的重载状态。
if (hasMethodOverrides()) {
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
可以看到这里就获取所有methodOverrides，然后遍历去调用prepareMethodOverride()方法，跟进prepareMethodOverride()方法。可以看到这里就是做个简单的标记。
/**
* Validate and prepare the given method override.
* Checks for existence of a method with the specified name,
* marking it as not overloaded if none found.
*
* 验证并准备给定的方法覆盖。检查具有指定名称的方法是否存在，如果没有找到，则将其标记为未重载。
*
* @param mo the MethodOverride object to validate
* @throws BeanDefinitionValidationException in case of validation failure
*/
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) {
// Mark override as not overloaded, to avoid the overhead of arg type checking.
// 将覆盖标记为未重载，以避免 arg 类型检查的开销。
mo.setOverloaded(false);
}
}
应用后置处理器
在实例化对象前，会经过后置处理器处理，这个后置处理器的提供了一个短路机制，就是可以提前结束整个Bean的生命周期，直接从这里返回一个Bean。不过我们一般不会这么做，它的另外一个作用就是对AOP提供了支持，在这里会将一些不需要被代理的Bean进行标记，就本IoC系列文章而言，你可以暂时理解它没有起到任何作用。
跟进代码resolveBeforeInstantiation(beanName, mbdToUse)查看。
/**
* Apply before-instantiation post-processors, resolving whether there is a
* before-instantiation shortcut for the specified bean.
*
* 应用实例化前后处理器，解析指定 bean 是否存在实例化前快捷方式。
* 实例化前的快捷方式的意思这里可能会直接返回一个定义的代理，而不需要在把目标类初始化
*
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @return the shortcut-determined bean instance, or {@code null} if none
*/
//注意单词Instantiation和Initialization区别
@Nullable
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()) {
// 确定给定的 bean 的类型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 提供一个提前初始化的时机，这里会直接返回一个实例对象
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 如果提前初始化成功，则执行 postProcessAfterInitialization() 方法，注意单词Instantiation和Initialization区别
// 关于这一块的逻辑，细心的一点的会发现，这里漏了实例化后置处理、初始化前置处理这两个方法。
// 而是在提前返回对象后，直接执行了初始化后置处理器就完成了bean的整个流程，
// 相当于是提供了一个短路的操作，不再经过Spring提供的繁杂的各种处理
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
// 设置是否已经提前实例化
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
跟进applyBeanPostProcessorsBeforeInstantiation()代码查看。这里只要有一个 InstantiationAwareBeanPostProcessor 返回的结果不为空，则直接返回，说明多个 InstantiationAwareBeanPostProcessor 只会生效靠前的一个，注意单词Instantiation和Initialization区别。
/**
* spring bean 初始化流程
* Bean 初始化（Initialization）
* 1.@PoseConstruct 方法
* 2.实现InitializingBean 接口的afterPropertiesSet()方法
* 3.自定义初始化方法
*/
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
// 如果为空，表示不作任何调整
// 这里只要有一个 InstantiationAwareBeanPostProcessor 返回的结果不为空，则直接返回，
// 说明多个 InstantiationAwareBeanPostProcessor 只会生效靠前的一个
if (result != null) {
return result;
}
}
}
return null;
}
跟进applyBeanPostProcessorsAfterInitialization()方法，逻辑跟上面的是类似的，注意单词Instantiation和Initialization区别。
@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;
}
创建Bean
经过上面的步骤，有惊无险，我们来到了doCreateBean(beanName, mbdToUse, args)方法，这是真正进行Bean创建的地方，所以这里才是真的进入正文，前面都是打酱油走走过程。
当经历过 resolveBeforelnstantiation() 方法后，程序有两个选择 ，如果创建了代理或者说重写了 InstantiationAwareBeanPostProcessor 的 postProcessBeforelnstantiation() 方法并在方法 postProcessBeforelnstantiation() 中改变了 bean， 则直接返回就可以了 ， 否则需要进行常规 bean 的创建。 而这常规 bean 的创建就是在 doCreateBean() 中完成的。
直接跟进doCreateBean()代码查看，代码很长，你忍一下。
/**
* Actually create the specified bean. Pre-creation processing has already happened
* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
* <p>Differentiates between default bean instantiation, use of a
* factory method, and autowiring a constructor.
*
* 实际创建指定的bean。
* 此时已经进行了预创建处理，例如检查 {@code postProcessBeforeInstantiation} 回调。
* <p>区分默认 bean 实例化、使用工厂方法和自动装配构造函数。
*
* @param beanName the name of the bean
* @param mbd the merged bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a new instance of the bean
* @throws BeanCreationException if the bean could not be created
* @see #instantiateBean
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 这个方法真正创建了Bean,创建一个Bean会经过 创建对象 > 依赖注入 > 初始化
// 这三个过程，在这个过程中，BeanPostProcessor会穿插执行，
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//根据指定bean使用对应的策略创建新的实例，如工厂方法，构造函数自动注入，简单初始化
// 这里真正的创建了对象
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.
// 按照官方的注释来说，这个地方是Spring提供的一个扩展点，
// 对程序员而言，我们可以通过一个实现了MergedBeanDefinitionPostProcessor的后置处理器
// 来修改bd中的属性，从而影响到后续的Bean的生命周期
// 不过官方自己实现的后置处理器并没有去修改bd，
// 而是调用了applyMergedBeanDefinitionPostProcessors方法
// 这个方法名直译过来就是-应用合并后的bd,也就是说它这里只是对bd做了进一步的使用而没有真正的修改
synchronized (mbd.postProcessingLock) {
// bd只允许被处理一次
if (!mbd.postProcessed) {
try {
// 应用合并后的bd
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
\"Post-processing of merged bean definition failed\", ex);
}
// 标注这个bd已经被MergedBeanDefinitionPostProcessor的后置处理器处理过
// 那么在第二次创建Bean的时候，不会再次调用applyMergedBeanDefinitionPostProcessors
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//是否需要提前暴露mbd.isSingleton() && this.allowCircularReferences &&
// isSingletonCurrentlyInCreation(beanName)
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\");
}
//为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
//getEarlyBeanReference对bean再一次依赖引用，主要应用SmartInstantiationAwareBeanPostProcessor
//其中我们熟悉的AOP就是在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
// 初始化实例
Object exposedObject = bean;
try {
//对bean进行填充，对各个属性进行注入，可能存在依赖其他bean的属性，则会递归初始化依赖bean
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);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
//earlySingletonReference只有在检测到循环依赖的情况下才不为空
if (earlySingletonReference != null) {
//如果exposedObject没有在初始化方法中被改变，也就是没有被增强
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);
}
}
/**
* 因为bean创建完成后，其依赖的bean也一定是创建完成的
* 如果actualDependentBeans不为空，则说明依赖的bean还没有被完全创建好
* 也就是说还存在循环依赖
*/
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 {
//根据scope注册bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, \"Invalid destruction signature\", ex);
}
return exposedObject;
}
分析一下这个函数设计思路：
- 如果是单例则需要首先清除缓存。
- 实例化 bean ，将 BeanDefinition 转换为 BeanWrapper。 转换是一个复杂的过程，但是我们可以尝试概括大致的功能，如下所示。
- 如果存在工厂方法则使用工厂方法进行实例化。
- 如果一个类有多个构造函数，每个构造函数都有不同的参数，所以需要根据参数锁定构造 函数并进行实例化。
- 如果既不存在工厂方法也不存在带有参数的构造函数，则使用默认的构造函数进行 bean 的实例化。
MergedBeanDefinitionPostProcessor的应用。 bean 合并后的处理，Autowired注解正是通过此方法实现诸如类型的预解析。- 依赖处理。 在 Spring 中会有循环依赖的情况，例如，当 A 中含有 B 的属性，而 B 中又含有 A 的属性 时就会构成一个循环依赖，此时如果 A 和 B 都是单例，那么在 Spring 中的处理方式就是当创建 B 的时候，涉及自动注入 A 的步骤，并不是直接去再次创建 A，而是通过放入缓存中的
ObjectFactory来创建实例，这样就解决了循环依赖的问题。 - 属性填充。 将所有属性填充至 bean 的实例中。
- 调用初始化方法。在属性填充完成后，这里会进行初始化方法的调用。
- 循环依赖检查。 之前有提到过，在 Sping 中解决循环依赖只对单例有效，而对于
prototype的 bean, Spring 没有好的解决办法，唯一要做的就是抛出异常。 在这个步骤里面会检测已经加载的 bean 是否 已经出现了依赖循环，并判断是再需要抛出异常。 - 注册
DisposableBean。 如果配置了destroy-method，这里需要注册以便于在销毁时候调用。 - 完成创建井返回。
可以看到上面的步骤非常的繁琐，每一步骤都使用了大量的代码来完成其功能，最复杂也是最难以理解的当属循环依赖的处理，在真正进入 doCreateBean() 前我们有必要先了解下循环依赖，这里会在下一篇文章Spring Ioc源码分析系列--自动注入循环依赖的处理图文并茂去分析。
下面就按照上述的点逐个分析，接下来肯定是枯燥无味的，那开始吧。
清除factoryBeanInstanceCache缓存
首先如果是单例，会到factoryBeanInstanceCache中获取是否存在缓存，如果有这里就会从缓存里获取一个instanceWrapper，不需要再去走复杂的创建流程了。
对应代码如下：
if (mbd.isSingleton()) {
// 你可以暂时理解为，这个地方返回的就是个null
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
实例化 bean
又到了实例化bean，是不是反反复复看了很多次，到底哪里才真的创建一个bean，别慌，这里真的是真正创建bean的地方了，再套娃就是狗。
跟进createBeanInstance(beanName, mbd, args)方法。这个方法干了哪几件事？
- 首先尝试调用
obtainFromSupplier()实例化bean - 尝试调用
instantiateUsingFactoryMethod()实例化bean - 根据给定参数推断构造函数实例化bean
- 以上均无，则使用默认构造函数实例化bean
/**
* Create a new instance for the specified bean, using an appropriate instantiation strategy:
* factory method, constructor autowiring, or simple instantiation.
*
* 使用适当的实例化策略为指定的 bean 创建一个新实例：工厂方法、构造函数自动装配或简单实例化。
*
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a BeanWrapper for the new instance
* @see #obtainFromSupplier
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
* @see #instantiateBean
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 确保此时实际解析了 bean 类。
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
\"Bean class isn\'t public, and non-public access not allowed: \" + beanClass.getName());
}
// 通过bd中提供的instanceSupplier来获取一个对象
// 正常bd中都不会有这个instanceSupplier属性，这里也是Spring提供的一个扩展点，但实际上不常用
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//如果工厂方法不为null，则使用工厂方法初始化策略
// bd中提供了factoryMethodName属性，那么要使用工厂方法的方式来创建对象，
// 工厂方法又会区分静态工厂方法跟实例工厂方法
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 在原型模式下，如果已经创建过一次这个Bean了，那么就不需要再次推断构造函数了
// 是否推断过构造函数
boolean resolved = false;
// 构造函数是否需要进行注入
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
//一个类里面有多个构造函数，每个构造函数都有不同的参数，所以调用前需要根据参数锁定要调用的构造函数或工厂方法
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
//如果已经解析过则使用解析好的构造函数方法，不需要再次锁定
if (resolved) {
if (autowireNecessary) {
//构造函数自动注入
return autowireConstructor(beanName, mbd, null, null);
}
else {
//使用默认构造函数进行构造
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
//需要根据参数解析构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
// 默认构造的首选构造函数？
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
//使用默认构造函数
return instantiateBean(beanName, mbd);
}
接下来分析以上几点，算了不分析，太长了。我在另一篇文章Spring Ioc源码分析系列--实例化Bean的几种方法会填坑。这里会详细分析上面的几点，好好把握，估计看到这都不知道啥跟啥了。
MergedBeanDefinitionPostProcessor的应用
到这里我们已经实例化了一个bean对象，但是这个bean只是个半成品，空有外壳而无内在，所以接下来的工作就是对里面的内容进行填充。那毫无疑问，按照Spring的尿性，肯定会在真正开始之前给你一个扩展点，让你还要机会在属性填充之前修改某些东西。我们经常使用的@Autowired注解就是在这里实现的，后续会写一篇Spring Ioc源码分析系列--@Autowired注解的实现原理结合源码和例子去分析它的实现。
跟进代码查看，比较简单，就是获取所有的MergedBeanDefinitionPostProcessor，然后依次执行它的postProcessMergedBeanDefinition()方法。
/**
* Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
* invoking their {@code postProcessMergedBeanDefinition} methods.
*
* 将 MergedBeanDefinitionPostProcessors 应用于指定的 bean 定义，
* 调用它们的 {@code postProcessMergedBeanDefinition} 方法。
*
* 可以看到这个方法的代码还是很简单的，
* 就是调用了MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
*
* @param mbd the merged bean definition for the bean
* @param beanType the actual type of the managed bean instance
* @param beanName the name of the bean
* @see MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
*/
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);
}
}
}
依赖处理
这部分主要是为了处理循环依赖而做的准备，这里会根据earlySingletonExposure参数去判断是否允许循环依赖，如果允许，则会调用addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))方法将bean的早期引用放入到singletonFactories中。关于循环依赖的详细处理过程，可以在下一篇文章Spring Ioc源码分析系列--自动注入循环依赖的处理里看到。
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//是否需要提前暴露mbd.isSingleton() && this.allowCircularReferences &&
// isSingletonCurrentlyInCreation(beanName)
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\");
}
//为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
//getEarlyBeanReference对bean再一次依赖引用，主要应用SmartInstantiationAwareBeanPostProcessor
//其中我们熟悉的AOP就是在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
跟进addSingletonFactory()方法，可以看到这里会先把早期引用放入到singletonFactories三级缓存中。
/**
* Add the given singleton factory for building the specified singleton
* if necessary.
*
* 如有必要，添加给定的单例工厂以构建指定的单例。
*
* <p>To be called for eager registration of singletons, e.g. to be able to
* resolve circular references.
*
* 被提前注册的单例Bean调用，例如用来解决循环依赖
*
* @param beanName the name of the bean
* @param singletonFactory the factory for the singleton object
*/
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, \"Singleton factory must not be null\");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
那放入到singletonFactories里面的是什么呢？从上面可以看到，这是一个lambada表达式，调用的方法的是getEarlyBeanReference()，跟进代码查看。
/**
* Obtain a reference for early access to the specified bean,
* typically for the purpose of resolving a circular reference.
*
* 获取对指定 bean 的早期访问的引用，通常用于解析循环引用。
*
* @param beanName the name of the bean (for error handling purposes)
* @param mbd the merged bean definition for the bean
* @param bean the raw bean instance
* @return the object to expose as bean reference
*/
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;
// 对 bean 再一次依赖引用
// 主要应用 SmartInstantiationAwareBeanPostProcessor,
// 其中我们熟知的 AOP 就是在这里将 advice 动态织入 bean 中， 若没有则直接返回 bean ，不做任何处理
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
属性填充
到这里会已经完成了bean的实例化，早期引用的暴露，那接下来就到了属性填充的部分，开始对bean进行各种赋值，让一个空壳半成品bean完善成一个有血有肉的正常bean。
这里可能存在依赖其他bean的属性，则会递归初始化依赖bean。
在 populateBean() 函数中提供了这样的处理流程。
InstantiationAwareBeanPostProcessor处理器的postProcessAfterinstantiation函数的应用， 此函数可以控制程序是否继续进行属性填充。- 根据注入类型（ byName/byType ），提取依赖的 bean，并统一存入
PropertyValues中。 - 应用
InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法， 对属性获取完毕填充前对属性的再次处理，典型应用是RequiredAnnotationBeanPostProcessor类中对属性的验证。 - 将所有
PropertyValues中的属性填充至BeanWrapper中。
跟进代码查看，又很长，这一块的代码真的是又臭又长。但是注释很详细，可以跟着看看。
/**
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
*
* 使用 bean 定义中的属性值填充给定 BeanWrapper 中的 bean 实例。
*
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param bw the BeanWrapper with bean instance
*/
@SuppressWarnings(\"deprecation\") // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, \"Cannot apply property values to null instance\");
}
else {
// Skip property population phase for null instance.
//没有可填充的属性
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
boolean continueWithPropertyPopulation = true;
//给InstantiationAwareBeanPostProcessors最后一次机会在属性设置前来改变 bean
//如：可以用来支持属性注入的类型
// 满足两个条件，不是合成类 && 存在InstantiationAwareBeanPostProcessor
// 其中InstantiationAwareBeanPostProcessor主要作用就是作为Bean的实例化前后的钩子
// 外加完成属性注入，对于三个方法就是
// postProcessBeforeInstantiation 创建对象前调用
// postProcessAfterInstantiation 对象创建完成，@AutoWired注解解析后调用
// postProcessPropertyValues（已过期，被postProcessProperties替代） 进行属性注入
// 下面这段代码的主要作用就是我们可以提供一个InstantiationAwareBeanPostProcessor
// 提供的这个后置处理如果实现了postProcessAfterInstantiation方法并且返回false
// 那么可以跳过Spring默认的属性注入，但是这也意味着我们要自己去实现属性注入的逻辑
// 所以一般情况下，我们也不会这么去扩展
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//返回值为是否继续填充bean
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
//如果后处理器发出停止填充命令则终止后续操作
if (!continueWithPropertyPopulation) {
return;
}
// 这里其实就是判断XML是否提供了属性相关配置
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 确认注入模型
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
// 主要处理byName跟byType两种注入模型，byConstructor这种注入模型在创建对象的时候已经处理过了
// 这里都是对自动注入进行处理，byName跟byType两种注入模型均是依赖setter方法
// byName,根据setter方法的名字来查找对应的依赖，例如setA,那么就是去容器中查找名字为a的Bean
// byType,根据setter方法的参数类型来查找对应的依赖，例如setXx(A a)，就是去容器中查询类型为A的bean
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
//根据名称注入
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
//根据类型注入
autowireByType(beanName, mbd, bw, newPvs);
}
// pvs是XML定义的属性
// 自动注入后，bean实际用到的属性就应该要替换成自动注入后的属性
pvs = newPvs;
}
//后置处理器已经初始化
// 检查是否有InstantiationAwareBeanPostProcessor
// 前面说过了，这个后置处理器就是来完成属性注入的
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
//需要依赖检查
// 是否需要依赖检查，默认是不会进行依赖检查的
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
// 下面这段代码有点麻烦了，因为涉及到版本问题
// 其核心代码就是调用了postProcessProperties完成了属性注入
PropertyDescriptor[] filteredPds = null;
// 存在InstantiationAwareBeanPostProcessor，我们需要调用这类后置处理器的方法进行注入
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 这句就是核心
// Autowired 是通过 AutowiredAnnotationBeanPostProcessor#postProcessProperties() 实现的
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
// 得到需要进行依赖检查的属性的集合
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//对所有需要依赖检查的属性做后置处理
// 这个方法已经过时了，放到这里就是为了兼容老版本
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
// 需要进行依赖检查
if (needsDepCheck) {
if (filteredPds == null) {
// 得到需要进行依赖检查的属性的集合
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//依赖检查，对应depends-on属性，3.0已经弃用此属性
// 对需要进行依赖检查的属性进行依赖检查
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 将XML中的配置属性应用到Bean上
if (pvs != null) {
//将属性应用到bean中
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
这里看到这里会根据byName或者byType方式寻找依赖，然后调用applyPropertyValues()将属性注入到BeanWrapperImpl里。
先来看autowireByName()方法，顾名思义，这里会根据属性名去获取依赖。
/**
* Fill in any missing property values with references to
* other beans in this factory if autowire is set to \"byName\".
*
* 如果 autowire 设置为“byName”，则使用对该工厂中其他 bean 的引用填充任何缺少的属性值。
*
* @param beanName the name of the bean we\'re wiring up.
* Useful for debugging messages; not used functionally.
* @param mbd bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//寻找bw中需要依赖注入的属性值
// 得到符合下面条件的属性名称
// 1.有setter方法
// 2.需要进行依赖检查
// 3.不包含在XML配置中
// 4.不是简单类型（基本数据类型，枚举，日期等）
// 这里可以看到XML配置优先级高于自动注入的优先级
// 不进行依赖检查的属性，也不会进行属性注入
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
//递归初始化相关bean
Object bean = getBean(propertyName);
// 将自动注入的属性添加到pvs中去
pvs.add(propertyName, bean);
//注册依赖
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace(\"Added autowiring by name from bean name \'\" + beanName +
\"\' via property \'\" + propertyName + \"\' to bean named \'\" + propertyName + \"\'\");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace(\"Not autowiring property \'\" + propertyName + \"\' of bean \'\" + beanName +
\"\' by name: no matching bean found\");
}
}
}
}
接下来看autowireByType()，该方法会根据属性的类型去获取依赖。也比较简单明了。
/**
* Abstract method defining \"autowire by type\" (bean properties by type) behavior.
* <p>This is like PicoContainer default, in which there must be exactly one bean
* of the property type in the bean factory. This makes bean factories simple to
* configure for small namespaces, but doesn\'t work as well as standard Spring
* behavior for bigger applications.
*
* 定义“按类型自动装配”（按类型的 bean 属性）行为的抽象方法。
* <p>这类似于 PicoContainer 默认值，其中 bean 工厂中必须只有一个属性类型的 bean。
* 这使得 bean 工厂易于为小型命名空间配置，但不能像标准 Spring 行为那样为大型应用程序工作。
*
* @param beanName the name of the bean to autowire by type
* @param mbd the merged bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 这个类型转换器，主要是在处理@Value时需要使用
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
//寻找bw中需要依赖注入的属性
// 得到符合下面条件的属性名称
// 1.有setter方法
// 2.需要进行依赖检查
// 3.不包含在XML配置中
// 4.不是简单类型（基本数据类型，枚举，日期等）
// 这里可以看到XML配置优先级高于自动注入的优先级
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don\'t try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
// 不要尝试为 Object 类型按类型自动装配：永远没有意义，即使它在技术上是一个不令人满意的、不简单的属性。
if (Object.class != pd.getPropertyType()) {
//探测指定属性的set方法
// 这里获取到的就是setter方法的参数，因为我们需要按照类型进行注入嘛
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
// 如果是PriorityOrdered在进行类型匹配时不会去匹配factoryBean
// 如果不是PriorityOrdered，那么在查找对应类型的依赖的时候会会去匹factoryBean
// 这就是Spring的一种设计理念，实现了PriorityOrdered接口的Bean被认为是一种
// 最高优先级的 Bean，这一类的Bean在进行为了完成装配而去检查类型时，
// 不去检查 factoryBean
// 具体可以参考PriorityOrdered接口上的注释文档
boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
// 将参数封装成为一个依赖描述符
// 依赖描述符会通过:依赖所在的类,字段名/方法名,依赖的具体类型等来描述这个依赖
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
/**
* 解析指定beanName的属性所匹配的值，并把解析到的属性名存储在autowiredBeanNames中，
* 当属性存在多个封装bean时，如：
* @Autowire
* private List<A> list;
* 将会找到所有匹配A类型的bean并将其注入
* 解析依赖，这里会处理@Value注解
* 另外，通过指定的类型到容器中查找对应的bean
*/
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
// 将查找出来的依赖属性添加到pvs中，后面会将这个pvs应用到bean上
pvs.add(propertyName, autowiredArgument);
}
// 注册bean直接的依赖关系
for (String autowiredBeanName : autowiredBeanNames) {
//注册依赖
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace(\"Autowiring by type from bean name \'\" + beanName + \"\' via property \'\" +
propertyName + \"\' to bean named \'\" + autowiredBeanName + \"\'\");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
属性依赖都获取完了，接下来就是按部就班的进行注入了。
跟进applyPropertyValues()方法，逻辑比较复杂。但是最终是调用了反射，给对应的属性进行了赋值，这里深入的就不再展开了。
/**
* Apply the given property values, resolving any runtime references
* to other beans in this bean factory. Must use deep copy, so we
* don\'t permanently modify this property.
*
* 应用给定的属性值，解析对此 bean 工厂中其他 bean 的任何运行时引用。必须使用深拷贝，所以我们不会永久修改这个属性。
*
* @param beanName the bean name passed for better exception information
* @param mbd the merged bean definition
* @param bw the BeanWrapper wrapping the target object
* @param pvs the new property values
*/
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
// 快捷方式：按原样使用转换前的值。
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, \"Error setting property values\", ex);
}
}
original = mpvs.getPropertyValueList();
}
else {
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
// 创建一个深拷贝副本，解析任何值的引用。
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException(\"Autowire marker for property without write method: \" + pv);
}
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
// 给定一个 PropertyValue，返回一个值，必要时解析对工厂中其他 bean 的任何引用
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
// 可能将转换后的值存储在合并的 bean 定义中，以避免对每个创建的 bean 实例进行重新转换。
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// 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);
}
}
调用初始化方法
初始化方法的调用逻辑在initializeBean(beanName, exposedObject, mbd)里面，跟进代码查看。
一看是不是很清晰，所以以后再遇到问你啥啥啥方法先执行，直接叼面试官。
/**
*
* initializeBean()方法依次调用四个方法
* 1.invokeAwareMethods()
* 2.applyBeanPostProcessorsBeforeInitialization()
* 3.invokeInitMethods()
* 4.applyBeanPostProcessorsAfterInitialization()
*
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 1.先调用实现 aware 接口的方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 2.调用 BeanPostProcessor#postProcessBeforeInitialization()方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 3.调用初始化方法，例如实现了 InitializingBean#afterPropertiesSet() 方法
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()) {
// 4.最后调用 BeanPostProcessor#postProcessAfterInitialization()
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
循环依赖检查
这一步主要是实现一个兜底的检测，避免出现注入了一个本该被代理的但是却注入了一个原生bean的情况，这部分会在循环依赖的文章里结合来分析。
先看下代码。
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
//earlySingletonReference只有在检测到循环依赖的情况下才不为空
if (earlySingletonReference != null) {
//如果exposedObject没有在初始化方法中被改变，也就是没有被增强
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);
}
}
/**
* 因为bean创建完成后，其依赖的bean也一定是创建完成的
* 如果actualDependentBeans不为空，则说明依赖的bean还没有被完全创建好
* 也就是说还存在循环依赖
*/
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.\");
}
}
}
}
注册 DisposableBean
这也是一个回调的操作，注册一些销毁的方法。Spring 中不但提供了对于初始化方法的扩展人口 ， 同样也提供了销毁方法的扩展入口，对 于销毁方法的扩展，除了我们熟知的配置属性 destroy-method 方法外，用户还可以注册后处理器 DestructionAwareBeanPostProcessor 来统一处理 bean 的销毁方法，跟进代码registerDisposableBeanIfNecessary()。
/**
* Add the given bean to the list of disposable beans in this factory,
* registering its DisposableBean interface and/or the given destroy method
* to be called on factory shutdown (if applicable). Only applies to singletons.
*
* 将给定的 bean 添加到该工厂的一次性 bean 列表中，
* 注册其 DisposableBean 接口和或在工厂关闭时调用的给定销毁方法（如果适用）。仅适用于单例。
*
* @param beanName the name of the bean
* @param bean the bean instance
* @param mbd the bean definition for the bean
* @see RootBeanDefinition#isSingleton
* @see RootBeanDefinition#getDependsOn
* @see #registerDisposableBean
* @see #registerDependentBean
*/
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.
// 注册一个为给定 bean 执行所有销毁工作的 DisposableBean 实现：DestructionAwareBeanPostProcessors、DisposableBean 接口、自定义销毁方法。
/**
* 单例模式下需要销毁的bean，此方法中会处理实现DisposableBean的bean
* 并且对所有的bean使用DestructionAwareBeanPostProcessors处理
* DisposableBean DestructionAwareBeanPostProcessors
*/
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
else {
// A bean with a custom scope...
// 自定义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));
}
}
}
总结
本文主要分析了doCreateBean()方法，但是讲得比较粗糙。回忆一下本文的思路，首先是通过类名反射得到一个class对象，然后推断构造函数去实例化得到一个bean对象，当然这部分没有深入细节去说，分多了一篇文章。然后通过byName和byType两种方式去获取依赖注入，之后通过反射将属性注入到对象中。除去一些边边角角的校验，总的思路就是这样，还是相对清晰的，就是细节比较多。
这里牵扯的东西比较多，也算是Ioc里面比较难啃的部分了。我回看一遍我写的文章，觉得整体言不达意，脑子里想十分，说出来可能只有六分，写出来的就剩三分了。
个人水平有限，如有错误，还请指出。
如果有人看到这里，那在这里老话重提。与君共勉，路漫漫其修远兮，吾将上下而求索。
来源：https://www.cnblogs.com/codegitz/p/16331774.html
本站部分图文来源于网络，如有侵权请联系删除。