Spring-Bean初始化源码探讨

电玩女神 2022-05-22 12:47 245阅读 0赞

#### 前言 ####

针对 Spring 容器实例化 singleton bean 的主流程进行介绍；singleton bean 在 Spring 容器的启动过程中就进行初始化；  
**Spring-beans version：5.0.6**

#### 核心流程UML ####

![这里写图片描述][70]

这边文档的内容：**Spring 容器是如何对 Singleton bean 进行初始化并注册到当前容器**；与之相关的主要有两个流程：  
1. **解析 bean definitions 并注册**  
解析 bean definitiions 并注册到当前的 BeanFactory 中；此步骤是在 step 1.1.1.2 obtainFreshBeanFactory 完成；更详细的介绍参考解析并注册 bean definitions 流程  
2. **从 \#1 中找到所有的已注册的 singleton bean definitions，遍历，实例化得到 Singleton beans**；此步骤对应的是 **step 1.1.1.11 finishBeanFactoryInitialization** 开始进行 singleton bean 的构造过程，其后调用**AbstractBeanFactory\#getBean(beanFactory)**方法进行构造；更详细的介绍参考 **Do Get Bean** 流程。

#### 解析并注册 bean definitions 流程 ####

待补充

#### Do Get Bean 流程 ####

Do Get Bean 流程的入口是 **AbstractBeanFactory\#doGetBean** 方法，主流程图如下：  
![这里写图片描述][70 1]

> 主要流程：**从缓存中找到是否已经实例化该bean，如果存在直接返回，不存在，则将当前bean封装为 RootBeanDefinition，然后调用DefaultSingletonBeanRegistry\#getSingleton 得到初始化的signleton bean并注册到缓存中( step 1.3.3 addSingleton )，然后判断bean是否是factory bean，如果是做特殊处理，不是直接返回(step 1.4 getObjectForBeanInstance );**  
> **RootBeanDefinition： bean 的顶层描述；包含了 bean 的字段属性，ref属性以及继承相关等等属性；**

#### Step 1.3：DefaultSingletonBeanRegistry\#getSingleton ####

相关源码：

// Create bean instance.
    if (mbd.isSingleton()) {
        sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); }

**这里通过接口 ObjectFactory 定义了一个回调方法 getObject()，通过该回调方法调用 AbstractAutowireCapableBeanFactory\#createBean 方法，通过此回调方法正式开始实例化 bean 。**

#### Step 1.3.1.1：AbstractAutowireCapableBeanFactory\#createBean ####

**AbstractAutowireCapableBeanFactory\#doCreateBean** 方法是初始化 bean 的最核心的入口方法，该流程主要做三件事：  
**1. instantiate bean：实例化bean**  
\- factory instantiate bean  
\- autwire instantiate bean  
\- default instantiate bean  
**2. populate bean：设置bean的property参数**  
**3. initialize bean：对实例化好的bean进行修饰**

#### 实例化：instantiate bean ####

该步骤对应 Do Get Bean 流程中的 Step 1.3.1.1.3.1 createBeanInstance；bean有3种配置方式：  
1. factory instantiate bean：工厂方法实例化 bean；待补充  
2. autwire instantiate bean ：通过 autowire 注解的方式实例化 bean；待补充  
3. default instantiate bean：以下讲述；

#### default instantiate bean ####

此步骤对应 Do Get Bean 流程中的 **Step 1.3.1.1.3.1.3 instantiateBean**，其对应 default instantiate bean 流程的UML如下图所示：  
![这里写图片描述][70 2]

> **注意：**  
> **这里仅仅是通过使用其构造函数 constructor 使用Java 反射实例化了 bean，并没有对其进行任何的参数赋值，赋值过程参考 populate bean 流程；**  
> **将 bean 封装为 BeanWrapper，然后注册 default PropertyEditor和注册 custom PropertyEditor**  
> **最后返回 BeanWrapper**

#### 设置bean属性：populate bean ####

对应 Do Get Bean 流程中的 **Step 1.3.1.1.3.4 populateBean**，通过调用 **AbstractAutowireCapableBeanFactory\#populateBean** 正式给 bean 的参数进行赋值，populate bean流程的UML如下：  
![这里写图片描述][70 3]

通过调用 **AbstractAutowireCapableBeanFactory\#applyPropertyValues** 方法正式给 bean 进行赋值操作，赋值的主流程主要包括两个部分，**resolve property value object** 和 **set property value to bean**

#### resolve property value ####

