Spring bean 创建过程源码解析

前言

在上一篇文章    中分析了 Spring 中 bean 的注册过程，就是把配置文件中配置的 bean 的信息加载到内存中，以 BeanDefinition对象的形式存放，该对象中存放了 bean 的相关属性，下面就以 debug 的形式一步步来看下 bean 是如何创建的。

Spring 中 bean 的创建可以说是非常的复杂，方法嵌套很多，为了更好的理清创建过程，画了下面的 UML 图：

从上述 UML 图中，可以看出 bean 的创建主要分为以下几步：

根据 bean 的 name 解析对应的 class

处理 lookup-metod 和 replace-method 子标签

处理初始化前的后置处理器

真正的创建 bean 4.1 创建 bean 实例    4.1.1 工厂方法创建    4.1.2 带参数的构造方法创建    4.1.3 默认的构造方法创建

4.2 添加单例对象的工厂缓存

4.3 填充对象的各种属性    4.3.1 名称注入    4.3.2 类型注入

4.4 处理 init-method 方法    4.4.1 处理 bean 的前置处理器    4.4.2 执行 init-method 方法    4.4.3 处理 bean 的后置处理器

处理 lookup-metod 和 replace-method 子标签

真正的创建 bean
4.1 创建 bean 实例
   4.1.1 工厂方法创建
   4.1.2 带参数的构造方法创建
   4.1.3 默认的构造方法创建

4.3 填充对象的各种属性
   4.3.1 名称注入
   4.3.2 类型注入

创建过程

创建 bean 的代码是在 AbstractAutowireCapableBeanFactory 类中开始创建的，在分析的过程中，会把一些代码省略掉，如异常处理等：

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    // 表示 bean 标签，里面有各种属性
    RootBeanDefinition mbdToUse = mbd;
    // 根据设置的 class 属性或 className 来解析 class，
    Class? resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    // 处理 lookup-method 和 replace-method 子标签
    mbdToUse.prepareMethodOverrides();

    // 给 BeanPostProcessors 机会返回一个代理来代替bean的实例
    // 即在初始化前，应用后置处理器，解析指定的bean是否存在初始化前的短路操作
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }   
    // 创建 bean 
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);   
    return beanInstance;
}

处理 lookup-method 和 replace-method 子标签

这两个标签虽然不常用，但是是很有用的，这里不再细说；在  中 这两个标签会被解析放到 BeanDefinition 对象的 methodOverrides 属性中，表示需要覆盖的方法；所以在创建 bean之前需要解析这两个标签，但是只是预处理：

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    // Check that lookup methods exists.
    MethodOverrides methodOverrides = getMethodOverrides();
    if (!methodOverrides.isEmpty()) {
        SetMethodOverride overrides = methodOverrides.getOverrides();
        synchronized (overrides) {
            for (MethodOverride mo : overrides) {
                prepareMethodOverride(mo);
            }
        }
    }
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
    // 获取对应类的方法的个数
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    if (count == 0) {
        throw new BeanDefinitionValidationException("...");
    }
    // 标记 MethodOverride 未被覆盖，避免了后面参数类型检查的开销
    else if (count == 1) {
        mo.setOverloaded(false);
    }
}

在处理 prepareMethodOverride(MethodOverride mo) 方法为什么只处理方法个数为 1 的情况呢？如果一个类中有多个重载的方法，则调用或增强的时候，还需要进行参数类型的解析才能确定调用的是哪个方法， Spring 把部分功能放在这里提前进行预处理，如果方法只有一个，即没有重载的方法，在后面调用的时候，直接找到该方法调用，不用再去解析参数来确定方法了，这样就可以避免的一些参数类型检查的开销。

实例化的前置处理

如果经过前置处理后的结果不为空，则直接返回，不再进行bean的创建过程，AOP功能就是在这里判断的：

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
    return bean;
}
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class? targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                // bean 的前置处理器
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    // bean 的后置处理器
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

创建 bean

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

    // 最终返回的 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 != null ? instanceWrapper.getWrappedInstance() : null);
    Class? beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    mbd.resolvedTargetType = beanType;

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            // 应用 MergedBeanDefinitionPostProcessors
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }
    // 检查循环依赖：是否是单例 && 是否允许循环依赖 && 当前bean是否正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 为了避免后期的循环依赖，在bean初始化完成前，将创建bean的工厂添加到缓存中，如果其他的bean依赖该bean，直接从缓存中获取对应的工厂创建集合，解决循环依赖，注意是只有单例情况才能这么做
        addSingletonFactory(beanName, new ObjectFactoryObject() {
            public Object getObject() throws BeansException {
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }
    // 初始化 bean
    Object exposedObject = bean;
    // 填充属性
    populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
        // 执行初始化方法，如 init-method 
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    if (earlySingletonExposure) {
        // 只有在检测到循环依赖时才不会为空
        Object earlySingletonReference = getSingleton(beanName, false);
        // 存在循环依赖
        if (earlySingletonReference != null) {
           // 如果 exposedObject 在初始化方法中没有被改变，即没有被增强
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                SetString actualDependentBeans = new LinkedHashSetString(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    // 检测依赖
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // 因为bean创建后，所依赖的bean一定是已经创建完毕的，actualDependentBeans 不为空则表示所依赖的bean还没有创建完，即存在循环依赖
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException("");
                }
            }
        }
    }
    // 根据 score 注册 bean 
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
    return exposedObject;
}

