BeanPostProcessor

BeanPostProcessor 是Spring IOC容器给我们提供的一个扩展接口。一般称为Bean的后置处理器，可以在创建每个 Bean 的过程中进行干涉，使之使用我们自定义的逻辑，是属于AbstractBeanFactory中一个属性。

我们先来看下BeanPostProcessor的定义：

public interface BeanPostProcessor {
    
	/*初始化前*/
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	};
    
	/*初始化后*/
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}
复制代码

可以看到，BeanPostProcessor接口中只有两个默认方法，这两个方法有着相同的参数：

bean：实例化之后的bean对象
beanName：bean名称

这两个默认方法的方法名称只有点小区别，一个是Before，一个是After。还要注意 Initialization，意思是初始化，需要小心与 Instantiation 实例化进行区分。注意：接口中的两个方法是可以返回 null 的哟。只是如果返回 null 不会再执行后续的 BeanPostProcessor。

初始化前方法源码

@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {
               
		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			// BPP1--》BPP2-->BPP3
			// 执行postProcessBeforeInitialization方法，也就是初始化前方法
			Object current = processor.postProcessBeforeInitialization(result, beanName);
                        //执行 postProcessBeforeInitialization 方法返回 null
                        //返回上次结果
			if (current == null) {
                            return result;
			}
			result = current;
		}
		return result;
	}
复制代码

初始化后方法源码

@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			// 执行postProcessAfterInitialization方法，也就是初始化后方法
			Object current = processor.postProcessAfterInitialization(result, beanName);
                        //执行 postProcessAfterInitialization 方法返回 null
                        //返回上次结果
			if (current == null) {
			    return result;
			}
			result = current;
		}
		return result;
	}
复制代码

两个方法都位于 AbstractAutowireCapableBeanFactory类中。

使用

下面就来写一个简单的示例，来看看BeanPostProcessor的作用

第一步

定义两个对象，User 和 Person

public class Person {

	private String name;

	public Person() {
	}

	public Person(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person{" +
				"name='" + name + '\'' +
				'}';
	}
}


public class User {
}
复制代码

第二步

定义一个BeanPostProcessor的实现类，重写其接口方法：

public class MeBeanPostPorcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if("person".equals(beanName)){
			System.out.println("初始化前====》" + "当前对象：" + bean + ",beanName = " + beanName);
			return new User();
		}
		return null;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if("person".equals(beanName)){
			System.out.println("初始化后====》" + "当前对象：" + bean + ",beanName = " + beanName);
			return new Person("gongjie");
		}
		return null;
	}
}
复制代码

稍稍说一下上面两个方法的逻辑，两个方法中都有一个判断，如果当前 beanName 等于 person 时，才进行干涉。因为 BeanPostProcessor 会在每个 Bean 的创建过程中都会被执行，但某些时候我们可能只需要某个 Bean 被自定义。在 Before方法中进行打印日志，创建User对象返回。After 方法，打印日志并创建Person对象并进行赋值后返回。

第三步

进行 xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean class="com.gongj.bean.Person" id="person"></bean>
	<bean class="com.gongj.bean.User" id="user"></bean>
	
</beans>
复制代码

第四步

编写测试类，进行测试

public static void main(String[] args) {
		ClassPathResource resource = new ClassPathResource("spring-config.xml");
		DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
		reader.loadBeanDefinitions(resource);
		Object person = factory.getBean("person");

		System.out.println(person);
	}

结果：
Person{name='null'}
复制代码

从运行结果可以看到，没有执行 postProcessBeforeInitialization 和 postProcessAfterInitialization！这是为什么呢？这与我们使用的容器有关。这里使用的是BeanFactory容器。而不是使用的ApplicationContext。两者之间的区别请前往：Spring源码(三)-BeanFactory

那怎么解决呢！开篇有提到，BeanPostPorcessor是属于AbstractBeanFactory中一个属性。

	private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
复制代码

既然是一个 List，那就会有add方法，在类 AbstractBeanFactory中看找到了如下代码：