对应上面 populate bean流程 中的 **Step 1.5 - Step 1.7；**这一步主要是去遍历当前 bean 所有的 property，并依次解析(resolve)得到对应的 Java 对象；通过方法 **BeanDefinitionValueResolver\#resolveValueIfNecessary 进行解析，解析的过程是针对不同类型的 Property，采用不同的解析方式，里面目前总共对应了十种类型**  
**BeanDefinitionValueResolver\#resolveValueIfNecessary源码：**

public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
 // We must check each value to see whether it requires a runtime reference
 // to another bean to be resolved.
 if (value instanceof RuntimeBeanReference) {
 RuntimeBeanReference ref = (RuntimeBeanReference) value;
 return resolveReference(argName, ref);
 }
 else if (value instanceof RuntimeBeanNameReference) {
 String refName = ((RuntimeBeanNameReference) value).getBeanName();
 refName = String.valueOf(doEvaluate(refName));
 if (!this.beanFactory.containsBean(refName)) {
 throw new BeanDefinitionStoreException(
 "Invalid bean name '" + refName + "' in bean reference for " + argName);
 }
 return refName;
 }
 else if (value instanceof BeanDefinitionHolder) {
 // Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
 BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
 return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
 }
 else if (value instanceof BeanDefinition) {
 // Resolve plain BeanDefinition, without contained name: use dummy name.
 BeanDefinition bd = (BeanDefinition) value;
 String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
 ObjectUtils.getIdentityHexString(bd);
 return resolveInnerBean(argName, innerBeanName, bd);
 }
 else if (value instanceof ManagedArray) {
 // May need to resolve contained runtime references.
 ManagedArray array = (ManagedArray) value;
 Class<?> elementType = array.resolvedElementType;
 if (elementType == null) {
 String elementTypeName = array.getElementTypeName();
 if (StringUtils.hasText(elementTypeName)) {
 try {
 elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
 array.resolvedElementType = elementType;
 }
 catch (Throwable ex) {
 // Improve the message by showing the context.
 throw new BeanCreationException(
 this.beanDefinition.getResourceDescription(), this.beanName,
 "Error resolving array type for " + argName, ex);
 }
 }
 else {
 elementType = Object.class;
 }
 }
 return resolveManagedArray(argName, (List<?>) value, elementType);
 }
 else if (value instanceof ManagedList) {
 // May need to resolve contained runtime references.
 return resolveManagedList(argName, (List<?>) value);
 }
 else if (value instanceof ManagedSet) {
 // May need to resolve contained runtime references.
 return resolveManagedSet(argName, (Set<?>) value);
 }
 else if (value instanceof ManagedMap) {
 // May need to resolve contained runtime references.
 return resolveManagedMap(argName, (Map<?, ?>) value);
 }
 else if (value instanceof ManagedProperties) {
 Properties original = (Properties) value;
 Properties copy = new Properties();
 original.forEach((propKey, propValue) -> {
 if (propKey instanceof TypedStringValue) {
 propKey = evaluate((TypedStringValue) propKey);
 }
 if (propValue instanceof TypedStringValue) {
 propValue = evaluate((TypedStringValue) propValue);
 }
 if (propKey == null || propValue == null) {
 throw new BeanCreationException(
 this.beanDefinition.getResourceDescription(), this.beanName,
 "Error converting Properties key/value pair for " + argName + ": resolved to null");
 }
 copy.put(propKey, propValue);
 });
 return copy;
 }
 else if (value instanceof TypedStringValue) {
 // Convert value to target type here.
 TypedStringValue typedStringValue = (TypedStringValue) value;
 Object valueObject = evaluate(typedStringValue);
 try {
 Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
 if (resolvedTargetType != null) {
 return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
 }
 else {
 return valueObject;
 }
 }
 catch (Throwable ex) {
 // Improve the message by showing the context.
 throw new BeanCreationException(
 this.beanDefinition.getResourceDescription(), this.beanName,
 "Error converting typed String value for " + argName, ex);
 }
 }
 else if (value instanceof NullBean) {
 return null;
 }
 else {
 return evaluate(value);
 }
 }

主要关注两类解析：  
**RuntimeBeanReference 类型解析**  
表示属性是一个bean，需要去解析一个ref bean，源码调用了resolveReference()方法，对应源码：  
**BeanDefinitionValueResolver\#resolveReference**

private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        try {
            Object bean;
            String refName = ref.getBeanName();
            refName = String.valueOf(doEvaluate(refName));
            if (ref.isToParent()) {
                if (this.beanFactory.getParentBeanFactory() == null) {
                    throw new BeanCreationException(
                            this.beanDefinition.getResourceDescription(), this.beanName,
                            "Can't resolve reference to bean '" + refName +
                            "' in parent factory: no parent factory available");
                }
                bean = this.beanFactory.getParentBeanFactory().getBean(refName);
            }
            else {
                bean = this.beanFactory.getBean(refName);
                this.beanFactory.registerDependentBean(refName, this.beanName);
            }
            if (bean instanceof NullBean) {
                bean = null;
            }
            return bean;
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    this.beanDefinition.getResourceDescription(), this.beanName,
                    "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
        }
    }

