spring源码分析系列 (2) spring拓展接口BeanPostProcessor

主要分析内容：

一、BeanPostProcessor简述与demo示例

二、BeanPostProcessor源码分析：注册时机和触发点

一、BeanPostProcessor简述与demo示例

BeanPostProcessor是spring非常重要的拓展接口，例如aop通过拓展接口生产代理bean等。接口有两个方法：

/**
 * Factory hook that allows for custom modification of new bean instances,
 * e.g. checking for marker interfaces or wrapping them with proxies.
 *
 * <p>ApplicationContexts can autodetect BeanPostProcessor beans in their
 * bean definitions and apply them to any beans subsequently created.
 * Plain bean factories allow for programmatic registration of post-processors,
 * applying to all beans created through this factory.
 *
 * <p>Typically, post-processors that populate beans via marker interfaces
 * or the like will implement {@link #postProcessBeforeInitialization},
 * while post-processors that wrap beans with proxies will normally
 * implement {@link #postProcessAfterInitialization}.
 *
 * @author Juergen Hoeller
 * @since 10.10.2003
 * @see InstantiationAwareBeanPostProcessor
 * @see DestructionAwareBeanPostProcessor
 * @see ConfigurableBeanFactory#addBeanPostProcessor
 * @see BeanFactoryPostProcessor
 */
public interface BeanPostProcessor {

    /**
     * Apply this BeanPostProcessor to the given new bean instance <i>before</i> 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.
     * <p>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 <i>after</i> 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.
     * <p>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.
     * <p>This callback will also be invoked after a short-circuiting triggered by a
     * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
     * in contrast to all other BeanPostProcessor callbacks.
     * <p>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;
    }

}

View Code

以上为spring原始接口，这里说明一下：

ApplicationContext类型的容器会自动发现和注册该类型的bean，通过BeanPostProcessor可以对bean进行定制化，接口作用域是所有bean创建。
postProcessBeforeInitialization触发时机在bean实例化(Instantiation)之后，所有初始化(Initialization)动作(包括 InitializingBean#afterPrpertiesSet() 和定制化init-method())以前。
postProcessAfterInitialization触发时机在bean实例化(Instantiation)之后，所有初始化(Initialization)动作(包括 InitializingBean#afterPrpertiesSet() 和定制化init-method())以后。同时还会在InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 和 FactoryBean(bean工厂)获得bean时候调用。这个也是重要的点，放在往后的博客中阐述。

由于ApplicationContext可以自动发现并注册BeanPostProcessor，如下使用ApplicationContext类型容器实现一个简单demo。对应的demo代码可参考： https://gitee.com/zhouxiaoxing91/learning-src/tree/master

 1 public class BeanPostProcessorTest {
 2 
 3     private ApplicationContext applicationContext ;
 4 
 5     @Before
 6     public void beforeApplicationContext(){
 7         /**
 8          * ApplicationContext 自动注册 BeanPostProcessor 
 9          *  不需要手动注册
10          * */
11         applicationContext = new ClassPathXmlApplicationContext("ioc-beanPostProcessor.xml") ;
12     }
13 
14     @Test
15     public void test(){
16         Bean bean = applicationContext.getBean("bean", Bean.class) ;
17         System.out.println(bean);
18     }
19 
20     @After
21     public void after(){
22         ((ClassPathXmlApplicationContext)applicationContext).close();
23     }
24 }

BeanPostProcessorTest.java

 1 public class Bean {
 2 
 3     public Bean(){
 4 
 5     }
 6 
 7     public Bean(String name){
 8         System.out.println("构造函数被调用啦");
 9         this.name = name ;
10     }
11 
12     private String name ;
13 
14 
15     public String getName() {
16         return name;
17     }
18 
19     public void setName(String name) {
20         this.name = name;
21     }
22 
23     @Override
24     public String toString() {
25         return "Bean{" +
26                 "name='" + name + '\'' +
27                 '}';
28     }
29 }

Bean.java

 1 public class LogicBeanPostProcessor implements BeanPostProcessor {
 2 
 3     @Nullable
 4     @Override
 5     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
 6         System.out.println("LogicBeanPostProcessor.postProcessAfterInitialization 执行啦 beanName = " + beanName);
 7         return bean;
 8     }
 9 
10     @Nullable
11     @Override
12     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
13         System.out.println("LogicBeanPostProcessor.postProcessBeforeInitialization 执行啦 beanName = " + beanName);
14         return bean;
15     }
16 }