@Override
	public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
		Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
		this.beanPostProcessors.remove(beanPostProcessor);
		if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
			// 是否有InstantiationAwareBeanPostProcessor
			this.hasInstantiationAwareBeanPostProcessors = true;
		}
		if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
			// 是否有DestructionAwareBeanPostProcessor
			this.hasDestructionAwareBeanPostProcessors = true;
		}
		// Add to end of list
		// 添加到 beanPostProcessors 中，到时候会按添加的顺序执行
		this.beanPostProcessors.add(beanPostProcessor);
	}
复制代码

所以只需要显示调用 addBeanPostProcessor() 就可以了，加入如下代码：

MeBeanPostPorcessor meBeanPostPorcessor = new MeBeanPostPorcessor();
factory.addBeanPostProcessor(meBeanPostPorcessor);

结果：
初始化前====》当前对象：Person{name='null'},beanName = person
初始化后====》当前对象：com.gongj.bean.User@49097b5d,beanName = person
Person{name='gongjie'}
复制代码

可以看到，实现BeanPostPorcessor的MeBeanPostPorcessor影响了Bean的初始化过程，并使用我们自定义的逻辑。

当然你也可以使用 ApplicationContext，修改代码。

配置文件新增 bean：

	<bean class="com.gongj.beanPostPorcessor.MeBeanPostPorcessor" 
        id="meBeanPostPorcessor"></bean>
复制代码

Main方法：

	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
		Object person = context.getBean("person");
		System.out.println(person);
	}
结果：
初始化前====》当前对象：Person{name='null'},beanName = person
初始化后====》当前对象：com.gongj.bean.User@7a07c5b4,beanName = person
Person{name='gongjie'}
复制代码

这是怎么实现的呢？其实在我们在构建ClassPathXmlApplicationContext 实例对象的时候，其中refresh方法会调用 registerBeanPostProcessors()方法。这个方法会将检测到的 BeanPostProcessor 注入到 ClassPathXmlApplicationContext 容器中。

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 省略一大部分代码
				// 从BeanFactory找出扫描得到得BeanPostProcessor，实例化并注册到BeanFactory中
				registerBeanPostProcessors(beanFactory);
			}
			// 省略
	}
复制代码

// 实例化并注册所有BeanPostProcessor Bean
// 必须在应用程序bean的任何实例化之前被调用
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}


public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		// 获取BeanPostProcessor类型的bean名称
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// 记录beanProcessor的数量
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		// 将实现 PriorityOrdered 的 BeanPostProcessor 放在一起
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// MergedBeanDefinitionPostProcessor
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		// 将实现 Ordered  的 BeanPostProcessor 放在一起
		List<String> orderedPostProcessorNames = new ArrayList<>();
		// 没有实现其他接口的BeanPostProcessor(没有顺序)
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();

		for (String ppName : postProcessorNames) {
			//  将实现了 PriorityOrdered 的 BeanPostProcessor 添加到 priorityOrderedPostProcessors 集合中
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 调用 getBean 获取 bean 实例对象
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					// 实现了 MergedBeanDefinitionPostProcessor
					internalPostProcessors.add(pp);
				}
			}
			//  将实现了 Ordered 的 BeanPostProcessor 添加到 orderedPostProcessorNames 集合中
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				//无序，按照添加顺序执行
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		// 首先，注册实现PriorityOrdered的BeanPostProcessor
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 把priorityOrderedPostProcessors添加到beanFactory中
		// 也是调用 AbstractBeanFactory 类中的 addBeanPostProcessor方法
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		// 接下来，注册实现Ordered的BeanPostProcessor
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
			// 调用 getBean 获取 bean 实例对象
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				// 实现了 MergedBeanDefinitionPostProcessor
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		// 把orderedPostProcessors添加到beanFactory中
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		// 现在，注册所有常规BeanPostProcessor
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String ppName : nonOrderedPostProcessorNames) {
			// 调用 getBean 获取 bean 实例对象
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				// 实现了 MergedBeanDefinitionPostProcessor
				internalPostProcessors.add(pp);
			}
		}
		// 注册
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		// 最后，重新注册所有内部BeanPostProcessor。也就是 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		//重新注册用于将内部bean检测的ApplicationListener的后处理器，
		//将其移到处理器链的末尾（用于拾取代理等）。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}
复制代码