可以看到，最终通过调用**this.beanFactory.getBean(refName)**再次进入Do Get Bean 流程初始化得到该 ref bean；

**TypedStringValue 类型解析**  
Property value 是可以包含 value type 的，所以，在解析 TypedStringValue 的时候，需要根据 value type 进行解析；具体逻辑参考resolveTargetType(typedStringValue);方法；

#### set property value to bean ####

此步骤的主流程主要是通过**Java Method 反射**将解析出来的值赋值给当前的 bean；对应时序图中的 **Step 1.8 setPropertyValues**；  
可以看到，通过遍历 **deepCopy ArrayList 对象**中已经解析过后的 PropertyValue，最终由 BeanWrapperImpl 对象通过方法的反射，将值注入给当前的 bean，Step 1.8.1.2.1.2.2 writeMethod.invoke  
**BeanWrapperImpl.BeanPropertyHandler\#setValue源码：**

public void setValue(final @Nullable Object value) throws Exception {
 final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
 ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
 this.pd.getWriteMethod());
 if (System.getSecurityManager() != null) {
 AccessController.doPrivileged((PrivilegedAction<Object>) () -> { ReflectionUtils.makeAccessible(writeMethod); return null; }); try { AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> writeMethod.invoke(getWrappedInstance(), value), acc); } catch (PrivilegedActionException ex) { throw ex.getException(); } } else { ReflectionUtils.makeAccessible(writeMethod); writeMethod.invoke(getWrappedInstance(), value); } }

**通过这一步，将相关的 property populate 给 bean 以后， 完成bean 的实例化；**

#### 初始化：initialize bean ####

这里的名称很容易让人产生混淆, 很容易让人产生这样一个疑问, 前面不是已经初始化好了, bean 创建好了, bean 相关的 property 也设置好了, 怎么这里还要进行初始化? , 前面的部分叫做 **instantiation, 叫做”实例化”, 而这里叫做 initialization, 叫做 “初始化”; “实例化”就是从 class 得到 instance 的过程; 而”初始化”, 包含的意义更广泛, 其意义包含了”实例化”和其它对 instance 的修饰的过程**  
initialize bean流程的UML如下所示：  
![这里写图片描述][70 4]

