AbstractAutowireCapableBeanFactory
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory抽象类，继承AbstractBeanFactory，实现AutowireCapableBeanFactory接口，完成Bean的创建。
源码解析
createBean 方法
createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法，创建 Bean，方法如下：
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// <1> 获取 `mbd` 对应的 Class 对象，确保当前 Bean 能够被创建出来
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 如果这里获取到了 Class 对象，但是 `mbd` 中没有 Class 对象的相关信息，表示这个 Class 对象是动态解析出来的
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
// 复制一份 `mbd`，并设置 Class 对象，因为动态解析出来的 Class 对象不被共享
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
// <2> 对所有的 MethodOverride 进行验证和准备工作（确保存在对应的方法，并设置为不能重复加载）
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.
/**
* <3> 在实例化前进行相关处理，会先调用所有 {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation}
* 注意，如果这里返回对象不是 `null` 的话，不会继续往下执行原本初始化操作，直接返回，也就是说这个方法返回的是最终实例对象
* 可以通过这种方式提前返回一个代理对象，例如 AOP 的实现，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）
*/
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 {
// <4> 创建 Bean 对象 `beanInstance`，如果上一步没有返回代理对象，就只能走常规的路线进行 Bean 的创建了
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
// <5> 将 `beanInstance` 返回
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);
}
}
resolveBeanClass 方法
resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)，获取beanName的 Class 对象，方法如下：
// AbstractBeanFactory.java
@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
// 有 Class 对象则直接返回
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
// 否则，调用 `doResolveBeanClass(...)` 方法，加载出一个 Class 对象
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
} else {
return doResolveBeanClass(mbd, typesToMatch);
}
}
// ... 省略 catch 各种异常
}
doResolveBeanClass 方法
// AbstractBeanFactory.java
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
throws ClassNotFoundException {
// 获取 ClassLoader 加载器
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());
}
}
}
}
// 获取 `className`
String className = mbd.getBeanClassName();
if (className != null) {
// 根据 BeanExpressionResolver 表达式处理器计算出 `className` 对应的结果
// 可能还是一个类名称，也可能是一个 Class 对象
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);
}
}
// 如果被处理过，则根据这个 `className` 创建一个 Class 对象
// 创建的 Class 对象不会设置到 `mbd` 中
if (freshResolve) {
// When resolving against a temporary class loader, exit early in order
// to avoid storing the resolved Class in the bean definition.
if (dynamicLoader != null) {
try {
return dynamicLoader.loadClass(className);
}
catch (ClassNotFoundException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
}
}
}
return ClassUtils.forName(className, dynamicLoader);
}
}
// Resolve regularly, caching the result in the BeanDefinition...
// 让 RootBeanDefinition 自己解析出 Class 对象
return mbd.resolveBeanClass(beanClassLoader);
}
prepareMethodOverrides方法
对应代码段：
// AbstractAutowireCapableBeanFactory#createBean(...) 方法
try {
// <2> 对所有的 MethodOverride 进行验证和准备工作（确保存在对应的方法，并设置为不能重复加载）
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
<lookup-method />和<replace-method />标签会被解析成LookupOverride和ReplaceOverride对象，用于实现或覆盖某个方法，这里会进行验证和准备工作，过程如下：
// AbstractBeanDefinition.java
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// Check that lookup methods exist and determine their overloaded status.
if (hasMethodOverrides()) { // 如果存在 `methodOverrides`
// 获取所有的 override method，遍历进行处理
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
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.
mo.setOverloaded(false);
}
}
resolveBeforeInstantiation方法
对应代码段：
// AbstractAutowireCapableBeanFactory#createBean(...) 方法
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
/**
* <3> 在实例化前进行相关处理，会先调用所有 {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation}
* 注意，如果这里返回对象不是 `null` 的话，不会继续往下执行原本初始化操作，直接返回，也就是说这个方法返回的是最终实例对象
* 可以通过这种方式提前返回一个代理对象，例如 AOP 的实现，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）
*/
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);
}
resolveBeforeInstantiation 方法
// AbstractAutowireCapableBeanFactory.java
@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.
// 如果 RootBeanDefinition 不是用户定义的（由 Spring 解析出来的），并且存在 InstantiationAwareBeanPostProcessor 处理器
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;
}
applyBeanPostProcessorsBeforeInstantiation方法
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 存在 InstantiationAwareBeanPostProcessor 处理器，则进行下面的处理
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
可以查看InstantiationAwareBeanPostProcessor源码解析
InstantiationAwareBeanPostProcessor
doCreateBean 方法
doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)，创建 Bean，方法如下：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Bean的实例化阶段，会将Bean的实例对象封装成BeanWrapperImpl包装对象
BeanWrapper instanceWrapper = null;
// 如果是单例模式，则先尝试从factoryBeanInstanceCache缓存中获取实例对象，并从缓存中移除
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 若缓存中没有可用的BeanWrapper，则调用createBeanInstance方法创建Bean实例，将BeanDefinition转换为BeanWrapper对象。
// 使用合适的实例化策略来创建 Bean 的实例：工厂方法、构造函数自动注入、简单初始化
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从BeanWrapper中提取实际Bean实例。
final Object bean = instanceWrapper.getWrappedInstance();
// 获取Bean的类型。
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
// 将解析后的Bean类型记录到Bean定义中，供后续流程（如依赖注入、AOP代理）使用。
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// <2> 对 RootBeanDefinition（合并后）进行加工处理
synchronized (mbd.postProcessingLock) { // 加锁，线程安全
// <2.1> 如果该 RootBeanDefinition 没有处理过，则进行下面的处理
if (!mbd.postProcessed) {
try {
/**
* <2.2> 对 RootBeanDefinition（合并后）进行加工处理
* 调用所有 {@link MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition}
* 【重要】例如有下面两个处理器：
* 1. AutowiredAnnotationBeanPostProcessor 会先解析出 @Autowired 和 @Value 注解标注的属性的注入元信息，后续进行依赖注入；
* 2. CommonAnnotationBeanPostProcessor 会先解析出 @Resource 注解标注的属性的注入元信息，后续进行依赖注入，
* 它也会找到 @PostConstruct 和 @PreDestroy 注解标注的方法，并构建一个 LifecycleMetadata 对象，用于后续生命周期中的初始化和销毁
*/
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
// <2.3> 设置该 RootBeanDefinition 被处理过，避免重复处理
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// <3> 提前暴露这个 `bean`，如果可以的话，目的是解决单例模式 Bean 的循环依赖注入
// <3.1> 判断是否可以提前暴露
boolean earlySingletonExposure = (mbd.isSingleton() // 单例模式
&& this.allowCircularReferences // 允许循环依赖，默认为 true
&& isSingletonCurrentlyInCreation(beanName)); // 当前单例 bean 正在被创建，在前面已经标记过
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
/**
* <3.2>
* 创建一个 ObjectFactory 实现类，用于返回当前正在被创建的 `bean`，提前暴露，保存在 `singletonFactories` （**三级 Map**）缓存中
*
* 可以回到前面的 {@link AbstractBeanFactory#doGetBean#getSingleton(String)} 方法
* 加载 Bean 的过程会先从缓存中获取单例 Bean，可以避免单例模式 Bean 循环依赖注入的问题
*/
addSingletonFactory(beanName,
// ObjectFactory 实现类
() -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
// 开始初始化 `bean`
Object exposedObject = bean;
try {
// <4> 对 `bean` 进行属性填充，注入对应的属性值
populateBean(beanName, mbd, instanceWrapper);
// <5> 初始化这个 `exposedObject`，调用其初始化方法
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);
}
}
// <6> 循环依赖注入的检查
if (earlySingletonExposure) {
// <6.1> 获取当前正在创建的 `beanName` 被依赖注入的早期引用
// 注意，这里有一个入参是 `false`，不会调用上面第 `3` 步的 ObjectFactory 实现类
// 也就是说当前 `bean` 如果出现循环依赖注入，这里才能获取到提前暴露的引用
Object earlySingletonReference = getSingleton(beanName, false);
// <6.2> 如果出现了循环依赖注入，则进行接下来的检查工作
if (earlySingletonReference != null) {
// <6.2.1> 如果 `exposedObject` 没有在初始化阶段中被改变，也就是没有被增强
// 则使用提前暴露的那个引用
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
// <6.2.2> 否则，`exposedObject` 已经不是被别的 Bean 依赖注入的那个 Bean
else if (!this.allowRawInjectionDespiteWrapping // 是否允许注入未加工的 Bean，默认为 false，这里取非就为 true
&& hasDependentBean(beanName)) { // 存在依赖 `beanName` 的 Bean（通过 `depends-on` 配置）
// 获取依赖当前 `beanName` 的 Bean 们的名称（通过 `depends-on` 配置）
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 接下来进行判断，如果依赖 `beanName` 的 Bean 已经创建
// 说明当前 `beanName` 被注入了，而这里最终的 `bean` 被包装过，不是之前被注入的
// 则抛出异常
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 {
/**
* <7> 为当前 `bean` 注册 DisposableBeanAdapter（如果需要的话），用于 Bean 生命周期中的销毁阶段
* 可以看到 {@link DefaultSingletonBeanRegistry#destroySingletons()} 方法
*/
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// <8> 返回创建好的 `exposedObject` 对象
return exposedObject;
}
Bean 的实例化
createBeanInstance方法
// Bean的实例化阶段，会将Bean的实例对象封装成BeanWrapperImpl包装对象
BeanWrapper instanceWrapper = null;
// 如果是单例模式，则先尝试从factoryBeanInstanceCache缓存中获取实例对象，并从缓存中移除
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 若缓存中没有可用的BeanWrapper，则调用createBeanInstance方法创建Bean实例，将BeanDefinition转换为BeanWrapper对象。
// 使用合适的实例化策略来创建 Bean 的实例：工厂方法、构造函数自动注入、简单初始化
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从BeanWrapper中提取实际Bean实例。
final Object bean = instanceWrapper.getWrappedInstance();
// 获取Bean的类型。
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
// 将解析后的Bean类型记录到Bean定义中，供后续流程（如依赖注入、AOP代理）使用。
mbd.resolvedTargetType = beanType;
}
Bean 的实例化阶段，会将 Bean 的实例对象封装成BeanWrapperImpl包装对象
PropertyAccessor、BeanWrapper、BeanWrapperImpl
createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法，创建一个 Bean 的实例对象，如下：
// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 从 Bean 定义中解析出 Bean 的 Class 对象。
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 若 Class 是非 public 且不允许非公开访问（!mbd.isNonPublicAccessAllowed()），抛出异常。
// 意义：确保 Bean 的类符合访问权限要求。
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());
}
// 如果存在 Supplier 实例化回调接口，则使用给定的回调方法创建一个实例对象
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果配置了 factory-method 工厂方法，则调用该方法来创建一个实例对象
// 通过 @Bean 标注的方法会通过这里进行创建
if (mbd.getFactoryMethodName() != null) {
// 这个过程非常复杂，你可以理解为：
// 找到最匹配的 Method 工厂方法，获取相关参数（依赖注入），然后通过调用该方法返回一个实例对象（反射机制）
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 判断这个 RootBeanDefinition 的构造方法是否已经被解析出来了
// 因为找到最匹配的构造方法比较繁琐，找到后会设置到 RootBeanDefinition 中，避免重复这个过程
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);
}
}
// 如果最匹配的构造方法还没开始解析，那么需要找到一个最匹配的构造方法，然后创建一个实例对象
// 尝试通过 SmartInstantiationAwareBeanPostProcessor 处理器的 determineCandidateConstructors 方法来找到一些合适的构造方法，如 AutowiredAnnotationBeanPostProcessor。
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 条件：满足以下任一条件时触发构造方法自动注入：
// 1.找到候选构造方法（如 @Autowired 标注的构造方法）。
// 2.Bean 定义的自动注入模式为构造器注入（AUTOWIRE_CONSTRUCTOR）。
// 3.Bean 定义中明确指定了构造参数。
// 4.方法调用时传入了参数（args）。
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR
|| mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))
{
// 找到最匹配的构造方法，如果 ctors 不为空，会从这里面找一个最匹配的，
// 并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）
return autowireConstructor(beanName, mbd, ctors, args);
}
// 如果还不满足，那么尝试获取优先的构造方法
// 某些特殊 Bean 定义（如 ClassDerivedBeanDefinition）可能指定优先使用的构造方法。
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
// 如果存在优先的构造方法，则从里面找到最匹配的一个，并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）
return autowireConstructor(beanName, mbd, ctors, null);
}
// 如果上面多种情况都不满足，那只能使用兜底方法了，直接调用默认构造方法返回一个实例对象（反射机制）
return instantiateBean(beanName, mbd);
}
obtainFromSupplier 方法
obtainFromSupplier(Supplier<?> instanceSupplier, String beanName)方法，通过Supplier创建Bean的实例，将其包装为BeanWrapper，并处理线程本地状态以确保依赖注入的正确性，方法如下：
// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
Object instance;
// currentlyCreatedBean 是一个 ThreadLocal<String>，用于跟踪当前线程正在创建的 Bean 名称。
// 保存当前线程的原始状态 (outerBean)，然后设置新的状态为当前正在创建的 beanName，防止循环依赖或并发问题。
String outerBean = this.currentlyCreatedBean.get();
// 设置当前线程正在创建的 Bean 的名称
this.currentlyCreatedBean.set(beanName);
try {
// 调用 Supplier 的 get()，返回一个实例对象
instance = instanceSupplier.get();
}
finally {
if (outerBean != null) {
// finally 块确保无论是否抛出异常，线程的原始状态 (outerBean) 都会被恢复，避免状态污染。
this.currentlyCreatedBean.set(outerBean);
}
else {
this.currentlyCreatedBean.remove();
}
}
// 如果 Supplier 返回 null，则创建一个 NullBean 作为占位符，避免后续流程因空指针中断。
if (instance == null) {
instance = new NullBean();
}
// 将实例包装为 BeanWrapperImpl，提供统一的属性访问接口（如设置属性值、调用方法）。
BeanWrapper bw = new BeanWrapperImpl(instance);
// initBeanWrapper(bw) 初始化包装器，注册 PropertyEditor 或自定义配置。
initBeanWrapper(bw);
return bw;
}
instantiateUsingFactoryMethod 方法
通过factoryMethodName工厂方法创建一个实例对象，例如 XML 配置的factory-method属性或者@Bean标注的方法都会解析成factoryMethodName属性。
这个过程非常复杂，你可以理解为去找到最匹配的Method工厂方法，获取相关入参（依赖注入），然后调用该方法返回一个实例对象（反射机制），方法如下：
// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}
具体步骤查看ConstructorResolver源码解析：
ConstructorResolver
autowireConstructor方法
这个过程和上一个方法一样非常复杂，不过差不太多，你可以理解为去找到当前 Bean 的构造方法，获取相关入参（构造器注入），然后调用该构造方法返回一个实例对象（反射机制），方法如下：
// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
具体步骤查看ConstructorResolver源码解析：
ConstructorResolver
instantiateBean 方法
兜底方法，如果构造方法找不到（或者已经解析出来的构造方法），则直接使用默认的构造方法（或者已经解析出来的构造方法），返回一个实例对象，方法如下：
// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
// 安全模式
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
// 获得 InstantiationStrategy 对象，并使用它，创建 Bean 对象
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
// 获得 InstantiationStrategy 对象，并使用它，创建 Bean 对象
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
可以看到会通过 CglibSubclassingInstantiationStrategy#instantiate(...)方法创建一个实例对象，该方法如下：
// SimpleInstantiationStrategy.java
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
// <1> 没有 MethodOverride 对象，也就是没有需要覆盖或替换的方法，则直接使用反射机制进行实例化即可
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// <1.1> 尝试从 RootBeanDefinition 获得已经解析出来的构造方法 `resolvedConstructorOrFactoryMethod`
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
// <1.2> 没有解析出来的构造方法，则获取默认的构造方法
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
// 如果是接口，抛出 BeanInstantiationException 异常
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
// 从 clazz 中，获得构造方法
if (System.getSecurityManager() != null) { // 安全模式
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
constructorToUse = clazz.getDeclaredConstructor();
}
// 标记 resolvedConstructorOrFactoryMethod 属性
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// <1.3> 通过这个构造方法实例化一个对象（反射机制）
return BeanUtils.instantiateClass(constructorToUse);
}
// <2> 否则，通过 CGLIB 生成一个子类对象
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
对 RootBeanDefinition 加工处理
applyMergedBeanDefinitionPostProcessors方法
对应代码段：
// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// Allow post-processors to modify the merged bean definition.
// <2> 对 RootBeanDefinition（合并后）进行加工处理
synchronized (mbd.postProcessingLock) { // 加锁，线程安全
// <2.1> 如果该 RootBeanDefinition 没有处理过，则进行下面的处理
if (!mbd.postProcessed) {
try {
/**
* <2.2> 对 RootBeanDefinition（合并后）进行加工处理
* 调用所有 {@link MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition}
* 【重要】例如有下面两个处理器：
* 1. AutowiredAnnotationBeanPostProcessor 会先解析出 @Autowired 和 @Value 注解标注的属性的注入元信息，后续进行依赖注入；
* 2. CommonAnnotationBeanPostProcessor 会先解析出 @Resource 注解标注的属性的注入元信息，后续进行依赖注入，
* 它也会找到 @PostConstruct 和 @PreDestroy 注解标注的方法，并构建一个 LifecycleMetadata 对象，用于后续生命周期中的初始化和销毁
*/
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
// <2.3> 设置该 RootBeanDefinition 被处理过，避免重复处理
mbd.postProcessed = true;
}
}
通过MergedBeanDefinitionPostProcessor处理器对该RootBeanDefinition进行加工处理
MergedBeanDefinitionPostProcessor
提前暴露当前 Bean
addSingletonFactory方法
对应代码段：
// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// 提前暴露这个 `bean`，如果可以的话，目的是解决单例模式 Bean 的循环依赖注入
// 判断是否可以提前暴露
// mbd.isSingleton()仅对单例Bean处理循环依赖（原型Bean不支持循环依赖）
// this.allowCircularReferences是否允许循环依赖（默认true，可通过配置关闭）。
// isSingletonCurrentlyInCreation(beanName)判断当前单例bean是否正在被创建，在前面已经标记过
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");
}
// 创建一个ObjectFactory实现类，用于返回当前正在被创建的bean，提前暴露，保存在singletonFactories（三级缓存）
// 前面的AbstractBeanFactory#doGetBean#getSingleton(String)，加载Bean的过程会先从缓存中获取单例Bean，避免单例模式Bean循环依赖
// 一级缓存（singletonObjects）：存储完全初始化好的单例 Bean。
// 二级缓存（earlySingletonObjects）：存储提前暴露的 Bean 早期引用（尚未完成属性填充）。
// 三级缓存（singletonFactories）：存储生成早期引用的 ObjectFactory。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
通过 Lambda 表达式创建一个ObjectFactory实现类，如下：
// AbstractAutowireCapableBeanFactory.java
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
// RootBeanDefinition 不是用户定义的（由 Spring 解析出来的）
if (!mbd.isSynthetic()
&& hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
SmartInstantiationAwareBeanPostProcessor对这个提前暴露的对象进行处理，最终会返回这个提前暴露的对象
SmartInstantiationAwareBeanPostProcessor
然后调用addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)方法，如下：
// DefaultSingletonBeanRegistry.java
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集合（三级 Map）中添加当前beanName和singletonFactory（ObjectFactory实现类）的映射关系；
从earlySingletonObjects集合（二级 Map）中移除当前beanName；
往registeredSingletons集合（已注册的 Bean 的名称集合）中添加当前beanName。
属性填充
对应代码段：
// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// 开始初始化bean
Object exposedObject = bean;
try {
// 在创建好实例对象后，bean的属性还没有赋值，所以将这个实例对象的相关属性进行赋值
populateBean(beanName, mbd, instanceWrapper);
// 初始化这个exposedObject，调用其初始化方法
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方法
populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)方法，属性填充，如下：
// AbstractAutowireCapableBeanFactory.java
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 如果实例对象为空，则进行下面的判断
if (bw == null) {
// 这个Bean有属性，则抛出异常
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
// 否则，不用属性填充，直接return
else {
return;
}
}
// 实例化阶段的后置处理，如果满足这两个条件
// mbd.isSynthetic()，RootBeanDefinition不是用户定义的（由 Spring 解析出来的）
// 判断是否有InstantiationAwareBeanPostProcessor处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 遍历所有的 BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 如果为 InstantiationAwareBeanPostProcessor 类型
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 对实例化对象进行后置处理
// 注意如果返回false，直接return，不会调用后面的 InstantiationAwareBeanPostProcessor 处理器，也不会进行接下来的属性填充
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 获取pvs，承载当前对象的属性值
// 检查 Bean 定义（BeanDefinition）中是否已配置了显式属性值（如 XML 中 <property> 标签或 @Value 注解）。
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 获取这个Bean的注入模式，默认为AUTOWIRE_NO。
// 可通过@Bean(autowire = Autowire.BY_NAME)或XML中autowire="byName"指定。
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
// 如果注入模式为AUTOWIRE_BY_NAME或者AUTOWIRE_BY_TYPE，则通过下面的方式获取属性值
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// 将pvs封装成MutablePropertyValues对象newPvs（允许对属性进行相关操作）
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// AUTOWIRE_BY_NAME模式，通过名称获取相关属性值，保存在newPvs中
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// AUTOWIRE_BY_TYPE模式，通过类型获取相关属性值，保存在newPvs中
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
// 将newPvs复制给pvs
pvs = newPvs;
}
// 是否有InstantiationAwareBeanPostProcessor处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 是否需要进行依赖检查，默认为 true
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
// 通过InstantiationAwareBeanPostProcessor处理器（如果有）对pvs进行处理
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 遍历所有的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 如果为InstantiationAwareBeanPostProcessor类型
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// Spring 内置实现
// AutowiredAnnotationBeanPostProcessor解析@Autowired和@Value注解。
// CommonAnnotationBeanPostProcessor解析@Resource注解。
// 调用处理器的postProcessProperties(...)方法，对pvs进行后置处理
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
// 如果上一步的处理结果为空，可能是新版本导致的（Spring 5.1 之前没有上面这个方法），则需要兼容老版本
if (pvsToUse == null) {
// 找到这个 Bean 的所有java.beans.PropertyDescriptor属性描述器（包含这个属性的所有信息）
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 调用处理器的postProcessPropertyValues(...)方法，对 `pvs` 进行后置处理
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
// 如果处理后的 PropertyValues 对象为空，直接return，则不会调用后面的 InstantiationAwareBeanPostProcessor 处理器，也不会进行接下来的属性填充
if (pvsToUse == null) {
return;
}
}
// 将处理后的pvsToUse复制给pvs
pvs = pvsToUse;
}
}
}
// 依赖检查
if (needsDepCheck) {
// 找到这个 Bean 的所有java.beans.PropertyDescriptor属性描述器（包含这个属性的所有信息）
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 依赖检查，如果没有找到对应的属性值，则根据检查策略进行抛出异常（默认不会）
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 如果pvs不为空，则将里面的属性值设置到当前 Bean 对应的属性中（依赖注入）
// 前面找到的属性值并没有设置到 Bean 中，且属性值可能是一个表达式，类型也可能也不对，需要先进行处理和类型转换，然后再设置到该实例对象中
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
InstantiationAwareBeanPostProcessor
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
通过名称获取属性值
autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)方法，通过名称获取相关属性值，如下：
// AbstractAutowireCapableBeanFactory.java
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// <1> 获取当前 Bean 中不满意的非简单类型的属性名称，也就是没有定义属性值的"对象"属性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// <2> 遍历这些对象属性的名称
for (String propertyName : propertyNames) {
// <3> 如果当前容器存在对应的 Bean（通过名称判断）
if (containsBean(propertyName)) {
// <3.1> 根据属性名称获取对应的 `bean` 对象（依赖查找）
Object bean = getBean(propertyName);
// <3.2> 将 `bean` 添加至 `pvs`
pvs.add(propertyName, bean);
// <3.3> 将两个 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");
}
}
}
}
获取当前 Bean 中不满意的非简单类型的属性名称，也就是没有定义属性值的"对象"属性，如下：
// AbstractAutowireCapableBeanFactory.java
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
// 获取已设置的属性值
PropertyValues pvs = mbd.getPropertyValues();
// 找到这个 Bean 的所有 PropertyDescriptor 属性描述器（包含这个属性的所有信息）
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
// 遍历所有属性
for (PropertyDescriptor pd : pds) {
if (pd.getWriteMethod() != null // 有可写方法
&& !isExcludedFromDependencyCheck(pd) // 不忽略
&& !pvs.contains(pd.getName()) // 没有对应的属性值
&& !BeanUtils.isSimpleProperty(pd.getPropertyType())) // 不是简单类型（例如一个实体类）
{
result.add(pd.getName());
}
}
// 返回这些不满意的非简单类型的属性
return StringUtils.toStringArray(result);
}
通过类型获取属性值
autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)方法，通过类型获取相关属性值，如下：
// AbstractAutowireCapableBeanFactory.java
protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// <1> 获取 TypeConverter 类型转换器，用于取代默认的 PropertyEditor 类型转换器
// 例如 Spring 3.0 之后的 ConversionService
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
// <2> 获取当前 Bean 中不满意的非简单类型的属性名称，也就是没有定义属性值的"对象"属性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// <3> 遍历这些对象属性的名称
for (String propertyName : propertyNames) {
try {
// <3> 获取这个属性的 `java.beans.PropertyDescriptor` 属性描述器（包含这个属性的所有信息）
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// <4> 如果不是 Object 类型（对 Object 类类型的 Bean 进行自动装配毫无意义），则尝试找到对应的对象
if (Object.class != pd.getPropertyType()) {
// <5> 找到这个属性的写方法
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
// 是否可以提前初始化
boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
// <6> 创建对应的依赖注入描述对象
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// <7> 依赖注入，找到该属性对应的对象
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
// <8> 如果找到属性对象，则将该其添加至 `pvs`
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
// <9> 将注入的属性对象和当前 Bean 之前的关系保存起来
// 因为该属性可能是一个集合，找到了多个对象，所以这里是一个数组
for (String autowiredBeanName : autowiredBeanNames) {
// 将 `autowiredBeanName` 与 `beanName` 的依赖关系保存
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
// 清空 `autowiredBeanName` 数组
autowiredBeanNames.clear();
}
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
属性值的后置处理
调用InstantiationAwareBeanPostProcessor#postProcessProperties方法，对前面属性值进行处理
在前面的AUTOWIRE_BY_NAME和AUTOWIRE_BY_TYPE两种注入模式中，找到的都是普通对象的属性值，例如@Autowired、@Value和@Resource注解并没有被解析，且默认的注入模式还是AUTOWIRE_NO，那这些注解是如何被解析的呢？Spring 内部有下面两个InstantiationAwareBeanPostProcessor处理器：
AutowiredAnnotationBeanPostProcessor，解析 @Autowired和@Value注解标注的属性，获取对应属性值
CommonAnnotationBeanPostProcessor，会解析@Resource注解标注的属性，获取对应的属性值
属性赋值
applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)方法，属性填充
如果获取到的 pvs 属性值对象不为空，则将里面的属性值设置到当前 Bean 对应的属性中（依赖注入），我们知道前面找到的属性值并没有设置到 Bean 中，且属性值可能是一个表达式，类型也可能也不对，需要先进行处理和类型转换，然后再设置到该实例对象中，方法如下：
// AbstractAutowireCapableBeanFactory.java
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
// <1> 没有相关属性值，则直接 `return` 返回
if (pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
// ------------------------开始属性值的转换与填充------------------------
MutablePropertyValues mpvs = null;
// 定义一个 `original` 集合，承载属性值（未进行转换）
List<PropertyValue> original;
// <2> 如果 `pvs` 是 MutablePropertyValues 类型，则可能已经处理过了
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
// <2.1> 属性值已经转换了，则将这些属性值设置到当前 Bean 中（反射机制），依赖注入的最终实现！！！
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
// <2.2> 没有转换过，则获取所有的属性值集合
original = mpvs.getPropertyValueList();
}
else {
// <2.2> 获取所有的属性值集合
original = Arrays.asList(pvs.getPropertyValues());
}
// 获取 TypeConverter 类型转换器，用于取代默认的 PropertyEditor 类型转换器
// 例如 Spring 3.0 之后的 ConversionService
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.
// <3> 定义一个 `deepCopy` 集合，保存转换后的属性值
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
// <4> 遍历所有的属性值，进行转换（如果有必要）
for (PropertyValue pv : original) {
// <4.1> 已经转换过，则直接添加到 `deepCopy` 中
if (pv.isConverted()) {
deepCopy.add(pv);
}
// <4.2> 否则，开始进行转换
else {
String propertyName = pv.getName();
// 转换之前的属性值
Object originalValue = pv.getValue();
// <4.2.1> 表达式的处理（如果有必要的话），例如你在 XML 配置的属性值为 `${systenm.user}`，则会解析出对应的值
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
// 转换之后的属性值
Object convertedValue = resolvedValue;
// 该属性是否可以转换
boolean convertible = bw.isWritableProperty(propertyName) && // 属性可写
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); // 不包含 `.` 和 `[`
if (convertible) {
// <4.2.2> 使用类型转换器转换属性值（如果有必要的话）
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.
if (resolvedValue == originalValue) { // 属性值没有转换过
if (convertible) {
// <4.2.3> 设置转换后的值，避免上面的各种判断
pv.setConvertedValue(convertedValue);
}
// <4.2.4> 添加到 `deepCopy` 中
deepCopy.add(pv);
}
// 属否则属性值进行了转换
else if (convertible // 可转换的
&& originalValue instanceof TypedStringValue // 属性原始值是字符串类型
&& !((TypedStringValue) originalValue).isDynamic() // 属性的原始类型值不是动态生成的字符串
&& !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) // 属性的原始值不是集合或者数组类型
{
// <4.2.3> 设置转换后的值，避免上面的各种判断
pv.setConvertedValue(convertedValue);
// <4.2.4> 添加到 `deepCopy` 中
deepCopy.add(pv);
}
// 否则
else {
// 这个属性每次都要处理，不能缓存
resolveNecessary = true;
// <4.2.4> 添加到 `deepCopy` 中
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
// <5> 如果属性值不为空，且不需要每次都处理，则设置为已转换
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
// <6> 将属性值设置到当前 Bean 中（反射机制），依赖注入的最终实现！！！
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
初始化 Bean
对应代码段：
// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// 开始初始化bean
Object exposedObject = bean;
try {
// 在创建好实例对象后，bean的属性还没有赋值，所以将这个实例对象的相关属性进行赋值
populateBean(beanName, mbd, instanceWrapper);
// 初始化这个exposedObject，调用其初始化方法
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);
}
}
initializeBean方法
// AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
// 若启用了安全管理器，通过 AccessController.doPrivileged 执行，确保权限控制。
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
// 调用 Bean 实现的 Aware 接口方法，向 Bean 注入底层框架对象。
// BeanNameAware：设置 Bean 的名称。
// BeanClassLoaderAware：设置类加载器。
// BeanFactoryAware：设置 BeanFactory。
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 执行所有 BeanPostProcessor 的 postProcessBeforeInitialization 方法。
// ApplicationContextAwareProcessor：处理更多 Aware 接口（如 ApplicationContextAware、EnvironmentAware），向 Bean 注入 Spring 上下文相关对象。
// CommonAnnotationBeanPostProcessor：处理 @PostConstruct 注解，调用标注的方法。
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 先调用 afterPropertiesSet()，再执行自定义初始化方法。
// InitializingBean 接口：调用 afterPropertiesSet() 方法。
// 自定义 init-method：调用 Bean 定义中指定的初始化方法（通过 XML 或 @Bean(initMethod="...") 配置）。
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
// 执行所有 BeanPostProcessor 的 postProcessAfterInitialization 方法。
// ApplicationListenerDetector：检测 Bean 是否为 ApplicationListener，如果是且为单例，则将其注册到应用上下文，用于监听 Spring 事件。
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
初始化过程如下：
Aware接口的回调，调用invokeAwareMethods(final String beanName, final Object bean)方法，如下：
// AbstractAutowireCapableBeanFactory.java
private void invokeAwareMethods(final String beanName, final Object bean) {
// 如果是 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware，则调用其 setXxx 方法
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
初始化阶段的前置处理，执行所有BeanPostProcessor的postProcessBeforeInitialization方法，如下：
// AbstractAutowireCapableBeanFactory.java
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 遍历所有 BeanPostProcessor
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 初始化的前置处理，返回current处理结果
Object current = processor.postProcessBeforeInitialization(result, beanName);
// 处理结果为空，则直接返回 `result`
if (current == null) {
return result;
}
// 否则，`result` 复制 `current`
result = current;
}
return result;
}
激活自定义的初始化方法，如下：
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// InitializingBean 接口的回调（如果是）
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) { // 安全模式
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
// 调用其 afterPropertiesSet() 方法
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
} catch (PrivilegedActionException pae) {
throw pae.getException();
}
} else {
// 调用其 afterPropertiesSet() 方法
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName)
&& !(isInitializingBean && "afterPropertiesSet".equals(initMethodName))
&& !mbd.isExternallyManagedInitMethod(initMethodName)) {
// <2> 调用通过 `init-method` 指定的初始化方法（反射机制）
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
InitializingBean接口的回调（如果是），调用其afterPropertiesSet()方法- 调用通过
init-method指定的初始化方法（反射机制）
初始化阶段的后置处理，执行所有BeanPostProcessor的postProcessAfterInitialization方法，如下：
// AbstractAutowireCapableBeanFactory.java
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 遍历所有 BeanPostProcessor
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 初始化的后置处理，返回current处理结果
Object current = processor.postProcessAfterInitialization(result, beanName);
// 处理结果为空，则直接返回result
if (current == null) {
return result;
}
// 否则，result复制current
result = current;
}
return result;
}
循环依赖注入的检查
对应代码段：
// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// 当 Bean 是单例且允许循环依赖时（通常为默认情况），earlySingletonExposure 为 true。
if (earlySingletonExposure) {
// 获取当前正在创建的beanName被依赖注入的早期引用
// 检查当前Bean是否已被其他Bean循环依赖注入，并返回其早期引用。
// 参数false：表示不触发创建新Bean，仅检查已存在的早期引用。
Object earlySingletonReference = getSingleton(beanName, false);
// 若存在早期引用（earlySingletonReference != null），说明有循环依赖发生
if (earlySingletonReference != null) {
// 如果exposedObject没有在初始化阶段中被改变，也就是没有被增强
// 则使用提前暴露的那个引用
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
// 如果Bean已被增强
// allowRawInjectionDespiteWrapping 是否允许注入未加工的 Bean，默认为 false，这里取非就为 true
// hasDependentBean(beanName) 是否存在通过 depends-on 显式依赖当前 Bean 的其他 Bean。
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// 获取所有显式依赖当前Bean的其他Bean的名称数组。
// 若 Bean B 在配置中声明了 depends-on="A"，则 getDependentBeans("A") 返回包含 "B" 的数组。
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 接下来进行判断，如果依赖 beanName 的 Bean 已经创建
// 说明当前 beanName 被注入了，而这里最终的 bean 被包装过，不是之前被注入的
// 则抛出异常
for (String dependentBean : dependentBeans) {
// 检查依赖 Bean 是否 仅用于类型检查（如解析泛型），而非实际使用。
// 如果是类型检查创建的 Bean，移除它并返回 true。
// 如果是实际创建的 Bean，保留它并返回 false。
// 意义：过滤掉临时创建的 Bean，只关注实际需要处理的目标。
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
// 当 removeSingletonIfCreatedForTypeCheckOnly 返回 false，说明依赖 Bean 已被实际创建，将其加入集合。
// 最终集合：记录所有 已创建且依赖当前 Bean 的其他 Bean。
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
// 假设 Bean A 被代理（如 AOP），Bean B 显式依赖 A（depends-on="A"）。
// B 在创建时注入了 A 的早期原始对象（未代理）。
// A 初始化完成后被代理，最终版本与早期引用不同。
// B 已持有 A 的原始版本，导致 B 使用的 A 与实际版本不一致。后续会导致代理逻辑（如事务、安全）对 B 无效，引发功能异常。
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.");
// 如何解决此异常？
// 方案一：避免循环依赖
// 调整设计，消除 depends-on 导致的显式循环依赖。
// 方案二：延迟注入
// 使用 @Lazy 注解，让依赖 Bean 在首次使用时才注入最终版本的 Bean：
// @Lazy
// @Autowired
// private A a;
}
}
}
}
注册可销毁的 Bean
对应代码段：
// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
try {
// 在 Bean 初始化完成后，根据其作用域和配置，注册销毁逻辑（如 destroy-method、DisposableBean 接口），以便在容器关闭或作用域结束时执行清理工作。
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
这里会调用registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd)方法，如下：
// AbstractBeanFactory.java
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
// 目的：如果启用了安全管理器，获取当前的安全上下文，确保后续操作在适当的权限下执行。
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
// !mbd.isPrototype() 非原型 Bean：原型（Prototype）作用域的 Bean 由调用者管理生命周期，容器不负责销毁。
// requiresDestruction(bean, mbd)
// 需要销毁：通过 requiresDestruction 判断 Bean 是否有销毁逻辑，如：
// 实现了 DisposableBean 接口。
// 配置了自定义的 destroy-method。
// 存在 DestructionAwareBeanPostProcessor 需要处理。
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
if (mbd.isSingleton()) {
// 将单例 Bean 的销毁逻辑封装为 DisposableBeanAdapter，并注册到容器的 disposableBeans（一个 Map<String, DisposableBean>）。
// DisposableBeanAdapter 的作用：
// 协调销毁步骤，包括：
// 调用 DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()。
// 执行 DisposableBean.destroy() 方法（如果 Bean 实现了该接口）。
// 调用自定义的 destroy-method 方法。
registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
else {
// 将销毁逻辑注册到对应作用域（如 Request、Session）的 Scope 对象中。
Scope scope = this.scopes.get(mbd.getScope());
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
}
// 创建一个 DisposableBeanAdapter 对象封装这个 Bean，往其他模式的 Scope 对象里面注册
// Scope 的作用：管理特定作用域 Bean 的生命周期。例如：
// Request 作用域：在 HTTP 请求结束时触发销毁回调。
// Session 作用域：在 HTTP 会话失效时触发销毁回调。
// registerDestructionCallback：由具体 Scope 实现决定何时调用销毁逻辑。
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}
扫一扫
1015
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
