揭秘Spring生命周期：Bean的创建过程超详细解析

Spring Bean 的生命周期

BeanFactory 创建对象

在 BeanFactory 接口中定义了获取 Bean 实例的方法 getBean。

@Test
public void testDefaultListableBeanFactory() {
    // 创建工厂
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // 创建 XML 阅读器，并指定关联的工厂
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    // 开始解析加载 Bean
    reader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml"));
    System.out.println(factory.getBean("user"));
}

Spring 工厂创建对象的过程其实就是 factory.getBean("user") 对应的实现，这个创建逻辑可以说是 Spring 中最复杂的地方，其中会完整的体现上面生命周期的各个步骤，以及对单例对象、多实例对象的处理，接下来我们将深入源码，解析整个对象的创建过程。

Bean 创建过程

获取 Bean 的方法是 getBean，其来自 DefaultListableBeanFactory 的父类 AbstractAutowireCapableBeanFactory 的父类 AbstractBeanFactory。有点绕，其实就是 DefaultListableBeanFactory 的爷爷…

【重载】getBean

AbstractBeanFactory#getBean

通过名称获取 Bean，这个名称可以是 ID，也可以是别名。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    
    @Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

	@Override
	public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
		return doGetBean(name, requiredType, null, false);
	}
    
	@Override
	public Object getBean(String name, Object... args) throws BeansException {
		return doGetBean(name, null, args, false);
	}
	
    ...
}

getBean 有多个重载方法，可分为通过 Bean 名称或通过 Class 获取 Bean 对象，这些重载方法底层都是调用 doGetBean 方法。

【从缓存拿或者创建】doGetBean

AbstractBeanFactory#doGetBean

// 为了简洁美观，这里将源码中的部分非核心内容进行了删减
protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
    
    // 转换名称，返回 Bean 的 ID
    // 如果是 FactoryBean 类型，则参数 name 会以 & 为前缀。此方法会去掉该修饰符，并返回后面的内容
    // 如果传入的是 Bean 的别名，则会找到 Bean 的 ID 返回
    final String beanName = transformedBeanName(name);
    Object bean;
    
    // 单例 Bean 只会被创建一次，后续再获取 Bean，直接从单例缓存中获取（共有三级缓存）
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // 如果存在缓存的 Bean
        // 获取 Bean，正常 Bean 直接返回，如果是 FactoryBean 则返回 FactoryBean.getObject()
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    
    else {
        // 检验逻辑
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(...);
        }
        
        // 父子容器的处理
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 当父容器不为空并且获取的 Bean 不在子容器定义时，从父容器递归获取
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            } else if (args != null) {
                // 递归到父容器中寻找
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            } else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        
        if (!typeCheckOnly) {
            // 将 Bean 标记为已经创建（或将要创建）,即将 beanName 加入 alreadyCreated 集合
            markBeanAsCreated(beanName);
        }
        
        try {
            // 获取合并后的父子 Bean，对应 <bean id="p" abstract="true"> 和 <bean id="c" parent="p" 的用法
            // 将子标签 bean 的各个属性合并到父标签，生成 RootBeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            
            // 获取目标 bean 所依赖的其它 bean 名称
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(...);
                    }
                    // 若存在依赖则需要递归实例化依赖的 bean
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    } // catch...
                }
            }
            
            if (mbd.isSingleton()) {
                // 创建单例 Bean
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 创建 Bean 的核心方法
                        return createBean(beanName, mbd, args);
                    } // catch...
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } 
            
            else if (mbd.isPrototype()) {
                // 创建原型 Bean
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                } finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } 
            
            else {
                // 创建其他作用域的 Bean
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException(...);
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        } finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } // catch...
            }
        } // catch...
    }
    // 将 Bean 的类型转换为 getBean 时指定的 requireType 类型
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(...);
            }
            return convertedBean;
        } // catch...
    }
    return (T) bean;
}

简单概述一下整个过程：

1. 第一步【转换名称】：解析转换传入的获取 Bean 的名字，可以分为三种情况：
   1. 传入的直接是 ID，则无须转换
   2. 传入的是 Bean 的别名，转换成 Bean 的 ID 返回
   3. 传入的是 FactoryBean 的 & 写法，，转换成 Bean 的 ID 返回