通过 **AbstractAutowireCapableBeanFactory\#initializeBean** 方法进行对 bean 的修饰过程，源码：(删除了大部分不相关的代码)

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
 if (System.getSecurityManager() != null) {
 AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { // 调用实现了 *Aware 接口的方法，比如注入 ApplicationContext.. invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 调用 bean-post-processor 的 before initialization 回调方法 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()) { // 调用 bean-post-processor 的 after initialization 回调方法 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } // 这里的 wrapped bean 指的是被 bean-post-processor 修饰以后的包装 bean return wrappedBean; }

整个流程做了三件事：  
1. 注入 Aware 对象  
2. 回调 bean-post-processors 接口方法  
3. 回调 InitializingBean 接口方法

#### 注入 Aware 对象 ####

对应流程图中的 **Step 1.1 invokeAwareMethods**，该步骤注册所有实现了Aware接口的 beans：  
Aware.java

/**
 * Marker superinterface indicating that a bean is eligible to be
 * notified by the Spring container of a particular framework object
 * through a callback-style method. Actual method signature is
 * determined by individual subinterfaces, but should typically
 * consist of just one void-returning method that accepts a single
 * argument.
 *
 * Note that merely implementing {
 @link Aware} provides no default
 * functionality. Rather, processing must be done explicitly, for example
 * in a {
 @link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessor}.
 * Refer to {
 @link org.springframework.context.support.ApplicationContextAwareProcessor}
 * and {
 @link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory}
 * for examples of processing {
 @code *Aware} interface callbacks.
 *
 * @author Chris Beams
 * @since 3.1
 */
 public interface Aware {
 }

从 Aware 接口的注释中可以看到，允许实现了该 Aware 接口的当前 bean 能够有机会通过回调的方式注入 Spring 容器中默认实现了 Aware 接口的 bean，比如 BeanFactory 等；  
**AbstractAutowireCapableBeanFactory\#invokeAwareMethods源码：**

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) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

注入了三种情况：

1.  当当前 bean 实现了 BeanNameAware 接口，只是调用了 setBeanName；给我目前的感觉是，没有起到什么大的作用，把自己的 beanName 设置给自己
2.  当当前 bean 实现了 BeanClassLoaderAware 接口，将 Spring 容器的 BeanClassLoader 注入到当前 bean；记住，如果想要获得加载 Bean 当前的 ClassLoader 对象的时候，只需要让 Bean 实现 BeanClassLoaderAware 接口并实现相应接口方法即可；
3.  当当前 bean 实现了 BeanFactoryAware 接口，将 Spring 容器中与 bean 初始化相关的 BeanFactory 实例(这里对应的是 DefaultListableBeanFactory 实例)注册给当前的 bean；

**但是要特别特别注意的是，这里并没有注入ApplicationContext对象，要注入ApplicaitonContext对象，bean 必须实现ApplicatonContextAware接口；**  
ApplicationContextAware.java

/**
 * Interface to be implemented by any object that wishes to be notified
 * of the {@link ApplicationContext} that it runs in.
 *
 * Implementing this interface makes sense for example when an object
 * requires access to a set of collaborating beans. Note that configuration
 * via bean references is preferable to implementing this interface just
 * for bean lookup purposes.
 *
 * This interface can also be implemented if an object needs access to file
 * resources, i.e. wants to call {@code getResource}, wants to publish
 * an application event, or requires access to the MessageSource. However,
 * it is preferable to implement the more specific {@link ResourceLoaderAware},
 * {@link ApplicationEventPublisherAware} or {@link MessageSourceAware} interface
 * in such a specific scenario.
 *
 * Note that file resource dependencies can also be exposed as bean properties
 * of type {@link org.springframework.core.io.Resource}, populated via Strings
 * with automatic type conversion by the bean factory. This removes the need
 * for implementing any callback interface just for the purpose of accessing
 * a specific file resource.
 *
 * {@link org.springframework.context.support.ApplicationObjectSupport} is a
 * convenience base class for application objects, implementing this interface.
 *
 * For a list of all bean lifecycle methods, see the
 * {@link org.springframework.beans.factory.BeanFactory BeanFactory javadocs}.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Chris Beams
 * @see ResourceLoaderAware
 * @see ApplicationEventPublisherAware
 * @see MessageSourceAware
 * @see org.springframework.context.support.ApplicationObjectSupport
 * @see org.springframework.beans.factory.BeanFactoryAware
 */
 public interface ApplicationContextAware extends Aware {
 
 /**
 * Set the ApplicationContext that this object runs in.
 * Normally this call will be used to initialize the object.
 * Invoked after population of normal bean properties but before an init callback such
 * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
 * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},
 * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and
 * {@link MessageSourceAware}, if applicable.
 * @param applicationContext the ApplicationContext object to be used by this object
 * @throws ApplicationContextException in case of context initialization errors
 * @throws BeansException if thrown by application context methods
 * @see org.springframework.beans.factory.BeanInitializationException
 */
 void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
 }

从注解中可以看到，它明确标注，是在 populate bean 以后，在 处理 InitializingBean 接口回调 之前调用，那是到底是在什么时刻呢？它是在 **ApplicationContextAwareProcessor\#invokeAwareInterfaces** 方法中被调用，而 ApplicationContextAwareProcessor 正好是一个 BeanPostProcessor 对象，所以，ApplicaitonContext对象实际上是在 bean-post-procesor before initialization流程中被注入的；  
ApplicationContextAwareProcessor\#postProcessBeforeInitialization源码：

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
 AccessControlContext acc = null;
 
 if (System.getSecurityManager() != null &&
 (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
 bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
 bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
 acc = this.applicationContext.getBeanFactory().getAccessControlContext();
 }
 
 if (acc != null) {
 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
 invokeAwareInterfaces(bean);
 return null;
 }, acc);
 }
 else {
 invokeAwareInterfaces(bean);
 }
 
 return bean;
 }

ApplicationContextAwareProcessor\#invokeAwareInterfaces源码：

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);
            }
        }
    }

#### 回调 bean-post-processors 接口方法 ####

BeanPostProcessor源码：

public interface BeanPostProcessor {
 
