### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- 本章是《spring4.1.8擴充套件實戰》的第七篇，我們來嘗試在容器初始化的時候對bean例項做設定；

### 控制bean的兩種擴充套件方式
- 兩種方式可以對bean做控制（例如修改某個成員變數）
1. 改變bean的定義(BeanFactoryPostProcessor介面) ，可以想象成修改了class檔案，這樣例項化出來的每個物件都變了；
2. 只改變例項化的物件(BeanPostProcessor介面)；

- 上述兩種方式都能控制bean，第一種請參照[《spring4.1.8擴充套件實戰之五：改變bean的定義(BeanFactoryPostProcessor介面)》](http://blog.itpub.net/70017844/viewspace-2900595/) ，今天我們來研究第二種：改變例項化的物件；

### 本章概覽
- 全文由以下部分組成：
1. spring原始碼分析，瞭解BeanPostProcessor介面的實現類如何被註冊到spring容器；
2. spring原始碼分析，瞭解已經註冊到spring環境的BeanPostProcessor實現類如何被使用；
3. 實戰，開發一個BeanPostProcessor實現類，驗證是否能用來改變指定的bean；

### 原始碼分析：BeanPostProcessor介面的實現類如何被註冊到spring容器
- 從spring容器的初始化程式碼看起吧，看AbstractApplicationContext類的refresh方法，如下圖所示，紅框中的方法負責將BeanPostProcessor介面的實現類註冊到spring容器：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220615/1655306504571766749.png)

- 展開registerBeanPostProcessors方法，發現是委託PostProcessorRegistrationDelegate類的靜態方法registerBeanPostProcessors來完成註冊工作的：

```java
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
```

- 展開PostProcessorRegistrationDelegate.registerBeanPostProcessors方法，裡面的程式碼邏輯簡潔整齊，意圖目的一目瞭然：

```java
public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	//獲取所有實現BeanPostProcessor介面的bean的名稱
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

//注意，此時儘管註冊操作還沒有開始，但是之前已經有一些特殊的bean已經註冊進來了，
	//詳情請看AbstractApplicationContext類的prepareBeanFactory方法，
	//因此getBeanPostProcessorCount()方法返回的數量並不為零，
	//加一是因為方法末尾會註冊一個ApplicationListenerDetector介面的實現類
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	//這裡的BeanPostProcessorChecker也是個BeanPostProcessor的實現類，用於每個bean的初始化完成後，做一些簡單的檢查
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

//如果這些bean還實現了PriorityOrdered介面（在意執行順序），就全部放入集合priorityOrderedPostProcessors 
	List<beanpostprocessor> priorityOrderedPostProcessors = new ArrayList<beanpostprocessor>();
	//集合internalPostProcessors，用來存放同時實現了PriorityOrdered和MergedBeanDefinitionPostProcessor介面的bean
	List<beanpostprocessor> internalPostProcessors = new ArrayList<beanpostprocessor>();
	//集合orderedPostProcessorNames用來存放實現了Ordered介面的bean的名稱（在意執行順序）
	List<string> orderedPostProcessorNames = new ArrayList<string>();
	//集合nonOrderedPostProcessorNames用來存放即沒實現PriorityOrdered介面，也沒有實現Ordered介面的bean的名稱（不關心執行順序）
	List<string> nonOrderedPostProcessorNames = new ArrayList<string>();
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			//實現了PriorityOrdered介面的bean，都放入集合priorityOrderedPostProcessors
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				//實現了MergedBeanDefinitionPostProcessor介面的bean，都放入internalPostProcessors集合
				internalPostProcessors.add(pp);
			}
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			//實現了Ordered介面的bean，將其名稱都放入orderedPostProcessorNames集合
			orderedPostProcessorNames.add(ppName);
		}
		else {
			//既沒實現PriorityOrdered介面，也沒有實現Ordered介面的bean，將其名稱放入nonOrderedPostProcessorNames集合
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

//實現了PriorityOrdered介面的bean排序
	OrderComparator.sort(priorityOrderedPostProcessors);
	//註冊到容器
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

List<beanpostprocessor> orderedPostProcessors = new ArrayList<beanpostprocessor>();
	//處理所有實現了Ordered介面的bean
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		//前面將所有實現了PriorityOrdered和MergedBeanDefinitionPostProcessor的bean放入internalPostProcessors，
		//此處將所有實現了Ordered和MergedBeanDefinitionPostProcessor的bean放入internalPostProcessors
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}

//實現了Ordered介面的bean排序
	OrderComparator.sort(orderedPostProcessors);
	//註冊到容器
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

List<beanpostprocessor> nonOrderedPostProcessors = new ArrayList<beanpostprocessor>();
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		//此處將其餘實現了MergedBeanDefinitionPostProcessor的bean放入internalPostProcessors
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	//註冊到容器
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

OrderComparator.sort(internalPostProcessors);
	//將所有實現了MergedBeanDefinitionPostProcessor介面的bean也註冊到容器
	registerBeanPostProcessors(beanFactory, internalPostProcessors);
	//建立一個ApplicationListenerDetector物件並且註冊到容器，這就是前面計算beanProcessorTargetCount的值時加一的原因
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
```