2. 第二步【从缓存中获取】：单例作用域的 Bean 只会创建一次，之后会存储在 Spring 的缓存中（共计三层）。如果缓存中存在目标 Bean，则获取 Bean，正常 Bean 直接返回，如果是 FactoryBean 则 返回 FactoryBean.getObject()。获取到 Bean 之后跳到第八步【类型转换】。
3. 第三步【父子容器的处理】：如果没有从上面的缓存中拿到数据，说明这次要重新创建 Bean。首先进行父子容器的处理，当父容器不为空并且获取的 Bean 不在当前容器定义时，从父容器递归获取。
4. 第四步【标记 Bean 为被创建】：将 Bean 标记为已经创建（或将要创建），即将 beanName 加入 alreadyCreated 集合。
5. 第五步【合并父子 Bean】：获取合并后的父子 Bean，对应 <bean id="xx" abstract="true"> 和 <bean id="c" parent="xx" 的用法，这个步骤会将子标签 bean 的各个属性合并到父标签，生成 RootBeanDefinition。
6. 第六步【处理依赖 Bean】：获取当前 Bean 是否配置依赖的其他的 Bean 的名称，若存在依赖则需要递归实例化依赖的其他 Bean。这个用法现在已经很少了，大家可以忽略。
7. 第七步【根据作用域创建 Bean】：根据作用域可分为三类：单例（singleton）、原型（prototype）和其他，对应的 if 的三个分支，最后都会调用 createBean 创建 Bean。
8. 第八步【类型转换】：如果获取 Bean 的时候传入了期望转换的类型 Class，那么这一步就会进行类型转换，之后就将创建的 Bean 返回给调用者了。

以上就是 getBean 方法的大致流程，其中有两个频繁出现且非常重要的方法，一个是处理 FactoryBean 的 getObjectForBeanInstance方法，另一个是创建 Bean 的核心实现 createBean 方法。

FactoryBean 是用于创建复杂对象的，之前我们说过有三种方式可以创建复杂对象：FactoryBean、实例工厂、静态工厂，对应这篇文章：《高级对象装配：解析Spring创建复杂对象的秘诀》

当某个 Bean 的实例化过程比较复杂时，可通过实现 FactoryBean 接口，然后在重写的 getObject 方法中定义实例化 Bean 的逻辑，以后获取该 Bean 时，会通过调用 getObject 方法进行返回。值得注意的是 MyBatis 底层就是通过 FactoryBean 来实现。

【BeanFactory处理】getObjectForBeanInstance

AbstractBeanFactory#getObjectForBeanInstance

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

	// 如果 beanName 以 & 为前缀，但对应的 Bean 不是 FactoryBean 类型，则抛异常
	if (BeanFactoryUtils.isFactoryDereference(name)) {
		if (beanInstance instanceof NullBean) {
			return beanInstance;
		}
		if (!(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(...);
		}
	}

	// 校验已获取的 Bean 
	// 1、如果该 Bean 不是 FactoryBean 类型，直接返回
	// 2、如果是 FactoryBean 类型，且 beanName 以 & 为前缀，说明想获取的是 FactoryBean，也是直接返回
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}

    // 从缓存中尝试获取 FactoryBean 创建的对象
	Object object = null;
	if (mbd == null) {
		object = getCachedObjectForFactoryBean(beanName);
	}
	if (object == null) {
		// 到这里已确定 beanInstance 一定是 FactoryBean 类型，所以进行强转
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
		// 获取 Bean 对应的 BeanDefinition
		if (mbd == null && containsBeanDefinition(beanName)) {
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		// 当前 Bean 是否是用户定义的，而不是应用程序自己定义的
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		// 解析 FactoryBean 的核心方法
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

这个方法很简单，大多是些辅助代码以及一些功能性的判断，真正的核心代码在 getObjectFromFactoryBean 方法中。

【BeanFactory处理】getObjectFromFactoryBean

AbstractBeanFactory#getObjectFromFactoryBean

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    // 如果是单例 Bean 
	if (factory.isSingleton() && containsSingleton(beanName)) {
		synchronized (getSingletonMutex()) {
		    // 尝试从缓存中获取，缓存中存储的是已经通过 FactoryBean 创建的 bean 
			Object object = this.factoryBeanObjectCache.get(beanName);
			if (object == null) {
			    // 通过 FactoryBean 创建真正的 Bean，其实就是调用了 factory.getObject() 方法
				object = doGetObjectFromFactoryBean(factory, beanName);
				// 这里大概是在执行上一步 doGetObjectFromFactoryBean 方法过程中，该 bean 已被其它线程创建并缓存了起来
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				} else { // 如果没有
					if (shouldPostProcess) { 
                        // Bean 是否要进行后置处理
						...
						try {
						    // 执行后置处理器
							object = postProcessObjectFromFactoryBean(object, beanName);
						} // catch ...
					}
					...
				}
			}
			return object;
		}
	}
	else { 
        // 如果不是单例 bean 
	    // 通过 FactoryBean 创建真正的 bean 
		Object object = doGetObjectFromFactoryBean(factory, beanName);
		if (shouldPostProcess) {
			try {
			    // 执行后置处理器
				object = postProcessObjectFromFactoryBean(object, beanName);
			} // catch ...
		}
		return object;
	}
}

