上一篇我們知道了Spring中bean工廠后置處理器的作用和觸發時間。

作用：允許我們在工廠里所有的bean被加載進來后但是還沒初始化前，對所有bean的屬性進行修改也可以add屬性值。
觸發時間：先執行工廠后置處理器，再執行構造方法，最后init-method。

本篇我們學習BeanPostProcessor,和BeanFactoryPostProcessor僅差一個Factory，可以推斷后者是針對工廠，前者是針對bean元素。
我們來看一下BeanPostProcessor的兩個方法

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

public interface BeanPostProcessor {

    //實例化、依賴注入完畢，在調用顯示的初始化之前完成一些定制的初始化任務  
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    //實例化、依賴注入、初始化完畢時執行 
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

注意：

BeanFactory和ApplicationContext兩個容器對待bean的后置處理器稍微有些不同。ApplicationContext容器會自動檢測Spring配置文件中那些bean所對應的Java類實現了BeanPostProcessor
接口，并自動把它們注冊為后置處理器。在創建bean過程中調用它們，所以部署一個后置處理器跟普通的bean沒有什么太大區別。

接下來我們通過案例來分析它的用法：

beans.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-2.5.xsd">
 <bean id="user" init-method="init" class="xz.quartz.analysis.User"></bean>
 <!-- Bean后置處理器  -->
 <bean id="beanpostpro" class="xz.quartz.analysis.beanpostpro"></bean>
</beans>

這里我們注冊了一個普通類User和一個BeanPostProcessor類

User類

package xz.quartz.analysis;

public class User {
    String name;
    String age;
    
    void init(){
        System.out.println("init");
        name = "zx-init";
        age = "zx-init";
        System.out.println("name:"+name+",age:"+age);
    }
    
    public User() {
        System.out.println("construtor");
        name = "zx-construtor";
        age = "zx-construtor";
        System.out.println("name:"+name+",age:"+age);
    }
    
    public void go(){
        System.out.println("最終age的值:"+age);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
}

user類里包含了init-method和construtor

BeanPostProcessor實現類

package xz.quartz.analysis;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class beanpostpro implements BeanPostProcessor{

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("before"+beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("after"+beanName);
        return bean;
    }

}

main函數

public class xz {

    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:beans.xml");
        System.out.println("獲取到User實例 ");
        ((User)applicationContext.getBean("user")).go();
    }
}

運行結果

construtor
name:zx-construtor,age:zx-construtor
beforeuser
init
name:zx-init,age:zx-init
afteruser
獲取到User實例 
最終age的值:zx-init

通過這個例子我們可以得出結論

執行順序：構造方法—>BeanPostProcessor的before—>init-method—>BeanPostProcessor的after。

我們把上篇提到的BeanFactoryPostProcessor也加進來看一下效果

package xz.quartz.analysis;

import org.springframework.beans.BeansException;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class beanfactorypostpro implements BeanFactoryPostProcessor{

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("******調用BeanFactoryPostProcessor開始");
        String[] beanStr = beanFactory.getBeanDefinitionNames();
        for (String beanName : beanStr) {
            System.out.println("bean name:"+beanName);
            if ("user".equals(beanName)) {
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
                System.out.println("修改user的age值");
                beanDefinition.getPropertyValues().add("age", "20");             
            }
        }
        System.out.println("******調用BeanFactoryPostProcessor結束");
    }       
}

運行結果

******調用BeanFactoryPostProcessor開始
bean name:user
修改user的age值
bean name:beanfactorypostpro
bean name:beanpostpro
******調用BeanFactoryPostProcessor結束
construtor
name:zx-construtor,age:zx-construtor
beforeuser
init
name:zx-init,age:zx-init
afteruser
獲取到User實例 
最終age的值:zx-init

到這里我們可以得出結論

1.執行順序：BeanFactoryPostProcessor—>構造方法—>BeanPostProcessor的before—>init-method—>BeanPostProcessor的after.
2.實際運用中，可以配置多個BeanFactoryPostProcessor和BeanPostProcessor
3.應用場景

1.解析bean的注解，將注解中的字段轉化為屬性
2、統一將屬性在執行前，注入bean中，如數據庫訪問的sqlMap，如嚴重服務，這樣不需要每個bean都配置屬性
3、打印日志，記錄時間等。