03-spring BeanPostProcessor

BeanPostProcessor

• Bean的后置处理器，实现该接口可以重写2个方法，这两个方法会在每一个bean的生命周期的指定时机被调用。假如现在又若干个BeanPostProcessor接口的实
  现类作为bean存在于Spring的容器中，那么后续每一个Bean进入初始化的过程中，在Bean初始化之前都会执行所有BeanPostProcessor实例的前置方法，然后初始化
  之后都会执行BeanPostProcessor实例后置方法。比如有ABC三个BeanPostProcessor实例，需要初始化Bean1和Bean2，那么简单的流程就是：

A.postProcessBeforeInitialization,
B.postProcessBeforeInitialization,
C.postProcessBeforeInitialization 
初始化bean1 
A.postProcessAfterInitialization,
B.postProcessAfterInitialization,
C.postProcessAfterInitialization
...
A.postProcessBeforeInitialization,
B.postProcessBeforeInitialization,
C.postProcessBeforeInitialization 
初始化bean2
A.postProcessAfterInitialization,
B.postProcessAfterInitialization,
C.postProcessAfterInitialization

• 本文的源码行数基于spring的5.0.6-RELEASE版本

一、实现类

• 下面2个图片我们看到BeanPostProcessor的实现类，

• 我们挑选一些常用和比较重要的几个实现类，简单讲述其功能，并且在后续的文章中重点对其源码的功能进行分析，下面是包含部分实现类的继承图。

简述接口功能，这部分接口我们在后面都会进行分析：

接口	接口/类	功能
BeanPostProcessor	顶层接口	初始化环绕处理器
InstantiationAwareBeanPostProcessor	子接口	实例化环绕处理器()
ApplicationContextAwareProcessor	实现类	给ApplicationContextAware实现类注入applicationContext
MergedBeanDefinitionPostProcessor	子接口	合并处理bean definition，比如AutowiredAnnotationBeanPostProcessor处理@Autowire和@Value注解就是在这个阶段
SmartInstantiationAwareBeanPostProcessor	子接口	继承自InstantiationAwareBeanPostProcessor接口
AspectJAwareAdvisorAutoProxyCreator	MergedBeanDefinitionPostProcessor的实现类	AOP的实现核心类
AutowiredAnnotationBeanPostProcessor	实现类	处理@Autowire和@Value注解
AnnotationAwareAspectJAutoProxyCreator	SmartInstantiationAwareBeanPostProcessor的实现类	AOP实现核心类

二、BeanPostProcessor实例的注册时机

• BeanPostProcessor实例本身也是一个Bean保存在IOC容器中，同时它会在每一个bean初始化的时候，在这个bean的初始化前后拦截调用2个方法，因此我们知道在时间上
  来看，BeanPostProcessor的实例比普通的bean肯定初始化的更早，如果把普通的bean看做一种产品，那么BeanPostProcessor实例可以看做是能够加工产品的一个东东，但
  是同时BeanPostProcessor实例自己也是一种产品，所有的产品都存在工厂(IOC容器)，因此需要将BeanPostProcessor这种特殊的产品较早的放到容器，它才能处理后续的产品。

源码

• 我们通过配置文件初始化IOC容器的时候代码如下：

ApplicationContext app = new AnnotationConfigApplicationContext(Cap9MainConfig.class);

//跟进去看看，调用的是下面这个构造方法
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//1.调用默认构造方法初始化相关信息
		this();
		//2.注册这个配置类
		register(annotatedClasses);
        //3.刷新容器，开始各种bean的初始化，核心方法
		refresh();
	}

//默认构造方法，初始化2个辅助类来便于后续读取配置
public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
}

    private final AnnotatedBeanDefinitionReader reader;
	private final ClassPathBeanDefinitionScanner scanner;


//注册这个配置类	
public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}	

• AbstractApplicationContext#refresh

    3.刷新容器，开始各种bean的初始化，核心方法
    @Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//注册用来拦截bean创建的Bean处理器，就是在这里初始化全部的BeanPostProcessor实例的
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//实例化非懒加载的单例bean(默认是非懒加载的，比如代码中自己定义的bean)
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