【创建Bean的入口】createBean

AbstractAutowireCapableBeanFactory#createBean

接着进入创建 Bean 的下一步 createBean 方法：

这个 createBean 方法是定义在 AbstractBeanFactory 中的抽象方法，最终的实现是交给了 AbstractAutowireCapableBeanFactory 类实现，所以接下来我们看看 AbstractAutowireCapableBeanFactory 这个类。

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {

	RootBeanDefinition mbdToUse = mbd;

	// 根据设置的 class 属性或 className 来解析得到 Class 引用赋值给 RootBeanDefinition
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// 对 override 属性进行标记和验证，本质上是处理 lookup-method 和 replaced-method 标签
	try {
		mbdToUse.prepareMethodOverrides();
	} // catch...

	try {
		// 执行 BeanPostProcessors 后置处理器，如果有 Bean 返回，则不执行接下来创建 Bean 的操作，直接返回该 Bean
        // 实际上这里的代码是不走的
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	} // catch...

	try {
	    // 最后会执行到这里，这是创建 Bean 的核心方法
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		return beanInstance;
	} // catch...
}

【创建Bean的主逻辑】doCreateBean

AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {

	BeanWrapper instanceWrapper = null;
	// 如果是单例，尝试获取对应的 BeanWrapper
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
        // 这里是一个关键点，使用对应的策略（工厂方法、构造函数）创建 Bean 实例，以及简单初始化
        // BeanWrapper 包装了 Bean 对象，并封装类型转换器
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 从 BeanWrapper 中获取包装的 Bean 实例
	final Object bean = instanceWrapper.getWrappedInstance();
	// 从 BeanWrapper 获取包装 Bean 的 Class 引用
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 执行 MergedBeanDefinitionPostProcessor 后置处理器。
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			// catch...
			mbd.postProcessed = true;
		}
	}

	// 检查是否需要提前曝光，避免循环依赖（循环依赖问题会在后面详细讨论）
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 开始初始化 Bean 
	Object exposedObject = bean;
	try {
	    // 对 Bean 进行填充，将各个属性值注入，如果存在依赖的 Bean 则进行递归初始化
		populateBean(beanName, mbd, instanceWrapper);
		// 执行一系列的初始化方法
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	// catch...

    // 再次检查是否循环依赖
	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 
				}
			}
		}
	}

	// 注册 DisposableBean
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	// catch...

	return exposedObject;
}

该方法整体流程如下：

1. 如果是单例，尝试从缓存中获取 Bean 的包装器 BeanWrapper，并清除缓存
2. 如果不存在对应的 Wrapper，则说明 Bean 未被实例化，创建 Bean 实例
3. 执行 MergedBeanDefinitionPostProcessor 后置处理器
4. 检查是否需要提前曝光，避免循环依赖
5. 属性填充，将所有属性填充至 Bean 的实例中
6. 执行一系列的初始化方法（回调钩子接口）
7. 再次检查是否存在循环依赖
8. 注册 DisposableBean

该过程中有几个需要重点介绍的方法，分别是创建 Bean 实例的 createBeaninstance 方法、注入 Bean 属性的 populateBean 方法以及执行 Bean 初始化方法的 initializeBean 方法。

【创建Bean的核心逻辑】createBeaninstance