上面创建 bean 的过程很复杂，分为很多步骤，下面再来看看这些步骤：

创建bean实例

创建 bean 的实例，会根据策略使用不同的创建方法，比如说 构造方法创建， 工厂方法创建，默认的构造方法创建等：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 获取 bean 对应的 class 
    Class? beanClass = resolveBeanClass(mbd, 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);
}

参数的构造方法注入

先来看下带参数的构造方法自动注入,

public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
        Constructor?[] chosenCtors, final Object[] explicitArgs) {

    BeanWrapperImpl bw = new BeanWrapperImpl();
    this.beanFactory.initBeanWrapper(bw);

    Constructor? constructorToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;
    // explicitArgs 参数通过 getBean() 方法传入，Object getBean(String name, Object... args)
    if (explicitArgs != null) {
        // 如果 getBean 方法传入了参数，则直接使用
        argsToUse = explicitArgs;
    }
    else {
        // 如果 getBean 方法没有传入参数，则从配置文件进行解析
        Object[] argsToResolve = null;
        // 从缓存中获取
        synchronized (mbd.constructorArgumentLock) {
            constructorToUse = (Constructor?) mbd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                argsToUse = mbd.resolvedConstructorArguments;
                if (argsToUse == null) {
                    argsToResolve = mbd.preparedConstructorArguments;
                }
            }
        }
        if (argsToResolve != null) {
            // 配置的构造方法参数
            argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
        }
    }
    // 该构造没有被缓存，则需要进行解析
    if (constructorToUse == null) {
        boolean autowiring = (chosenCtors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
        ConstructorArgumentValues resolvedValues = null;
        // 参数个数
        int minNrOfArgs;
        if (explicitArgs != null) {
            minNrOfArgs = explicitArgs.length;
        }
        else {
            // 获取配置文件中配置的构造方法参数
            ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
            resolvedValues = new ConstructorArgumentValues();
            // 获取参数个数
            minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
        }
        Constructor?[] candidates = chosenCtors;
        if (candidates == null) {
            Class? beanClass = mbd.getBeanClass();
            candidates = (mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors());
        }
        // 排序构造方法，按照参数个数进行排序
        AutowireUtils.sortConstructors(candidates);
        int minTypeDiffWeight = Integer.MAX_VALUE;
        SetConstructor? ambiguousConstructors = null;
        for (Constructor? candidate : candidates) {
            Class?[] paramTypes = candidate.getParameterTypes();
            if (constructorToUse != null && argsToUse.length  paramTypes.length) {
                // 如果已经找到满足条件的构造方法，则终止
                break;
            }
            if (paramTypes.length  minNrOfArgs) {
                continue;
            }
            ArgumentsHolder argsHolder;
            if (resolvedValues != null) {
                // 构造方法参数的名字
                String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
                if (paramNames == null) {
                    // 如果参数名字为空，则获取参数名称探索器
                    ParameterNameDiscoverer pnd=this.beanFactory.getParameterNameDiscoverer();
                    if (pnd != null) {
                        // 使用探索器获取对应构造方法的参数名称
                       paramNames = pnd.getParameterNames(candidate);
                    }
                    // 根据参数名称和类型创建参数持有者
                argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,getUserDeclaredConstructor(candidate), autowiring);
            }
            else {
                // 构造方法没有参数
                argsHolder = new ArgumentsHolder(explicitArgs);
            }
            // 检查是否有不确定性构造方法的存在，如参数为父子关系
            int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
            if (typeDiffWeight  minTypeDiffWeight) {
                constructorToUse = candidate;
                argsHolderToUse = argsHolder;
                argsToUse = argsHolder.arguments;
                minTypeDiffWeight = typeDiffWeight;
                ambiguousConstructors = null;
            }
            else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                if (ambiguousConstructors == null) {
                    ambiguousConstructors = new LinkedHashSetConstructor?();
                    ambiguousConstructors.add(constructorToUse);
                }
                ambiguousConstructors.add(candidate);
            }
        }

        if (constructorToUse == null) {
            throw new BeanCreationException("...")
        }
        // 将解析的构造方法加入缓存
        if (explicitArgs == null) {
            argsHolderToUse.storeCache(mbd, constructorToUse);
        }
    }
    // 实例化
    Object beanInstance;
    if (System.getSecurityManager() != null) {
        final Constructor? ctorToUse = constructorToUse;
        final Object[] argumentsToUse = argsToUse;
        beanInstance = AccessController.doPrivileged(new PrivilegedActionObject() {
            public Object run() {
                return beanFactory.getInstantiationStrategy().instantiate(
                        mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
            }
        }, beanFactory.getAccessControlContext());
    }
    else {
        beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
                mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
    }
    bw.setBeanInstance(beanInstance);
    return bw;
}