LogicBeanPostProcessor.java

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
 4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 5 
 6     <bean id="bean" class="com.nancy.ioc.Bean">
 7         <constructor-arg name="name" value="zhouxiaoxing"/>
 8     </bean>
 9 
10     <bean id="logicBeanPostProcessor" class="com.nancy.ioc.BeanPostProcessor.LogicBeanPostProcessor"/>
11 </beans>

ioc-beanPostProcessor.xml

运行结果符合以上的结论：

构造函数被调用啦
LogicBeanPostProcessor.postProcessBeforeInitialization 执行啦 beanName = bean
LogicBeanPostProcessor.postProcessAfterInitialization 执行啦 beanName = bean
Bean{name='zhouxiaoxing'}

提出两个疑问：

1、在ApplicationContext容器中何时注册BeanPostProcessor接口？

2、何时apply对应的回调方法呢？

二、BeanPostProcessor源码分析：注册时机和触发点

1、注册BeanPostProcessor

在AbstractApplicationContext容器启动的refresh()会注册BeanPostProcessor，源码如下：

 1 @Override
 2     public void refresh() throws BeansException, IllegalStateException {
 3         synchronized (this.startupShutdownMonitor) {
 4             // Prepare this context for refreshing.
 5             prepareRefresh();
 6 
 7             // Tell the subclass to refresh the internal bean factory.
 8             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 9 
10             // Prepare the bean factory for use in this context.
11             prepareBeanFactory(beanFactory);
12 
13             try {
14                 // Allows post-processing of the bean factory in context subclasses.
15                 postProcessBeanFactory(beanFactory);
16 
17                 // Invoke factory processors registered as beans in the context.
18                 invokeBeanFactoryPostProcessors(beanFactory);
19 
20                 // Register bean processors that intercept bean creation.
21                 // 注册BeanPostProcessor 在bean创建的时候进行拦截
22                registerBeanPostProcessors(beanFactory);
23 
24                 // Initialize message source for this context.
25                 initMessageSource();
26 
27                 // Initialize event multicaster for this context.
28                 initApplicationEventMulticaster();
29 
30                 // Initialize other special beans in specific context subclasses.
31                 onRefresh();
32 
33                 // Check for listener beans and register them.
34                 registerListeners();
35 
36                 // Instantiate all remaining (non-lazy-init) singletons.
37                 finishBeanFactoryInitialization(beanFactory);
38 
39                 // Last step: publish corresponding event.
40                 finishRefresh();
41             }
42 
43             catch (BeansException ex) {
44                 if (logger.isWarnEnabled()) {
45                     logger.warn("Exception encountered during context initialization - " +
46                             "cancelling refresh attempt: " + ex);
47                 }
48 
49                 // Destroy already created singletons to avoid dangling resources.
50                 destroyBeans();
51 
52                 // Reset 'active' flag.
53                 cancelRefresh(ex);
54 
55                 // Propagate exception to caller.
56                 throw ex;
57             }
58 
59             finally {
60                 // Reset common introspection caches in Spring's core, since we
61                 // might not ever need metadata for singleton beans anymore...
62                 resetCommonCaches();
63             }
64         }
65     }
66 
67         ......
68 
69     /**
70      * Instantiate and invoke all registered BeanPostProcessor beans,
71      * respecting explicit order if given.
72      * <p>Must be called before any instantiation of application beans.
73      */
74     protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
75         PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
76     }