registerBeanPostProcessors方法首先从 BeanFactory 获取所有 BeanPostProcessor 类型的beanName，然后循环这些 beanName，将其按照PriorityOrdered、Ordered、无序的顺序添加至相应的 List 集合中，对相应的 List 集合进行sortPostProcessors()排序和 registerBeanPostProcessors注册。
这个排序只有实现了 PriorityOrdered、Ordered的BeanPostProcessor 才会进行排序操作。会根据getOrder方法中指定的order值进行排序。order值越大，优先级越小

小结：

使用ApplicationContext容器的 BeanPostProcessor 是支持 PriorityOrdered、Ordered，也就是说可以指定BeanPostProcessor的执行顺序。而 BeanFactory容器的 BeanPostProcessor 是不支持的，原因在于ApplicationContext容器在启动时会对 BeanPostProcessor 进行 PriorityOrdered、Ordered检测并完成排序，而 BeanFactory 中的 BeanPostProcessor 只跟注册的顺序有关，也就是显示调用 addBeanPostProcessor()方法。

子类

这里再介绍几个比较熟悉的子类:

InstantiationAwareBeanPostProcessor

InstantiationAwareBeanPostProcessor接口是BeanPostProcessor的子接口，通过接口类名我们可以知道它作用：感知 Bean 实例化的后置处理器。它在BeanPostProcessor的基础上新增了几个方法，如下：

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    
	/*实例化前*/
	@Nullable
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}
    
    /*实例化后*/
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		return true;
	}
    
    /*对属性值进行修改*/
	@Nullable
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
			throws BeansException {

		return null;
	}

	@Deprecated
	@Nullable
	default PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

		return pvs;
	}

}
复制代码

可以看到， InstantiationAwareBeanPostProcessor 接口中有四个默认方法，接下来就分别介绍几个方法的用途，当然 postProcessPropertyValues 方法就不再介绍了，该方法已经过时了。

postProcessBeforeInstantiation：实例化前，是 BeanPostProcessor 里最被先执行的方法。在目标对象实例化之前调用，该方法的返回值类型是Object。如果该方法的返回值不为空，则 postProcessAfterInitialization (初始化后)方法会被调用，其它方法不再调用，Spring 创建Bean的流程结束；如果为空，则按照正常的创建Bean流程走(方法默认返回空)。
postProcessAfterInstantiation：实例化后，在目标对象实例化之后调用。该方法的返回值类型是 boolean。如果返回值为 false，不会进行属性填充操作。
postProcessProperties：修改 Bean 中属性的内容。如果postProcessAfterInstantiation实例化后方法返回 false，该方法不会被调用。

实例

创建类并实现 InstantiationAwareBeanPostProcessor，重写其方法。

public class MyBeanPostPorcessor implements InstantiationAwareBeanPostProcessor {
    
	// 如果 postProcessBeforeInstantiation 实例化前方法 返回 不是 null
	// 如我这写法，将会中断 Spring 的创建 bean 的流程，执行完实例化前方法后
    // 直接执行 postProcessAfterInitialization 初始化后方法
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {

		if("person".equals(beanName)){
			System.out.println("实例化前");
			System.out.println("原本class对象:"+beanClass);
		}
        return new User();
		
	}

	// postProcessAfterInstantiation 实例化后 方法，
    // 如果返回 false，将不会对属性进行填充
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

		if("person".equals(beanName)){
			System.out.println("实例化后");
		}
		return false;
	}

    // postProcessAfterInstantiation 实例化后 方法，
    // 如果返回 false，将不会执行 postProcessProperties 方法
   @Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if("person".equals(beanName)){
			System.out.println("postProcessProperties方法被执行");
			PropertyValue name = pvs.getPropertyValue("name");
			Object oldValue = name.getValue();
			System.out.println("修改前name的值是:"+oldValue);
			name.setConvertedValue("yuanj");
		}
		return pvs;
	}

      // 如果 postProcessProperties 返回 null，将会执行 postProcessPropertyValues 方法
	@Override
	public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
		if("person".equals(beanName)){
			System.out.println("废弃方法：postProcessPropertyValues被执行");
			PropertyValue name = pvs.getPropertyValue("name");
			Object oldValue = name.getValue();
			System.out.println("修改前name的值是:"+oldValue);
			name.setConvertedValue("gongjie LOVE  yuanj");
		}
		return pvs;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if("person".equals(beanName)){
			System.out.println("初始化前");
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

		if("person".equals(beanName)){
			System.out.println("初始化后");
			System.out.println("原本class对象:"+bean);
		}
		return bean;
	}
}
复制代码