• AbstractApplicationContext#registerBeanPostProcessors

    //AbstractApplicationContext#registerBeanPostProcessors
    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}
	
	//PostProcessorRegistrationDelegate#registerBeanPostProcessors()，这是处理的核心方法，底层的方法我们这次暂不跟进，抓住主干流程
	public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

        //1.获取所有的BeanPostProcessor处理器的名称
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		//2.注册BeanPostProcessorChecker，当BeanPostProcessor初始化期间创建了bean的时候打印信息
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));


		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		//3.将所有的BeanPostProcessors分成三类，第一类是实现了PriorityOrdered接口的，第二类是实现了Ordered接口的，其余的作为第三类，然后分别放到3个集合里面
		//如果实现了PriorityOrdered接口并且还是MergedBeanDefinitionPostProcessor接口实现类，那么也会单独拎出来放到internalPostProcessors集合里面
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		
		for (String ppName : postProcessorNames) {
		    //4.1处理第一类情况
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				//4.1 MergedBeanDefinitionPostProcessor接口实现类单独拎出来
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			4.2处理第二类情况
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			//4.1其他的是第三类情况
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		//5.首先注册第一类的BeanPostProcessor，注册之前会先排序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		//6.然后注册第二类的BeanPostProcessor，注册之前也会先排序，注意还会把混杂到这一类的
	    //实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor也拎出来放到internalPostProcessors集合
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		
		//7.然后注册第三类的BeanPostProcessor，按规矩，注册之前也会先排序，注意还会把混杂到这一类的
		//实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor也拎出来放到internalPostProcessors集合
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		//8.最后，注册那些拎出来的实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);
		
		//9.前面为什么不直接分为四类，而是分为三类，却又把三类里面的MergedBeanDefinitionPostProcessor类型挑出来呢？
		//是处于优先级的考虑，集合是一个ArrayList，按照前面代码处理的话，BeanPostProcessor在internalPostProcessors
		//集合集合里面还是按照PriorityOrdered > Ordered > 其他 这样的优先级来的
		//因为实现了PriorityOrdered接口的优先级最高，继承Ordered接口的优先级次之，其余的优先级最低

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		//加入ApplicationListenerDetector，ApplicationListenerDetector也是BeanPostProcessor的一个实现类
		//ApplicationListenerDetector的功能参照后面的参考文章[2]
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

三、BeanPostProcessor方法的调用时机

• 上面我们主要分析BeanPostProcessor实例的注册时机，那么注册之后，后续的普通bean的初始化过程是会被BeanPostProcessor实例拦截调用的，
  这个拦截调用的过程在哪里？我们从前文提到的registerBeanPostProcessors方法跟进。

源码

• 业务bean的初始化是在BeanPostProcessor类型的bean初始化之后，我们看前面的AbstractApplicationContext#refresh方法，里面的finishBeanFactoryInitialization
  就是初始化业务单实例bean的主流程，我们从这里跟进。

• AbstractApplicationContext#finishBeanFactoryInitialization#line 841

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		 
		 ...省去...
		
		//这是初始化业务单实例bean的主流程，我们不关注前面的细节，跟进
		beanFactory.preInstantiateSingletons();
	}

• DefaultListableBeanFactory#preInstantiateSingletons#line 727

@Override
	public void preInstantiateSingletons() throws BeansException {
		        ...省去...
				else {
				//这里跟进，前面省去
					getBean(beanName);
				}
	         ...省去...
	}

• AbstractBeanFactory#getBean(java.lang.String)#line 198

    //line 198
    @Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}
	
	//AbstractBeanFactory#doGetBean#line240
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		...省去...
				// 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;
						}
					});
				 
					 
            ...省去...
	}
}

• AbstractAutowireCapableBeanFactory#createBean()#line 462

@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
    ...省去...
		try {
		    //这里跟进
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isDebugEnabled()) {
				logger.debug("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
	  ...省去...
	}

• AbstractAutowireCapableBeanFactory#doCreateBean#line 532

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

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			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);
			}
		}

		 ...省去...
	}

• AbstractAutowireCapableBeanFactory#initializeBean()#1685，在这里面我们可以看到BeanPostProcessor处理器的处理流程

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 {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
		    //1.BeanPostProcessor前置处理
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
		    //2.初始化
			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()) {
		    //3.BeanPostProcessor后置处理
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
	
 
	

• 前置处理

//前置处理方法 AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization
	@Override
	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;
	}

• 初始化

//被环绕的bean初始化方法
	protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {

		boolean isInitializingBean = (bean instanceof InitializingBean);
		//1.调用初始化部分的afterPropertiesSet方法
		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();
			}
		}
        
        //2.调用初始化部分的initMethodName方法
		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);
			}
		}
	}

• 后置处理

//后置处理方法AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization
	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			//依次后置处理
			Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

四、小结

• 我们这里通过代码直接跟进到了BeanPostProcessor调用的地方，过程中忽略了很多细节和其他的处理，其他的相关流程
  会在后面的文章慢慢分析，这里我们只是通过代码直观的看到BeanPostProcessor环绕的处理，下面的调用栈。

AbstractApplicationContext#finishBeanFactoryInitialization#line 841
	DefaultListableBeanFactory#preInstantiateSingletons#line 727
		AbstractBeanFactory#getBean(java.lang.String)#line 198
			AbstractBeanFactory#doGetBean#line240
				AbstractAutowireCapableBeanFactory#createBean()#line 462
					AbstractAutowireCapableBeanFactory#doCreateBean#line 532
						AbstractAutowireCapableBeanFactory#initializeBean()#1685

五、参考

• [1] Spring源码分析(七)扩展接口BeanPostProcessors源码分析
• [2] Spring BeanPostProcessor : ApplicationListenerDetector