跟进PostProcessorRegistrationDelegate.registerBeanPostProcessors

  1 public static void registerBeanPostProcessors(
  2             ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
  3 
  4         /**
  5          * 此时bean的定义加载已经完成，但是还没有实例化。 获得所有BeanPostProcessor bean对应的beanName
  6          */  
  7         String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
  8 
  9         /**
 10          * 注册日志BeanPostProcessor， 检测注册的bean是否为spring基础服务类并打印日志
 11          */ 
 12         // Register BeanPostProcessorChecker that logs an info message when
 13         // a bean is created during BeanPostProcessor instantiation, i.e. when
 14         // a bean is not eligible for getting processed by all BeanPostProcessors.
 15         int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
 16         beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 17 
 18         /**
 19          * 当有注册多个BeanPostProcessor接口时会按顺序进行，即 实现PriorityOrdered->实现Ordered->普通类型接口->内部系统MergedBeanDefinitionPostProcessor
 20          */ 
 21         // Separate between BeanPostProcessors that implement PriorityOrdered,
 22         // Ordered, and the rest.
 23         List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 24         List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
 25         List<String> orderedPostProcessorNames = new ArrayList<>();
 26         List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 27         for (String ppName : postProcessorNames) {
 28             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 29 
 30                /**
 31                  * 通过beanFactory.getBean(), 将会提前初始化BeanPostProcessor类型实例
 32                  */ 
 33                 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 34                 priorityOrderedPostProcessors.add(pp);
 35                 if (pp instanceof MergedBeanDefinitionPostProcessor) {
 36                     internalPostProcessors.add(pp);
 37                 }
 38             }
 39             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
 40                 orderedPostProcessorNames.add(ppName);
 41             }
 42             else {
 43                 nonOrderedPostProcessorNames.add(ppName);
 44             }
 45         }
 46 
 47         // First, register the BeanPostProcessors that implement PriorityOrdered.
 48         sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 49         registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
 50 
 51         // Next, register the BeanPostProcessors that implement Ordered.
 52         List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
 53         for (String ppName : orderedPostProcessorNames) {
 54             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 55             orderedPostProcessors.add(pp);
 56             if (pp instanceof MergedBeanDefinitionPostProcessor) {
 57                 internalPostProcessors.add(pp);
 58             }
 59         }
 60         sortPostProcessors(orderedPostProcessors, beanFactory);
 61         registerBeanPostProcessors(beanFactory, orderedPostProcessors);
 62 
 63         // Now, register all regular BeanPostProcessors.
 64         List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
 65         for (String ppName : nonOrderedPostProcessorNames) {
 66             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 67             nonOrderedPostProcessors.add(pp);
 68             if (pp instanceof MergedBeanDefinitionPostProcessor) {
 69                 internalPostProcessors.add(pp);
 70             }
 71         }
 72         registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
 73 
 74         // Finally, re-register all internal BeanPostProcessors.
 75         sortPostProcessors(internalPostProcessors, beanFactory);
 76         registerBeanPostProcessors(beanFactory, internalPostProcessors);
 77 
 78         /**
 79          * ApplicationListener探测器，当bean实现ApplicationListener接口时自动注册监听
 80          */
 81         // Re-register post-processor for detecting inner beans as ApplicationListeners,
 82         // moving it to the end of the processor chain (for picking up proxies etc).
 83         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
 84     }
 85 
 86     /**
 87      * 按照给定Ordered的顺序排序
 88      */
 89     private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
 90         Comparator<Object> comparatorToUse = null;
 91         if (beanFactory instanceof DefaultListableBeanFactory) {
 92             comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
 93         }
 94         if (comparatorToUse == null) {
 95             comparatorToUse = OrderComparator.INSTANCE;
 96         }
 97         postProcessors.sort(comparatorToUse);
 98     }
 99 
100     /**
101      * Register the given BeanPostProcessor beans.
102      */
103     private static void registerBeanPostProcessors(
104             ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
105 
106         for (BeanPostProcessor postProcessor : postProcessors) {
107             beanFactory.addBeanPostProcessor(postProcessor);
108         }
109     }

修改上述demo中LogicBeanPostProcessor.java文件，并debug模式查看：

 1 public class LogicBeanPostProcessor implements BeanPostProcessor {
 2 
 3     public LogicBeanPostProcessor(){
 4         System.out.println("LogicBeanPostProcessor 被 beanFactory.getBean() 提前初始化");
 5     }
 6 
 7     @Nullable
 8     @Override
 9     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
10         System.out.println("LogicBeanPostProcessor.postProcessAfterInitialization 执行啦 beanName = " + beanName);
11         return bean;
12     }
13 
14     @Nullable
15     @Override
16     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
17         System.out.println("LogicBeanPostProcessor.postProcessBeforeInitialization 执行啦 beanName = " + beanName);
18         return bean;
19     }
20 }

查看PostProcessorRegistrationDelegate#registerBeanPostProcessors，注册一个普通BeanPostProcessor -> logicBeanPostProcessor

最后运行结果：

LogicBeanPostProcessor 被 beanFactory.getBean() 提前初始化
构造函数被调用啦
LogicBeanPostProcessor.postProcessBeforeInitialization 执行啦 beanName = bean
LogicBeanPostProcessor.postProcessAfterInitialization 执行啦 beanName = bean
Bean{name='zhouxiaoxing'}