原本的Person类也进行小改动，增加 user属性以及 name 属性的get/set方法，来测试postProcessAfterInstantiation 实例化后方法的返回值是否会影响属性填充。

public class Person {

	@Autowired
	public User user;

	private String name;

    public String getName() {
		return name;
	}

	public void setName(String name) {
      System.out.println("setName方法 = " + name);
  		this.name = name;
	}
	public Person() {
	}

	public Person(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person{" +
				"user=" + user +
				", name='" + name + '\'' +
				'}';
	}
}
复制代码

xml 新增配置，将之前的 MeBeanPostPorcessor进行注释

<bean class="com.gongj.bean.Person" id="person">
    <property name="name" value="gongj"></property>
</bean>
<bean class="com.gongj.bean.User" id="user"></bean>
<bean class="com.gongj.beanPostPorcessor.MyBeanPostPorcessor" id="myBeanPostPorcessor"></bean>
<context:annotation-config></context:annotation-config>
复制代码

启动类：

public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
		Object person = context.getBean("person");
		System.out.println( "最终对象：" + person);
	}
结果：
实例化前
原本class对象:class com.gongj.bean.Person
初始化后
原本class对象:com.gongj.bean.User@4d76f3f8
最终对象：com.gongj.bean.User@4d76f3f8
复制代码

根据打印的信息可以看出，只执行了实例化前方法和初始化后方法，并且返回值为实例化前方法的返回值。说明 postProcessBeforeInstantiation实例化前方法的返回值会影响 Spring 创建 Bean 的流程。

修改代码，将 postProcessBeforeInstantiation实例化前方法的返回值修改为 null。

@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {

		if("person".equals(beanName)){
			System.out.println("实例化前");
			System.out.println("原本class对象:"+beanClass);
		}
		//return new User();
		return null;
	}
结果：
实例化前
原本class对象:class com.gongj.bean.Person
实例化后
初始化前
初始化后
原本class对象:Person{user=null, name='null'}
最终对象：Person{user=null, name='null'}
复制代码

修改 postProcessBeforeInstantiation实例化前方法的返回值之后，执行了实例化后和初始化前逻辑。也就是走了 Spring 自带的创建 Bean 的流程。但是我们可以看到最终对象的打印信息里面的 user 属性为 null 值。上面提到 postProcessAfterInstantiation实例化后方法的返回值为false时，不会进行属性填充。

修改代码，将 postProcessAfterInstantiation实例化后方法的返回值修改为 true。

@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

		if("person".equals(beanName)){
			System.out.println("实例化后");
		}
		return true;
	}

结果：====》
实例化前
原本class对象:class com.gongj.bean.Person
实例化后
postProcessProperties方法被执行
修改前name的值是:TypedStringValue: value [gongj], target type [null]
setName方法 = yuanj
初始化前
初始化后
原本class对象:Person{user=com.gongj.bean.User@7e0b37bc, name='yuanj'}
最终对象：Person{user=com.gongj.bean.User@7e0b37bc, name='yuanj'}
复制代码

看到打印出来的信息，postProcessProperties方法对 Bean 中属性值的修改是成功的。但我们发现被废弃的方法postProcessPropertyValues并没有被执行，这个方法是完全没有被使用了吗？其实不是的，当 postProcessProperties方法的返回值为 null时，被废弃的方法 postProcessPropertyValues就会被执行。

修改 postProcessProperties方法的返回值为 null。

@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if("person".equals(beanName)){
			System.out.println("postProcessProperties方法被执行");
			PropertyValue name = pvs.getPropertyValue("name");
			Object oldValue = name.getValue();
			System.out.println("修改前name的值是:"+oldValue);
			name.setConvertedValue("yuanj");
		}
		return null;
	}
