spring源码--09--IOC高级特性--BeanPostProcessor后置处理器的实现

spring源码–09–IOC高级特性–BeanPostProcessor后置处理器的实现

---

1、BeanPostProcessor

1. 后置处理器是一个监听器，可以监听容器触发的Bean声明周期事件。

2. 后置处理器向容器注册以后，容器中管理的Bean就具备了接收IoC容器事件回调的能力。

3. BeanPostProcessor的使用非常简单，只需要提供一个实现接口BeanPostProcessor的实现类，然后在Bean的配置文件中设置即可。

2、源码

 
 
public interface BeanPostProcessor {

	//为在Bean的初始化前提供回调入口  
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
	//为在Bean的初始化之后提供回调入口  
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

这两个回调的入口 可以为用户 在IOC容器初始化Bean过程中 自定义处理操作。

3、AbstractAutowireCapableBeanFactory类对容器生成的Bean添加后置处理器

BeanPostProcessor后置处理器 发生在依赖注入完成之后。对应的源码如下

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

  

    // 真正创建Bean的方法
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
			.
			.
			.
			.
			.
			.

            // 使用bean定义的属性值 填充bean 实例对象
            populateBean(beanName, mbd, instanceWrapper);
            //对Bean实例对象进行初始化 
			//为Bean实例对象添加BeanPostProcessor后置处理器
            exposedObject = initializeBean(beanName, exposedObject, mbd);
			.
			.
			.
			.
			.
			.


	}
}

3.1、initializeBean 源码

为Bean实例对象添加BeanPostProcessor后置处理器

	
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
		
	//初始容器创建的Bean实例对象，为其添加BeanPostProcessor后置处理器  
	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		//JDK的安全机制验证权限  
		if (System.getSecurityManager() != null) {
			
			//实现PrivilegedAction接口的匿名内部类  
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			 //为Bean实例对象包装相关属性，如名称，类加载器，所属容器等信息  
			invokeAwareMethods(beanName, bean);
		}

		//封装类
		Object wrappedBean = bean;
		
		
		if (mbd == null || !mbd.isSynthetic()) {
			//对BeanPostProcessor后置处理器的postProcessBeforeInitialization回调方法的调用，为Bean实例初始化前做一些处理    
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			 
			//调用Bean实例对象初始化的方法，这个初始化方法是在Spring Bean定义配置文件中通过init-method属性指定的     
			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()) {
			//对BeanPostProcessor后置处理器的postProcessAfterInitialization回调方法的调用，为Bean实例初始化之后做一些处理   
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		// 返回封装类
		return wrappedBean;
	}
	
	
	
	
	
	
	
	@Override
	//对BeanPostProcessor后置处理器的postProcessBeforeInitialization回调方法的调用，为Bean实例初始化前做一些处理    
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		 
		Object result = existingBean;
		
		//遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器  
		// 也就是说：所有bean初始化的时候，都会执行后置处理器
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			//执行后置处理器
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
	
	
	

	@Override
	//对BeanPostProcessor后置处理器的postProcessAfterInitialization回调方法的调用，为Bean实例初始化之后做一些处理   
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		//遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器  
		// 也就是说：所有bean初始化的时候，都会执行后置处理器
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
				//执行后置处理器
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
	
	
	
}

3.2、验证

BeanPostProcessor是一个接口，其初始化前的操作方法和初始化后的操作方法均委托其实现子类来实现，在Spring中，BeanPostProcessor的实现子类非常的多，分别完成不同的操作。举例如下

1. AOP面向切面编程的注册通知适配器
2. Bean对象的数据校验
3. Bean继承属性/方法的合

我们以 AOP面向切面编程的注册通知适配器 来了解它的功能

4、AdvisorAdapterRegistrationManager 在Bean对象初始化后 注册通知适配器

1. AdvisorAdapterRegistrationManager是BeanPostProcessor的一个实现类
2. 作用：为容器中管理的Bean注册一个面向切面编程的通知适配器，以便在Spring容器为所管理的Bean进行面向切面编程时提供方便。

4.1、源码

 
 
 
//为容器中管理的Bean注册一个面向切面编程的通知适配器  
public class AdvisorAdapterRegistrationManager implements BeanPostProcessor {

	//容器中负责管理 切面通知适配器注册 的对象
	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();


	/**
	 * Specify the AdvisorAdapterRegistry to register AdvisorAdapter beans with.
	 * Default is the global AdvisorAdapterRegistry.
	 * @see GlobalAdvisorAdapterRegistry
	 */
	public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
		this.advisorAdapterRegistry = advisorAdapterRegistry;
	}


	@Override
	//BeanPostProcessor在Bean对象初始化前的操作  
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		//没有做任何操作，直接返回容器创建的Bean对象  
		return bean;
	}

	@Override
	//BeanPostProcessor在Bean对象初始化后的操作  
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (bean instanceof AdvisorAdapter){
			//如果容器创建的Bean实例对象是一个切面通知适配器，则向容器的注册
			this.advisorAdapterRegistry.registerAdvisorAdapter((AdvisorAdapter) bean);
		}
		return bean;
	}

}