总结如下：

(1)、BeanPostProcessor注册的入口在AbstractApplicationContext容器启动的refresh()的AbstractApplicationContext#registerBeanPostProcessors。

(2)、AbstractApplicationContext进而委派PostProcessorRegistrationDelegate#registerBeanPostProcessors实现注册。

(3)、当有注册多个BeanPostProcessor接口时会按顺序进行，即实现PriorityOrdered->实现Ordered->普通类型接口->内部系统MergedBeanDefinitionPostProcessor。而同种类型也会进行排序，按顺序注册。

(4)、BeanPostProcessor类型实例会通过BeanFactory#getBean()提前初始化。

2、触发BeanPostProcessor方法

触发BeanPostProcessor有很多入口，首先分析几个入口后续的再补上。

触发（1）AbstractAutowireCapableBeanFactory#createBean 中：

 1 /**
 2      * Central method of this class: creates a bean instance,
 3      * populates the bean instance, applies post-processors, etc.
 4      * @see #doCreateBean
 5      */
 6     @Override
 7     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
 8             throws BeanCreationException {
 9 
10         // 省略...... 
11 
12         try {
13             // bean 创建
14             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
15             if (logger.isTraceEnabled()) {
16                 logger.trace("Finished creating instance of bean '" + beanName + "'");
17             }
18             return beanInstance;
19         }
20         catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
21             // A previously detected exception with proper bean creation context already,
22             // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
23             throw ex;
24         }
25         catch (Throwable ex) {
26             throw new BeanCreationException(
27                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
28         }
29     }
30 
31     /**
32      * Actually create the specified bean. Pre-creation processing has already happened
33      * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
34      * <p>Differentiates between default bean instantiation, use of a
35      * factory method, and autowiring a constructor.
36      * @param beanName the name of the bean
37      * @param mbd the merged bean definition for the bean
38      * @param args explicit arguments to use for constructor or factory method invocation
39      * @return a new instance of the bean
40      * @throws BeanCreationException if the bean could not be created
41      * @see #instantiateBean
42      * @see #instantiateUsingFactoryMethod
43      * @see #autowireConstructor
44      */
45     protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
46             throws BeanCreationException {
47 
48         // Instantiate the bean.
49         BeanWrapper instanceWrapper = null;
50         if (mbd.isSingleton()) {
51             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
52         }
53         if (instanceWrapper == null) {
54             instanceWrapper = createBeanInstance(beanName, mbd, args);
55         }
56 
57         // 省略...... 
58 
59         // Initialize the bean instance.
60         Object exposedObject = bean;
61         try {
62             // 根据加载到的bean definition给 bean赋值
63             populateBean(beanName, mbd, instanceWrapper);
64             // 调用bean初始化方法
65             exposedObject = initializeBean(beanName, exposedObject, mbd);
66         }
67         catch (Throwable ex) {
68             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
69                 throw (BeanCreationException) ex;
70             }
71             else {
72                 throw new BeanCreationException(
73                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
74             }
75         }
76 
77         // 省略...... 
78         
79         return exposedObject;
80     }

跟进AbstractAutowireCapableBeanFactory#initializeBean方法：

 1 /**
 2      * Initialize the given bean instance, applying factory callbacks
 3      * as well as init methods and bean post processors.
 4      * <p>Called from {@link #createBean} for traditionally defined beans,
 5      * and from {@link #initializeBean} for existing bean instances.
 6      * @param beanName the bean name in the factory (for debugging purposes)
 7      * @param bean the new bean instance we may need to initialize
 8      * @param mbd the bean definition that the bean was created with
 9      * (can also be {@code null}, if given an existing bean instance)
10      * @return the initialized bean instance (potentially wrapped)
11      * @see BeanNameAware
12      * @see BeanClassLoaderAware
13      * @see BeanFactoryAware
14      * @see #applyBeanPostProcessorsBeforeInitialization
15      * @see #invokeInitMethods
16      * @see #applyBeanPostProcessorsAfterInitialization
17      */
18     protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
19         // 1、工厂factory类 接口回调  
20         if (System.getSecurityManager() != null) {
21             AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
22                 invokeAwareMethods(beanName, bean);
23                 return null;
24             }, getAccessControlContext());
25         }
26         else {
27             invokeAwareMethods(beanName, bean);
28         }
29 
30         Object wrappedBean = bean;
31         if (mbd == null || !mbd.isSynthetic()) {
32             // 2、BeanPostProcessor前置执行
33             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
34         }
35 
36         try {
37             // 3、InitializingBean接口方法 or 自定义 init method 执行
38             invokeInitMethods(beanName, wrappedBean, mbd);
39         }
40         catch (Throwable ex) {
41             throw new BeanCreationException(
42                     (mbd != null ? mbd.getResourceDescription() : null),
43                     beanName, "Invocation of init method failed", ex);
44         }
45         if (mbd == null || !mbd.isSynthetic()) {
46             // 4、BeanPostProcessor后置执行
47             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
48         }
49 
50         return wrappedBean;
51     }