结果：=====
实例化前
原本class对象:class com.gongj.bean.Person
实例化后
postProcessProperties方法被执行
修改前name的值是:TypedStringValue: value [gongj], target type [null]
废弃方法：postProcessPropertyValues被执行
修改前name的值是:TypedStringValue: value [gongj], target type [null]
setName方法 = gongjie LOVE  yuanj
初始化前
初始化后
原本class对象:Person{user=com.gongj.bean.User@61e717c2, name='gongjie LOVE  yuanj'}
最终对象：Person{user=com.gongj.bean.User@61e717c2, name='gongjie LOVE  yuanj'}
复制代码

MergedBeanDefinitionPostProcessor

MergedBeanDefinitionPostProcessor接口是BeanPostProcessor的子接口，用于寻找注入点，所谓注入点其实就是被Spring所支持的注解所标记的属性或者方法，在AbstractAutowireCapableBeanFactory类的doCreateBean方法中，Bean 被实例化之后就会调用applyMergedBeanDefinitionPostProcessors方法。执行该后置处理器的postProcessMergedBeanDefinition方法。“MergedBeanDefinitionPostProcessor有许多的子类，其中两个比较重要，分别是 AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor`。

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				// AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor接口.
				// 该PostPorcessor会将被@Autowired、@Value、@Inject 标记的成员变量进行记录.(静态方法、静态属性、无参方法不会作为注入点)
				// CommonAnnotationBeanPostProcessor 也是MergedBeanDefinitionPostProcessor的一个实现.
				// 该类负责记录@Resource、@PostConstruct、@PreDestroy.
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}
复制代码

AutowiredAnnotationBeanPostProcessor

AutowiredAnnotationBeanPostProcessor实现了 MergedBeanDefinitionPostProcessor，作用是查找bean中的被@Autowired、@Value 注解标注的属性与方法，如果有javax.inject.Inject依赖，那么也会查找被@Inject注解标注的属性与方法，封装成InjectionMetadata对象。

CommonAnnotationBeanPostProcessor

CommonAnnotationBeanPostProcessor继承了 InitDestroyAnnotationBeanPostProcessor类。而InitDestroyAnnotationBeanPostProcessor类实现了MergedBeanDefinitionPostProcessor。

作用与 AutowiredAnnotationBeanPostProcessor大致相同，只不过针对的是不同的注解。常见的注解有@PostConstruct、@PreDestroy、@Resource。如果有相对应的依赖，也可以使用@WebServiceRef、@EJB，也会被封装成InjectionMetadata对象。

ApplicationContextAwareProcessor

ApplicationContextAwareProcessor实现了BeanPostProcessor接口。并只重新定义了postProcessBeforeInitialization初始化前方法。

class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;


	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 * 为给定上下文创建一个新的ApplicationContextAwareProcessor
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}


    // 初始化前方法
	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
            // 具体逻辑在这个方法中
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

    //设置bean对应的属性值
	private void invokeAwareInterfaces(Object bean) {
		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 实现了什么接口，就给这个 bean setter 相对应的对象实例。当然都是 XxxAware接口，至于Aware的具体使用可以前往：Spring源码-Aware接口

DestructionAwareBeanPostProcessor

在销毁 Bean 前执行 Bean 所声明的自定义销毁方法，该回调只能应用到单例Bean。

具体实现之一： InitDestroyAnnotationBeanPostProcessor：调用@PreDestroy注解的销毁方法。

SmartInstantiationAwareBeanPostProcessor

继承自InstantiationAwareBeanPostProcessor，是InstantiationAwareBeanPostProcessor接口的扩展。此接口是一个专用接口，主要用于 Spring 框架内部使用。你会在源码的很多地方见到它。

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

    // 预测此处理器的postProcessBeforeInstantiation(实例化前)回调最终返回的bean的类型。
	@Nullable
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}

	// 确定要用于给定bean的候选构造函数，具体实现在：AutowiredAnnotationBeanPostProcessor
    // 如果方法返回的结果不为 null，则使用该构造函数数组进行对象实例化
	@Nullable
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
			throws BeansException {

		return null;
	}
    // 提前暴露引用，用于解决循环依赖问题.
	default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		return bean;
	}

}
复制代码