- 以上程式碼已加註釋，就不多解讀了，有一點需要注意：對於實現了MergedBeanDefinitionPostProcessor介面的bean，在前面幾次呼叫registerBeanPostProcessors方法的時候已經註冊過了，那麼在最後執行的==registerBeanPostProcessors(beanFactory, internalPostProcessors)==，豈不是將一個bean註冊了多次？

- 為了弄清楚這個問題需要看registerBeanPostProcessors方法：

```java
private static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<beanpostprocessor> postProcessors) {

for (BeanPostProcessor postProcessor : postProcessors) {
		//對每個bean都呼叫beanFactory.addBeanPostProcessor方法來註冊
		beanFactory.addBeanPostProcessor(postProcessor);
	}
}
```

- addBeanPostProcessor方法的程式碼在AbstractApplicationContext類中，如下所示，==先刪除再新增，這樣反覆註冊也沒有問題==：

```java
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
	Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
	//如果已經註冊，就先刪除掉
	this.beanPostProcessors.remove(beanPostProcessor);
	//再註冊
	this.beanPostProcessors.add(beanPostProcessor);
	if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
		this.hasInstantiationAwareBeanPostProcessors = true;
	}
	if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
		this.hasDestructionAwareBeanPostProcessors = true;
	}
}
```

- 至此，我們已經弄清楚了BeanPostProcessor實現類的bean註冊到spring容器的邏輯，接下來看看spring容器如何使用這些bean；

### 原始碼分析，BeanPostProcessor實現類如何被使用
- 要弄清楚BeanPostProcessor介面的實現類是在哪裡被用到的，還是從負責容器初始化的AbstractApplicationContext類的refresh方法看起，如下圖紅框中的finishBeanFactoryInitialization方法，就是負責例項化和初始化bean的：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220615/1655306544884241859.png)

- 從finishBeanFactoryInitialization方法到BeanPostProcessor的實現類被使用，中間有多層邏輯和呼叫，篇幅所限就不逐個展開了，直接列出堆疊資訊，您可以根據此資訊去檢視對應原始碼：

```java
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean()
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean()
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean()
org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject()
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton()
org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean()
org.springframework.beans.factory.support.AbstractBeanFactory.getBean()
org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons()
org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization()
org.springframework.context.support.AbstractApplicationContext.refresh()
org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.refresh()
org.springframework.boot.SpringApplication.refresh()
org.springframework.boot.SpringApplication.refreshContext()
org.springframework.boot.SpringApplication.run()
org.springframework.boot.SpringApplication.run()
org.springframework.boot.SpringApplication.run()
```

- 根據上述堆疊資訊，直接檢視AbstractAutowireCapableBeanFactory類的initializeBean()方法：

```java
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(new PrivilegedAction<object>() {
			@Override
			public Object run() {
				invokeAwareMethods(beanName, bean);
				return null;
			}
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		//對已經例項化的bean，在初始化前用BeanPostProcessor實現類去處理
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

try {
		//bean的初始化
		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()) {
		//對已經例項化的bean，在初始化後用BeanPostProcessor實現類去處理
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}
```

- 如上所示，我們最關注的程式碼是==applyBeanPostProcessorsBeforeInitialization==和==applyBeanPostProcessorsAfterInitialization==這兩個方法，它們分別在bean的初始化方法==invokeInitMethods==的前後被執行；

- 先看看applyBeanPostProcessorsBeforeInitialization方法，邏輯非常簡單，就是取出所有已註冊的BeanPostProcessor實現類，執行其postProcessBeforeInitialization方法，入參是當前正在做例項化和初始化的bean例項：

```java
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {

Object result = existingBean;
	//逐一執行每個BeanPostProcessor實現類的postProcessBeforeInitialization方法
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		result = beanProcessor.postProcessBeforeInitialization(result, beanName);
		if (result == null) {
			return result;
		}
	}
	return result;
}
```

- 在invokeInitMethods方法執行完畢後會執行applyBeanPostProcessorsAfterInitialization方法，程式碼如下，與applyBeanPostProcessorsBeforeInitialization如出一轍，僅有的不同是呼叫的beanProcessor的方法變成了postProcessAfterInitialization：

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