对应回调方法：

 1 private void invokeAwareMethods(final String beanName, final Object bean) {
 2         if (bean instanceof Aware) {
 3             if (bean instanceof BeanNameAware) {
 4                 ((BeanNameAware) bean).setBeanName(beanName);
 5             }
 6             if (bean instanceof BeanClassLoaderAware) {
 7                 ClassLoader bcl = getBeanClassLoader();
 8                 if (bcl != null) {
 9                     ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
10                 }
11             }
12             if (bean instanceof BeanFactoryAware) {
13                 ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
14             }
15         }
16     }
17 
18     /**
19      * Give a bean a chance to react now all its properties are set,
20      * and a chance to know about its owning bean factory (this object).
21      * This means checking whether the bean implements InitializingBean or defines
22      * a custom init method, and invoking the necessary callback(s) if it does.
23      * @param beanName the bean name in the factory (for debugging purposes)
24      * @param bean the new bean instance we may need to initialize
25      * @param mbd the merged bean definition that the bean was created with
26      * (can also be {@code null}, if given an existing bean instance)
27      * @throws Throwable if thrown by init methods or by the invocation process
28      * @see #invokeCustomInitMethod
29      */
30     protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
31             throws Throwable {
32 
33         boolean isInitializingBean = (bean instanceof InitializingBean);
34         if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
35             if (logger.isTraceEnabled()) {
36                 logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
37             }
38             if (System.getSecurityManager() != null) {
39                 try {
40                     AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
41                         ((InitializingBean) bean).afterPropertiesSet();
42                         return null;
43                     }, getAccessControlContext());
44                 }
45                 catch (PrivilegedActionException pae) {
46                     throw pae.getException();
47                 }
48             }
49             else {
50                 ((InitializingBean) bean).afterPropertiesSet();
51             }
52         }
53 
54         if (mbd != null && bean.getClass() != NullBean.class) {
55             String initMethodName = mbd.getInitMethodName();
56             if (StringUtils.hasLength(initMethodName) &&
57                     !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
58                     !mbd.isExternallyManagedInitMethod(initMethodName)) {
59                 invokeCustomInitMethod(beanName, bean, mbd);
60             }
61         }
62     }
63 
64     @Override
65     public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
66             throws BeansException {
67 
68         Object result = existingBean;
69         for (BeanPostProcessor processor : getBeanPostProcessors()) {
70             Object current = processor.postProcessBeforeInitialization(result, beanName);
71             if (current == null) {
72                 return result;
73             }
74             result = current;
75         }
76         return result;
77     }
78 
79     @Override
80     public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
81             throws BeansException {
82 
83         Object result = existingBean;
84         for (BeanPostProcessor processor : getBeanPostProcessors()) {
85             Object current = processor.postProcessAfterInitialization(result, beanName);
86             if (current == null) {
87                 return result;
88             }
89             result = current;
90         }
91         return result;
92     }

initializeBean对应的方法

总结如下：

(1.1)、由此可见BeanPostProcessor的一个触发入口在AbstractAutowireCapableBeanFactory#createBean，最终至AbstractAutowireCapableBeanFactory#initializeBean。

(1.2)、AbstractAutowireCapableBeanFactory#initializeBean不但会触发BeanPostProcessor回掉方法，并且还会按顺序执行bean生命周期：

factory类型接口(BeanNameAware#setBeanName)
factory类型接口(BeanClassLoaderAware#setBeanClassLoader)
factory类型接口(BeanFactoryAware#setBeanFactory)
BeanPostProcessor#postProcessBeforeInitialization
InitializingBean和自定义的init-method
BeanPostProcessor#postProcessAfterInitialization

触发（2）FactoryBeanRegistrySupport（后续补上）

spring源码分析系列 (2) spring拓展接口BeanPostProcessor

猜你喜欢