上面的方法就是使用构造方法进行实例化bean的过程，很复杂，也有很多的辅助方法，下面来看下实例化的过程：

实例化有两种方式，CGLIB 和 反射：

beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, ctorToUse);

先来看下 getInstantiationStrategy 方法返回什么？

protected InstantiationStrategy getInstantiationStrategy() {
    return this.instantiationStrategy;
}
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

它返回的是 InstantiationStrategy  接口，而接口由两个实现类：

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
        final Constructor? ctor, Object... args) {
    // 如果没有需要动态改变的方法，则直接使用反射进行实例化
    if (bd.getMethodOverrides().isEmpty()) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedActionObject() {
                @Override
                public Object run() {
                    ReflectionUtils.makeAccessible(ctor);
                    return null;
                }
            });
        }
        // 使用 反射 实例化
        return BeanUtils.instantiateClass(ctor, args);
    }
    else {
        // 如果需要覆盖或者动态替换的方法，则需要使用 CGLIB 来动态代理，在创建代理的时候，可以增强植入我们的代码
        return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
    }
}

使用工厂方法创建实例和构造方法参不多，使用默认的构造方法实例化比较简单，这里就不列出来了。

属性填充

在上面分析 doCreateBean 方法的时候，当通过 工厂方法，带参数的构造方法或默认的构造方法创建了 bean 实例后，需要对 bean 的属性进行设置

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();
    // 给 InstantiationAwareBeanPostProcessor 最后一次机会在属性设置前来改变 bean 
    boolean continueWithPropertyPopulation = true;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // postProcessAfterInstantiation 返回值为是否继续填充 bean 
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }
    if (!continueWithPropertyPopulation) {
        return;
    }

    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;
    }
    // 后处理器已经初始化
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 需要依赖检查
    boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    if (hasInstAwareBpps || needsDepCheck) {
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        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);
        }
    }
    // 将属性应用到 bean 中
    applyPropertyValues(beanName, mbd, bw, pvs);
}

关于 名称 注入和类型注入，后面单独分析

将属性应用到 bean 中：
到这里，已经完成了对注入属性的获取，但是获取的是 PropereyValues 的形式存在，现在将他们应用到 bean 中去:

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    if (pvs == null || pvs.isEmpty()) {
        return;
    }
    if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
        ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    }
    MutablePropertyValues mpvs = null;
    ListPropertyValue original;
    if (pvs instanceof MutablePropertyValues) {
        // 如果 mpvs 中的值已经被转换为对应的类型，则可以直接设置到 beanWapper 中 
        mpvs = (MutablePropertyValues) pvs;
        if (mpvs.isConverted()) {
            bw.setPropertyValues(mpvs);
            return;
        }
        original = mpvs.getPropertyValueList();
    }
    else {
        // 如果 pvs 不是 MutablePropertyValues 封装的类，则直接使用原始的属性获取方法
        original = Arrays.asList(pvs.getPropertyValues());
    }
    // 获取用户自定义的类型转换器
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }
    / 获取对应的解析器
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

    ListPropertyValue deepCopy = new ArrayListPropertyValue(original.size());
    boolean resolveNecessary = false;
    // 遍历属性，将属性转换为对应类的对应属性的类型
    for (PropertyValue pv : original) {
        if (pv.isConverted()) {
            deepCopy.add(pv);
        }
        else {
            String propertyName = pv.getName();
            Object originalValue = pv.getValue();
            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) {
                    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();
    }
    bw.setPropertyValues(new MutablePropertyValues(deepCopy));

}

执行初始化方法

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    // 执行用户自定义的各种 aware 方法
    invokeAwareMethods(beanName, bean);

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 在执行 init 方法之前，先执行 前置处理器 applyBeanPostProcessorsBeforeInitialization
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    // 执行初始化方法
    invokeInitMethods(beanName, wrappedBean, mbd);

    // 执行后置处理器 applyBeanPostProcessorsAfterInitialization
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}
// 执行用户自定义的各种 aware 方法 
private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

到这里，bean 创建的大致过程就结束了

原文始发于微信公众号（Java技术大杂烩）：