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

### 本篇概覽
- 本章我們繼續實戰spring的擴充套件能力，透過自定義BeanFactoryPostProcessor介面的實現類，來對bean例項做一些控制；

### BeanFactoryPostProcessor介面簡介
- spring容器初始化時，從資源中讀取到bean的相關定義後，儲存在beanFactory的成員變數中（參考DefaultListableBeanFactory類的成員變數beanDefinitionMap），在例項化bean的操作就是依據這些bean的定義來做的，而在例項化之前，spring允許我們透過自定義擴充套件來改變bean的定義，定義一旦變了，後面的例項也就變了，而beanFactory後置處理器，即==BeanFactoryPostProcessor==就是用來改變bean定義的；

### 原始碼分析
- 一起來看看上述功能對應的原始碼，從AbstractApplicationContext類的refresh方法看起，這裡面對應著容器初始化的基本操作；

- 如下圖所示，紅框中的invokeBeanFactoryPostProcessors方法用來找出所有beanFactory後置處理器，並且呼叫這些處理器來改變bean的定義：

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

- 開啟invokeBeanFactoryPostProcessors方法，如下所示，實際操作是委託PostProcessorRegistrationDelegate去完成的：

```java
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	}
```

- 在呼叫PostProcessorRegistrationDelegate類的invokeBeanFactoryPostProcessors方法時，注意第二個入參是getBeanFactoryPostProcessors()方法，該方法返回的是applicationContext的成員變數beanFactoryPostProcessors，該成員變數的值是哪裡設定的呢？查詢後發現，來自AbstractApplicationContext.addBeanFactoryPostProcessor方法被呼叫的時候：

```java
@Override
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
	Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
	this.beanFactoryPostProcessors.add(postProcessor);
}
```

- AbstractApplicationContext.addBeanFactoryPostProcessor方法是留給業務擴充套件時呼叫的，例如在springboot初始化時，ConfigurationWarningsApplicationContextInitializer類的initialize方法中就有呼叫：

```java
@Override
public void initialize(ConfigurableApplicationContext context) {
	context.addBeanFactoryPostProcessor(
			new ConfigurationWarningsPostProcessor(getChecks()));
}
```

- 看過了如何新增BeanFactoryPostProcessor，再回到PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors方法，看看如何處理這些BeanFactoryPostProcessor，整個invokeBeanFactoryPostProcessors太大，不在此貼上所有程式碼了，主要是分成七段來看分析這個方法：
- 第一段，入參中的BeanFactoryPostProcessor，按照是否實現了BeanDefinitionRegistryPostProcessor，分別放入兩個集合：registryProcessors和regularPostProcessors；
- 第二段，找出所有實現了BeanDefinitionRegistryPostProcessor介面和PriorityOrdered介面的bean，放入registryProcessors集合，放入根據PriorityOrdered介面來排序，然後這些bean會被invokeBeanDefinitionRegistryPostProcessors方法執行；
- 第三段，找出所有實現了BeanDefinitionRegistryPostProcessor介面和Ordered介面的bean，放入registryProcessors集合，放入根據PriorityOrdered介面來排序，然後這些bean會被invokeBeanDefinitionRegistryPostProcessors方法執行；
- 第四段，對於那些實現了BeanDefinitionRegistryPostProcessor介面，但是沒有實現PriorityOrdered和Ordered的bean也被找出來，然後這些bean會被invokeBeanDefinitionRegistryPostProcessors方法執行；
- 第五段，入參中的BeanFactoryPostProcessor，沒有實現BeanDefinitionRegistryPostProcessor的那些bean，被invokeBeanDefinitionRegistryPostProcessors；
- 第六段，接下來的程式碼需要重點關注：==找出實現了BeanFactoryPostProcessor介面的bean，注意這裡已將面實現了BeanDefinitionRegistryPostProcessor介面的bean給剔除了，將這些bean分為三類：實現了PriorityOrdered介面的放入priorityOrderedPostProcessors，實現了Ordered介面的放入orderedPostProcessorNames，其他的放入nonOrderedPostProcessorNames，這段程式碼是關鍵，因為我們自定義的實現BeanFactoryPostProcessor介面的bean就會在此處被找出來==，如下：

```java
String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<beanfactorypostprocessor> priorityOrderedPostProcessors = new ArrayList<beanfactorypostprocessor>();
		List<string> orderedPostProcessorNames = new ArrayList<string>();
		List<string> nonOrderedPostProcessorNames = new ArrayList<string>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
```

- 第七段，priorityOrderedPostProcessors和orderedPostProcessorNames這兩個集合，都是先做排序再呼叫invokeBeanDefinitionRegistryPostProcessors方法，最後是nonOrderedPostProcessorNames集合，也被傳入invokeBeanDefinitionRegistryPostProcessors方法；

- 從上面的分析可以發現，所有實現了BeanFactoryPostProcessor介面的bean，都被作為入參，然後呼叫了invokeBeanDefinitionRegistryPostProcessors或者invokeBeanFactoryPostProcessors方法去處理，來看看這兩個方法：

```java
private static void invokeBeanDefinitionRegistryPostProcessors(
			Collection extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		}
	}

/**
	 * Invoke the given BeanFactoryPostProcessor beans.
	 */
	private static void invokeBeanFactoryPostProcessors(
			Collection extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

for (BeanFactoryPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessBeanFactory(beanFactory);
		}
	}
```

