Spring Bean 的實例化過程

------------------2020.7.27

bean 創建的三步走：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
createBean() --> doCreateBean()
1. createBeanInstance()  // 通過反射創建 bean 的實例
2. populateBean()    // 填充 bean 里面的屬性值，包括 @AutoWired、@Resource、@Value 標記的屬性
3. initializeBean()    // 對 bean 進行初始化工作，包括一些初始化方法的執行，如：awareMethods、BeanPostProcessor、initMethods
// 參考方法：AbstractAutowireCapableBeanFactory#initializeBean()
// 其中，@ConfigurationProperties 標記的 bean 的屬性注入，就選擇了使用 BeanPostProcessor 來處理
// 具體的處理可查看 ConfigurationPropertiesBindingPostProcessor#postProcessBeforeInitialization()

 

-------------------2020.1.6

Spring Bean 的初始化是在 Spring 容器 refresh() 時進行的。

Spring 容器 refresh 時會調用 finishBeanFactoryInitialization() 來初始化所有非延遲加載的 bean。

org.springframework.context.support.AbstractApplicationContext.refresh()
    --> org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization // 初始化bean（延遲加載除外） 3         --> org.springframework.beans.factory.config.ConfigurableListableBeanFactory.preInstantiateSingletons()
            --> org.springframework.beans.factory.support.AbstractBeanFactory.getBean
                --> org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
                    --> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean // 創建 bean（實例化 bean）

 

1. org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean

0. pre: 如果 bean 已經注冊過，就從緩存中獲取 bean 的實例
1. 在 parentBeanFactory 中如果存在 beanName，則直接返回父容器里面的 bean
2. 初始化當前 bean 依賴的 bean
3. 創建 bean 的實例
　　3.1 單例類型的 bean 創建
　　3.2 原型類型的 bean 創建
　　3.3 其他 scope 類型（request、session等）的 bean 創建
4. 將新創建的 bean 的實例保存到緩存 singletonObjects 中

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    // 從緩存中獲取 bean 的實例（已經注冊過的 bean 都保存在 singletonObjects 中）
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {

        // Check if bean definition exists in this factory.
        // 1. 在 parentBeanFactory 中如果存在 beanName，則直接返回父容器里面的 bean
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            } else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } else if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            } else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            // 2. 初始化當前 bean 依賴的 bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        // getBean() 會再遞歸調用 doGetBean()，以確保所依賴的 bean 全部初始化
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // Create bean instance.
            // 3. 創建 bean 的實例
            if (mbd.isSingleton()) { // 單例類型的 bean
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 創建 bean 的實例
                        return createBean(beanName, mbd, args);
                    } catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                // 如果 bean 為 FactoryBean 的話，則調用 FactoryBean.getObject() 來創建 bean 實例
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) { // 原型類型的 bean  71                 // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                } finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else { // 其他 scope 類型的 bean
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        } finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    ......
    return (T) bean;
}

 

 

2. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {

    RootBeanDefinition mbdToUse = mbd;
    ......

    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    // BeanPostProcessor 可以創建一個代理 bean 返回
    // 執行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation  -- bean 實例化前置處理 10     // 執行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization  -- bean 初始化后置處理
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }
    
    // 創建 bean 
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    return beanInstance;
}

 

代理 bean 是通過 AbstractAutoProxyCreator 來創建的：

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessBeforeInstantiation(Class<?> beanClass, String beanName)

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    Object cacheKey = getCacheKey(beanClass, beanName);

    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    // Create proxy here if we have a custom TargetSource.
    // Suppresses unnecessary default instantiation of the target bean:
    // The TargetSource will handle target instances in a custom fashion.
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    return null;
}

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessAfterInitialization(@Nullable Object bean, String beanName)

/**
 * Create a proxy with the configured interceptors if the bean is
 * identified as one to proxy by the subclass.
 * @see #getAdvicesAndAdvisorsForBean
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}
    
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // Create proxy if we have advice.
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

 

3. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean

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

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;

    if (instanceWrapper == null) {
        // 創建 bean 的實例：通過默認構造函數反射生成、通過配置的構造函數生成（構造方法注入）、通過 factoryMethod 生成
        // 最終會生成一個 BeanWrapper
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();

    // Allow post-processors to modify the merged bean definition.
    // 允許 post-processors 修改 bean 的定義
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            // 執行 MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);        
            mbd.postProcessed = true;
        }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 解決循環依賴相關
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 填充 bean 屬性，處理屬性注入：@Value, @Autowired, @Resource 等
        populateBean(beanName, mbd, instanceWrapper); 37         // 初始化 bean：執行 aware 方法 --> BeanPostProcessor --> afterPropertiesSet() --> 指定的初始化方法
        exposedObject = initializeBean(beanName, exposedObject, mbd); 39     } 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);
        }
    }

    ......

    return exposedObject;
}