 /**
 * Apply this BeanPostProcessor to the given new bean instance before any bean
 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
 * or a custom init-method). The bean will already be populated with property values.
 * The returned bean instance may be a wrapper around the original.
 * The default implementation returns the given {@code bean} as-is.
 * @param bean the new bean instance
 * @param beanName the name of the bean
 * @return the bean instance to use, either the original or a wrapped one;
 * if {@code null}, no subsequent BeanPostProcessors will be invoked
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
 */
 @Nullable
 default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
 return bean;
 }
 
 /**
 * Apply this BeanPostProcessor to the given new bean instance after any bean
 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
 * or a custom init-method). The bean will already be populated with property values.
 * The returned bean instance may be a wrapper around the original.
 * In case of a FactoryBean, this callback will be invoked for both the FactoryBean
 * instance and the objects created by the FactoryBean (as of Spring 2.0). The
 * post-processor can decide whether to apply to either the FactoryBean or created
 * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
 * This callback will also be invoked after a short-circuiting triggered by a
 * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
 * in contrast to all other BeanPostProcessor callbacks.
 * The default implementation returns the given {@code bean} as-is.
 * @param bean the new bean instance
 * @param beanName the name of the bean
 * @return the bean instance to use, either the original or a wrapped one;
 * if {@code null}, no subsequent BeanPostProcessors will be invoked
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
 * @see org.springframework.beans.factory.FactoryBean
 */
 @Nullable
 default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
 return bean;
 }
 
 }

该接口定义了两个回调方法：

*  Object postProcessBeforeInitialization(Object bean, String beanName)  
    **该方法是在回调 InitializeBean 接口方法之前调用，并且是在 populate bean) 之后进行的调用，通常是对原有 bean 做一层封装，然后返回该封装对象；这就是前文所描述的，其实就是是对原有 bean 起到修饰的作用**
 *  Object postProcessAfterInitialization(Object bean, String beanName)  
    **该方法是在回调 InitializeBean 接口方法之前调用，同样也是在 populate bean) 之后进行的调用**  
    所以，**bean-post-processors 总共有两次调用的时机，分别是 before initialization 和 after initialization**，而且要特别注意的是，该回调方法是针对对容器中所有的普通 bean 进行的回调；

**before initialization**  
该步骤对应 Step 1.2 applyBeanPostProcessorsBeforeInitialization，然后正式调用 Step 1.2.1 beanPostProcessor.postProcessBeforeInitialization bean-post-processor 的回调方法，不过这里要注意的是，如果 Step 1.2.1 返回 null，会终止余下的 post-bean-processor 的执行，并且直接返回一个 null，该 null 同样被视为是封装后的产物，既然是 null，那么后续的 bean-post-processor 也无需处理了，也无法对原有的 bean 进行包装了  
**AbstractAutowireCapableBeanFactory\#applyBeanPostProcessorsBeforeInitialization源码：**

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
                throws BeansException {
    
        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

**after initialization**  
对应的是 step 1.4 applyBeanPostProcessorsAfterInitialization 步骤，里面的逻辑和 before initialization 逻辑类似。

#### 回调 InitializingBean 接口方法 ####

该步骤对应的是 Step 1.3: invokeInitMethod，回调 InitializingBean 接口方法；  
AbstractAutowireCapableBeanFactory\#invokeInitMethods源码：

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
 throws Throwable {
 
 boolean isInitializingBean = (bean instanceof InitializingBean);
 if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
 if (logger.isDebugEnabled()) {
 logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
 }
 if (System.getSecurityManager() != null) {
 try {
 AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((InitializingBean) bean).afterPropertiesSet(); return null; }, getAccessControlContext()); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { ((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)) { invokeCustomInitMethod(beanName, bean, mbd); } } }

**这里主要回调的是InitializingBean接口的afterPropertiesSet方法，所以，我们可以让某个 bean 实现 InitializingBean 接口，并通过该接口实现一些当 bean 实例化好以后的回调方法，注意afterPropertiesSet并不返回任何值，所以，这里不是像 bean-post-processor 那样对 bean 起到修饰的作用，而是起到纯粹的调用作用；**

> 参考资料：  
> [http://www.shangyang.me/2017/04/01/spring-core-container-sourcecode-analysis-beans-instantiating-process/][http_www.shangyang.me_2017_04_01_spring-core-container-sourcecode-analysis-beans-instantiating-process]

[70]: /images/20220522/59d6e5dcf06a469586d3ed022df462ef.png
[70 1]: /images/20220522/c74a573f5fa64211a5c33fc98bebfc8d.png
[70 2]: /images/20220522/116ed861f4e54e54901c5707eb3032b9.png
[70 3]: /images/20220522/d27a8930108c491eb98423fdd18c0ff8.png
[70 4]: /images/20220522/7000adebecb146d8bc68c688f2a0e5fe.png
[http_www.shangyang.me_2017_04_01_spring-core-container-sourcecode-analysis-beans-instantiating-process]: http://www.shangyang.me/2017/04/01/spring-core-container-sourcecode-analysis-beans-instantiating-process/