- 如上所示，兩個方法都很簡單，對每個BeanFactoryPostProcessor介面的實現類，都呼叫了其介面方法，不同的是，對於實現了BeanDefinitionRegistryPostProcessor介面的bean，呼叫其postProcessBeanDefinitionRegistry方法的時候，入參是BeanDefinitionRegistry，而非BeanFactory，因此，實現了BeanDefinitionRegistryPostProcessor介面的bean，其postProcessBeanDefinitionRegistry在被呼叫時，可以透過入參BeanDefinitionRegistry來做更多和bean的定義有關的操作，例如註冊bean；

- 至此，對BeanFactoryPostProcessor的處理流程就全部分析完了，這裡小結一下：
1. ApplicationContext擴充套件類可以呼叫AbstractApplicationContext.addBeanFactoryPostProcessor方法，將自定義的BeanFactoryPostProcessor實現類儲存到ApplicationContext中；
2. spring容器初始化時，上一步中被加入到ApplicationContext的bean會被優先呼叫其postProcessBeanFactory方法；
3. 自定義的BeanFactoryPostProcessor介面實現類，也會被找出來，然後呼叫其postProcessBeanFactory方法；
4. postProcessBeanFactory方法被呼叫時，beanFactory會被作為引數傳入，自定義類中可以使用該引數來處理bean的定義，達到業務需求；
5. 此時的spring容器還沒有開始例項化bean，因此自定義的BeanFactoryPostProcessor實現類不要做與bean例項有關的操作，而是做一些與bean定義有關的操作，例如修改某些欄位的值，這樣後面例項化的bean的就會有相應的改變；

### 實戰BeanFactoryPostProcessor介面的實現類
- 本次實戰的內容是建立一個springboot工程，在裡面自定義一個BeanFactoryPostProcessor介面的實現類，如果您不想敲程式碼，也可以去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專案中有多個資料夾，本章原始碼在資料夾customizebeanfactorypostprocessor下，如下圖紅框所示：

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

- 接下來開始實戰吧：
- 基於maven建立一個springboot的web工程，名為customizebeanfactorypostprocessor，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>customizebeanfactorypostprocessor</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

<name>customizebeanfactorypostprocessor</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>
```

- 定義一個服務介面CalculateService：

```java
package com.bolingcavalry.customizebeanfactorypostprocessor.service;

public interface CalculateService {
    /**
     * 整數加法
     * @param a
     * @param b
     * @return
     */
    int add(int a, int b);

/**
     * 返回當前實現類的描述資訊
     * @return
     */
    String getServiceDesc();
}
```

- 建立CalculateService介面的實現類CalculateServiceImpl，==注意要在Service註解上明確寫入bean的名稱==：

```java
package com.bolingcavalry.customizebeanfactorypostprocessor.service.impl;

import com.bolingcavalry.customizebeanfactorypostprocessor.service.CalculateService;
import org.springframework.stereotype.Service;

@Service("calculateService")
public class CalculateServiceImpl implements CalculateService {

private String desc = "desc from class";

public void setDesc(String desc) {
        this.desc = desc;
    }

@Override
    public int add(int a, int b) {
        return a + b;
    }

@Override
    public String getServiceDesc() {
        return desc;
    }
}
```

- 建立一個BeanFactoryPostProcessor介面的實現類CustomizeBeanFactoryPostProcessor，並且用註解Component將其定義為spring環境中的bean：

```java
package com.bolingcavalry.customizebeanfactorypostprocessor.beanfactorypostprocessor;

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;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.stereotype.Component;

@Component
public class CustomizeBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        AbstractBeanDefinition abstractBeanDefinition = (AbstractBeanDefinition) beanFactory.getBeanDefinition("calculateService");

MutablePropertyValues pv =  abstractBeanDefinition.getPropertyValues();
        pv.addPropertyValue("desc", "Desc is changed from bean factory post processor");
        abstractBeanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
    }
}
```

- 上述程式碼的功能很簡單，找到名為"calculateService"的bean的定義物件，透過呼叫addPropertyValue方法，將定義中的desc屬性值改為"Desc is changed from bean factory post processor"，這樣等名為"calculateService"的bean被例項化出來後，其成員變數desc的值就是"Desc is changed from bean factory post processor"；

- 建立啟動類CustomizebeanfactorypostprocessorApplication：

```java
package com.bolingcavalry.customizebeanfactorypostprocessor;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CustomizebeanfactorypostprocessorApplication {

public static void main(String[] args) {
        SpringApplication.run(CustomizebeanfactorypostprocessorApplication.class, args);
    }
}
```

- 啟動應用，瀏覽器輸入地址：http://localhost:8080/add/1/2 ，看到的響應如下圖，紅框中就是CustomizeBeanFactoryPostProcessor對名為calculateService的bean的定義物件修改後導致的結果：

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

- 至此，BeanFactoryPostProcessor的原始碼分析和擴充套件實戰就結束了，透過本次實戰，除了對spring擴充套件的認識加深，又掌握了一種控制bean的方式；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</string></string></string></string></beanfactorypostprocessor></beanfactorypostprocessor>

spring4.1.8擴充套件實戰之五：改變bean的定義(BeanFactoryPostProcessor介面)

相關文章