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

BeanFactoryPostProcessor介面簡介

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

原始碼分析

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

1. 如下圖所示，紅框中的invokeBeanFactoryPostProcessors方法用來找出所有beanFactory後置處理器，並且呼叫這些處理器來改變bean的定義：
   
   
   
2. 開啟invokeBeanFactoryPostProcessors方法，如下所示，實際操作是委託PostProcessorRegistrationDelegate去完成的：

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

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

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

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

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

5. 看過了如何新增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就會在此處被找出來，如下：

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方法；

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

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下載原始碼，地址和連結資訊如下表所示：

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


接下來開始實戰吧：
1. 基於maven建立一個springboot的web工程，名為customizebeanfactorypostprocessor，pom.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/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <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>

2. 定義一個服務介面CalculateService：

package com.bolingcavalry.customizebeanfactorypostprocessor.service;

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

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

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

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;
    }
}

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

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”；

5. 建立啟動類CustomizebeanfactorypostprocessorApplication：

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);
    }
}

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

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