Object result = existingBean;
	//逐一執行每個BeanPostProcessor實現類的postProcessAfterInitialization方法
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		result = beanProcessor.postProcessAfterInitialization(result, beanName);
		if (result == null) {
			return result;
		}
	}
	return result;
}
```

- 以上就是spring容器初始化過程中對BeanPostProcessor實現類的使用場景，此時還剩一點疑問需要澄清：==在分析註冊過程的時候，曾看到實現MergedBeanDefinitionPostProcessor介面的bean是最後註冊的，那麼這些MergedBeanDefinitionPostProcessor實現類在spring容器中是何處使用的呢？==

- 為了搞清這個問題，來看看AbstractAutowireCapableBeanFactory類的doCreateBean方法，前面我們分析的initializeBean方法就是在這裡面被呼叫的：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220615/1655306579980408462.png)

- 如上圖所示，紅框中就是用所有MergedBeanDefinitionPostProcessor實現類去處理當前正在例項化的bean，然後才會執行綠框中的initializeBean方法（裡面是我們剛才分析的bean的初始化，BeanPostProcessor實現類被使用的邏輯）；

- 來看看紅框中的applyMergedBeanDefinitionPostProcessors方法，主要目的是處理特殊的合成bean的定義類：

```java
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class> beanType, String beanName)
			throws BeansException {

try {
		//取出每個註冊的BeanPostProcessor實現類
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			//只有實現了MergedBeanDefinitionPostProcessor介面才執行
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				//執行postProcessMergedBeanDefinition
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}
	catch (Exception ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Post-processing failed of bean type [" + beanType + "] failed", ex);
	}
}
```

- 至此，我們對BeanPostProcessor有關的原始碼分析就完成了，小結一下：
1. 初始化時，spring容器有特別處理，會直接呼叫beanFactory.addBeanPostProcessor進行註冊（例如AbstractApplicationContext類的prepareBeanFactory方法中就有）；
2. 找出所有實現了BeanPostProcessor介面的bean，註冊到容器，註冊順序如下：
第一：實現了PriorityOrdered介面的，排序後；
第二：實現了Ordered介面的，排序後；
第三：既沒實現PriorityOrdered介面，也沒有實現Ordered介面的；
第四：實現了MergedBeanDefinitionPostProcessor介面的（這些也按照PriorityOrdered、Ordered等邏輯拍過續）；
第五：例項化一個ApplicationListenerDetector物件；
3. 例項化bean的時候，對於每個bean，先用MergedBeanDefinitionPostProcessor實現類的postProcessMergedBeanDefinition方法處理每個bean的定義類；
4. 再用BeanPostProcessor的postProcessBeforeInitialization方法處理每個bean例項；
5. bean例項初始化；
6. 用BeanPostProcessor的postProcessAfterInitialization方法處理每個bean例項；

- 原始碼分析結束，接下來自定義一個BeanPostProcessor實現類，驗證我們之前的分析：控制bean例項；

### 實戰自定義BeanPostProcessor實現類

- 本次實戰的內容是建立一個springboot工程，在裡面自定義一個BeanPostProcessor介面的實現類，如果您不想敲程式碼，也可以去github下載原始碼，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個資料夾，本章原始碼在資料夾customizebeanpostprocessor下，如下圖紅框所示：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220615/1655306604017461655.png)

- 接下來開始實戰吧：

- 基於maven建立一個springboot的web工程，名為customizebeanpostprocessor，pom.xml如下：

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>

<groupid>com.bolingcavalry</groupid>
    <artifactid>customizebeanpostprocessor</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

<name>customizebeanpostprocessor</name>
    <description>Demo project for Spring Boot</description>

<parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>1.5.15.RELEASE</version>
        <relativepath></relativepath> 
    </parent>

<dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

<dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
        </dependency>
    </dependencies>

<build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>
```

- 建立Utils.java，裡面有一些靜態的工具方法，例如列印當前堆疊：

```java
package com.bolingcavalry.customizebeanpostprocessor.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Utils {

private static final Logger logger = LoggerFactory.getLogger(Utils.class);

/**
     * 列印當前執行緒堆疊資訊
     * @param prefix
     */
    public static void printTrack(String prefix){
        StackTraceElement[] st = Thread.currentThread().getStackTrace();

if(null==st){
            logger.info("invalid stack");
            return;
        }

StringBuffer sbf =new StringBuffer();

for(StackTraceElement e:st){
            if(sbf.length()>0){
                sbf.append("  [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</object></beanpostprocessor></beanpostprocessor></beanpostprocessor></beanpostprocessor></beanpostprocessor></string></string></string></string></beanpostprocessor></beanpostprocessor></beanpostprocessor></beanpostprocessor>

spring4.1.8擴充套件實戰之七：控制bean(BeanPostProcessor介面)

相關文章