AbstractAutowireCapableBeanFactory#createBeaninstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    
	Class<?> beanClass = resolveBeanClass(mbd, beanName);
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(...);
	}

    // 如果有用于创建 Bean 实例的回调方法
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
    
    // 如果工厂方法不为空，则使用工厂方法进行实例化
	if (mbd.getFactoryMethodName() != null)  {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 利用构造函数进行实例化，解析并确定目标构造函数
	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);
		}
	}

	// 根据参数确定构造函数
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 使用默认的构造函数
	return instantiateBean(beanName, mbd);
}

以上主要分为：

• 使用工厂方法进行实例化
• 通过构造函数实例化

不管是通过工厂方法还是构造方法来实例化对象，到这里得到的也仅仅是一个 Bean 的最初实例，还不是我们最终期望的 Bean，因为后面还需要对 Bean 实例进行初始化处理，注入相应的属性值等。

【属性填充】populateBean

AbstractAutowireCapableBeanFactory#populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    
    // 判断实例化的 Bean 是否为空
	if (bw == null) {
	    // 返回是否有为此 Bean 定义的属性值，如果有，则抛异常，提示 “无法将属性值应用于空实例”
		if (mbd.hasPropertyValues()) {
			throw new BeanCreationException(...);
		}
		// 没有，则跳过属性填充阶段以获取空实例
		else {
			return;
		}
	}

	// 在设置属性之前，先执行 InstantiationAwareBeanPostProcessors 后置处理器，这些后置处理器可以用其它方式注入属性，如字段注入。
	boolean continueWithPropertyPopulation = true;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}
    // 当使用了 InstantiationAwareBeanPostProcessors 后置处理器注入属性，则结束属性注入流程，直接返回
	if (!continueWithPropertyPopulation) {
		return;
	}

    // 获取 Bean 实例的属性值集合
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

		// 根据名称自动注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}

		// 根据类型自动注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

    // 返回此工厂是否拥有 InstantiationAwareBeanPostProcessor
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// 是否进行依赖检查
	boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

	if (hasInstAwareBpps || needsDepCheck) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		// 在属性注入前执行 InstantiationAwareBeanPostProcessor 后置处理器
        // @Autoware 的实现原理 
        // 这里涉及一个极其重要的后置处理器实现 AutowiredAnnotationBeanPostProcessor，其主要用来处理 @Autowired 注解，这部分会在后面详细讨论
		if (hasInstAwareBpps) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
            }
		}
		// 进行依赖检查
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}

	if (pvs != null) {
        // 这里进行属性的类型转换，例如将字符串的 id 转为数字的 id
	    // 执行属性注入，这里才真正的将属性进行填充，将解析和类型转换好的属性列表（pvs）赋值到包装对象（bw）上
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		
   	// ...
    
    // 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();
            // 如果是 JDK 类型，返回的是 TypeStringValue
            // 如果是要注入其他的 Bean，则是 RuntimeBeanReference 类型
            Object originalValue = pv.getValue();
            // 这里是个重点，进行属性的解析，如果是 JDK 类型则返回的对应 JDK 的类型
            // 如果是 RuntimeBeanReference，则会递归调用工厂的 getBean 获取到要注入的对象
            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);
            }
            if (resolvedValue == originalValue) {
                if (convertible) {
                    // 将类型转换好的数据赋值给 PropertyValue
                    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();
    }

    try {
        // 这里才真正的对创建的包装对象进行了属性的赋值，底层肯定是用到了反射了
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    }
    catch (BeansException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

【初始化】initializeBean

AbstractAutowireCapableBeanFactory#initializeBean

接着进入 initializeBean 方法，在该方法中会回调许多在 Bean 初始化阶段执行的方法。

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

    // 回调 Aware 系列接口
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

    // 回调 BeanPostProcessor 后置处理器的 postProcessBeforeInitialization 方法
	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
	    // 回调 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()) {
	    // 回调 BeanPostProcessor 后置处理器的 postProcessAfterInitialization 方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

可以看到，在 Bean 的初始化阶段，分别回调了 Aware 系列接口、BeanPostProcessor 后置处理器、InitializingBean。这三个接口都属于 Spring 的钩子接口，是 Spring 开放出来的扩展接口，可以影响 Bean 的生命周期。

回调 Aware 系列接口

private void invokeAwareMethods(final String beanName, final Object bean) {   
    
	if (bean instanceof Aware) {
	    // 如果当前 Bean 继承了 BeanNameAware 接口，则回调接口中的 setBeanName 方法，并传递 beanName 参数
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		
		// 这个 BeanClassLoaderAware 接口传递的是 ClassLoader
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		
		// 这个 BeanFactoryAware 接口传递的是 AbstractAutowireCapableBeanFactory
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

这里被回调的 Aware 接口有三个，分别是 BeanNameAware 、BeanClassLoaderAware、BeanFactoryAware。

回调 BeanPostProcessor 后置处理器的 postProcessBeforeInitialization 方法

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) {

	Object result = existingBean;
	
	// getBeanPostProcessors 方法获取所有的 BeanPostProcessor 后置处理器的实现
    // 并循环执行 postProcessBeforeInitialization 方法，参数是当前 Bean 以及 beanName
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

其中有一个后置处理器的实现 ApplicationContextAwareProcessor ，其用来对剩余的 Aware 接口进行回调：

@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
    AccessControlContext acc = null;
    //...

    invokeAwareInterfaces(bean);
    //...

	return bean;
}

private void invokeAwareInterfaces(Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}
}

回调 InitializingBean 的 afterPropertiesSet 方法

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	//..
    ((InitializingBean) bean).afterPropertiesSet();
	//..
}

回调 BeanPostProcessor 后置处理器的 postProcessAfterInitialization 方法

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) {
	Object result = existingBean;
	// getBeanPostProcessors 方法获取所有的 BeanPostProcessor 后置处理器的实现
    // 并循环执行 postProcessAfterInitialization 方法，参数是当前 Bean 以及 beanName
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

注意 Spring AOP 就是通过 BeanPostProcessor 来实现的，创建代理对象就是在初始化阶段执行 postProcessAfterInitialization 中完成的，有一个 AspectJAwareAdvisorAutoProxyCreator 这个类。

到这里，创建 Bean 的核心流程就讨论结束，我这里做一个完整的归纳：

1. 调用者通过 getBean 方法调用工厂获取一个 Bean，传入的 name 可以是 Bean 的 id；也可以是别名；也可以是 &name，表示获取原始的 FactoryBean 对象。
2. 通过一系列的方法重载，最后会到达 AbstractBeanFactory#doGetBean 方法处理，先要对传入的 name 进行解析，解析出 id。
3. 接下来会尝试从单例缓存池中获取已创建好的对象，Spring 底层提供了三级缓存（三个Map）体系来解决循环依赖的问题：singletonObjects、earlySingletonObjects、singletonFactories。
4. 如果拿到了缓存数据：对 FactoryBean 类型进行判定，决定是否直接返回缓存对象还是返回 FactoryBean.getObject()。
5. 如果没有拿到缓存数据，说明要新建一个 Bean。
   • 首先进行父子容器的处理，当父容器不为空并且获取的 Bean 不在子容器定义时，从父容器递归获取。
   • 将 Bean 标记为已经创建（或将要创建）,即将 beanName 加入 alreadyCreated 集合。
   • 父子 Bean 的处理，将子标签 bean 的各个属性合并到父标签，生成 RootBeanDefinition。
   • 处理 depends-on，若存在依赖则需要递归实例化依赖的 bean。
   • 根据不同的作用域创建 Bean 实例，分为单例、原型和其他，这三种创建的时候都会调用 createBean 方法，这个方法由 AbstractAutowireCapableBeanFactory 提供。
     • 首先需要处理 lookup-method 和 replaced-method。
     • 然后要将创建实例的职责交给 doCreateBean，这个方法大概有三个重要的步骤：
       1. 创建实例 createBeaninstance：使用工厂方法实例化还是使用构造函数，默认是无参构造。这里返回的是包装对象，里面还封装了类型转换器的信息。
       2. 属性填充 populateBean：填充的时候设计到类型转换，底层再通过反射对创建的包装对象进行属性赋值。
       3. 初始化 initializeBean：在这个步骤，分别回调了 Aware 系列接口、BeanPostProcessor 后置处理器、InitializingBean。
6. 如果 getBean 的时候传入了类型（getBean("user", User.clsss)），则需要进行类型转换后返回。