前言

上一次我們實現了bean定義的自動化注冊，這讓我們的demo看起來已經很有Spring的那個味道了。但是擴展性還是差了一些。我們都知道，要寫出高內聚，低耦合，富有擴展性的代碼。那么如何增加擴展性呢？想想Spring中的AOP吧。在我們使用切面的時候，是不是可以在方法執行的前后進行攔截，加入我們自己的邏輯？這就是一種擴展性。它可以讓我們在不修改主體邏輯的前提下，完成一些功能的擴展。那么我們這次要做的，雖然不是AOP，但思想和這個是類似的。我們要在Bean定義創建和bean實例化的前后，增加前置后置處理器，以便進行擴展。

工程結構

├─src │ ├─main │ │ ├─java │ │ │ └─com │ │ │ └─akitsuki │ │ │ └─springframework │ │ │ ├─beans │ │ │ │ ├─exception │ │ │ │ │ BeanException.java │ │ │ │ │ │ │ │ │ └─factory │ │ │ │ │ BeanFactory.java │ │ │ │ │ ConfigurableListableBeanFactory.java │ │ │ │ │ HierarchicalBeanFactory.java │ │ │ │ │ ListableBeanFactory.java │ │ │ │ │ │ │ │ │ ├─config │ │ │ │ │ AutowireCapableBeanFactory.java │ │ │ │ │ BeanDefinition.java │ │ │ │ │ BeanFactoryPostProcessor.java │ │ │ │ │ BeanPostProcessor.java │ │ │ │ │ BeanReference.java │ │ │ │ │ ConfigurableBeanFactory.java │ │ │ │ │ DefaultSingletonBeanRegistry.java │ │ │ │ │ PropertyValue.java │ │ │ │ │ PropertyValues.java │ │ │ │ │ SingletonBeanRegistry.java │ │ │ │ │ │ │ │ │ ├─support │ │ │ │ │ AbstractAutowireCapableBeanFactory.java │ │ │ │ │ AbstractBeanDefinitionReader.java │ │ │ │ │ AbstractBeanFactory.java │ │ │ │ │ BeanDefinitionReader.java │ │ │ │ │ BeanDefinitionRegistry.java │ │ │ │ │ CglibSubclassingInstantiationStrategy.java │ │ │ │ │ DefaultListableBeanFactory.java │ │ │ │ │ InstantiationStrategy.java │ │ │ │ │ SimpleInstantiationStrategy.java │ │ │ │ │ │ │ │ │ └─xml │ │ │ │ XmlBeanDefinitionReader.java │ │ │ │ │ │ │ ├─context │ │ │ │ │ ApplicationContext.java │ │ │ │ │ ConfigurableApplicationContext.java │ │ │ │ │ │ │ │ │ └─support │ │ │ │ AbstractApplicationContext.java │ │ │ │ AbstractRefreshableApplicationContext.java │ │ │ │ AbstractXmlApplicationContext.java │ │ │ │ ClasspathXmlApplicationContext.java │ │ │ │ │ │ │ ├─core │ │ │ │ └─io │ │ │ │ ClasspathResource.java │ │ │ │ DefaultResourceLoader.java │ │ │ │ FileSystemResource.java │ │ │ │ Resource.java │ │ │ │ ResourceLoader.java │ │ │ │ UrlResource.java │ │ │ │ │ │ │ └─util │ │ │ ClassUtils.java │ │ │ │ │ └─resources │ └─test │ ├─java │ │ └─com │ │ └─akitsuki │ │ └─springframework │ │ └─test │ │ │ ApiTest.java │ │ │ │ │ ├─bean │ │ │ UserDao.java │ │ │ UserService.java │ │ │ │ │ └─common │ │ MyBeanFactoryPostProcessor.java │ │ MyBeanPostProcessor.java │ │ │ └─resources │ config.yml │ spring.xml

這次又多出來不少類，又是一塊難啃的骨頭。

Processor？那是什么？

Processor是什么？如果去查詞典，可能會得到這么一個譯名：處理器。它是用來處理一些內容的。既然我們要擴展，那么就要留出口子。怎么留？用接口！

package com.akitsuki.springframework.beans.factory.config;import com.akitsuki.springframework.beans.factory.ConfigurableListableBeanFactory;/*** BeanFactory的后置處理器* 用于在BeanDefinition加載完成后，但尚未實例化Bean對象之前，提供修改BeanDefinition屬性的功能** @author ziling.wang@hand-china.com* @date 2022/11/10 14:10*/ public interface BeanFactoryPostProcessor {/*** 在所有的BeanDefinition加載完成后，實例化Bean對象前，提供修改BeanDefinition的機制** @param beanFactory*/void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory); } package com.akitsuki.springframework.beans.factory.config;import com.akitsuki.springframework.beans.exception.BeanException;/*** 在bean對象初始化的前后，提供插入點** @author ziling.wang@hand-china.com* @date 2022/11/10 14:59*/ public interface BeanPostProcessor {/*** 在 Bean 對象執行初始化方法之前，執行此方法** @param bean 準備初始化的bean* @param beanName bean的名稱* @return 修改后的bean* @throws BeanException e*/Object postProcessBeforeInitialization(Object bean, String beanName) throws BeanException;/*** 在 Bean 對象執行初始化方法之后，執行此方法** @param bean 初始化后的bean* @param beanName bean的名稱* @return 修改后的bean* @throws BeanException e*/Object postProcessAfterInitialization(Object bean, String beanName) throws BeanException;}

這里寫了兩個接口，分別是在BeanDefinition加載完成后、Bean對象初始化前后提供插入點。有了這些插入點，用戶就可以自己去編寫類實現這些接口和方法，從而插入自己的邏輯，也就完成了我們所說的擴展。

Context？這又是什么？

Context，一般被稱為上下文。一開始接觸編程的我，對這個詞一直是半懂不懂的。到底什么是上下文啊（惱），明明是漢字為什么我卻看不懂啊（惱）。然后，就到了今天，我依然是半懂不懂（笑）。如果去百度搜索上下文，它會告訴你：將一長串的文字或內容，從其中分析出該個段落的摘要以及大意，甚至更進一步，將整篇文章的文意整理出來。此項技術可以應用在解讀影片、音訊等檔案，使得搜索引擎能夠搜尋到文字以外的物件，方便使用者省去大量時間觀看影片、聆聽音訊，同時也可以幫助使用者提前了解影片與音訊的內容。說人話就是：故事梗概。在保留核心內容的情況下，對整體內容進行精簡。那么對于Spring來說，我們知道有大量的工廠、bean定義、注冊等等功能，我們也需要這么一個梗概，來幫助我們對Spring有一個大體的了解，方便我們的使用。那么這個梗概，就是上下文。

package com.akitsuki.springframework.context;import com.akitsuki.springframework.beans.factory.ListableBeanFactory;/*** 上下文接口** @author ziling.wang@hand-china.com* @date 2022/11/10 14:15*/ public interface ApplicationContext extends ListableBeanFactory { }

ApplicationContext在Spring中，可以算得上是絕對重量級的角色。用戶一般操作Spring，都是在和它打交道。雖然目前內部還沒有添加方法，但是會在后面逐步進行完善。

雖然這里還沒有方法，但是我們注意到，它繼承了一個接口，ListableBeanFactory。我們來看看這個接口的內容

package com.akitsuki.springframework.beans.factory;import com.akitsuki.springframework.beans.exception.BeanException;import java.util.Map;/*** 可以列出bean實例的beanFactory，而不是通過名稱去查找** @author ziling.wang@hand-china.com* @date 2022/11/10 14:44*/ public interface ListableBeanFactory extends BeanFactory {/*** 按照類型返回 Bean 實例** @param type bean type* @param <T> type* @return bean* @throws BeanException e*/<T> Map<String, T> getBeansOfType(Class<T> type) throws BeanException;/*** 返回注冊表中所有的Bean名稱** @return bean name list*/String[] getBeanDefinitionNames(); }

嗯，按類型獲取bean實例，以及獲取所有bean的名稱。還有不要忘了繼承自BeanFactory的getBean方法。那么對于用戶來說，實際上就可以通過ApplicationContext,來獲取bean了。而那些bean定義的注冊、bean的創建等過程，都被隱藏起來了。

接下來是對ApplicationContext的一個擴充

package com.akitsuki.springframework.context;import com.akitsuki.springframework.beans.exception.BeanException;/*** @author ziling.wang@hand-china.com* @date 2022/11/10 14:15*/ public interface ConfigurableApplicationContext extends ApplicationContext {/*** 刷新容器** @throws BeanException e*/void refresh() throws BeanException; }

可以看到，它在繼承ApplicationContext的同時，提供了一個刷新容器的方法。這是一個重要的方法，那么它究竟會做什么事情呢？我們下面來揭曉。

package com.akitsuki.springframework.context.support;import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.ConfigurableListableBeanFactory; import com.akitsuki.springframework.beans.factory.config.BeanFactoryPostProcessor; import com.akitsuki.springframework.beans.factory.config.BeanPostProcessor; import com.akitsuki.springframework.context.ConfigurableApplicationContext; import com.akitsuki.springframework.core.io.DefaultResourceLoader;import java.util.Map;/*** 應用上下文類抽象實現* 繼承DefaultResourceLoader是為了處理配置文件資源的加載* 實現了ConfigurableApplicationContext接口的刷新方法** @author ziling.wang@hand-china.com* @date 2022/11/10 15:06*/ public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {@Overridepublic void refresh() throws BeanException {//創建beanFactory，加載beanDefinitionrefreshBeanFactory();//獲取beanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory();//在bean實例化之前，執行BeanFactoryPostProcessorinvokeBeanFactoryPostProcessors(beanFactory);//注冊BeanPostProcessorregisterBeanPostProcessors(beanFactory);//提前實例化單例bean對象beanFactory.preInstantiateSingletons();}/*** 刷新beanFactory** @throws BeanException*/protected abstract void refreshBeanFactory() throws BeanException;/*** 獲取beanFactory** @return*/protected abstract ConfigurableListableBeanFactory getBeanFactory();/*** 調用beanFactoryPostProcessor** @param beanFactory* @throws BeanException*/private void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) throws BeanException {for (BeanFactoryPostProcessor processor : beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values()) {processor.postProcessBeanFactory(beanFactory);}}/*** 注冊beanPostProcessor** @param beanFactory* @throws BeanException*/private void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) throws BeanException {for (BeanPostProcessor processor : beanFactory.getBeansOfType(BeanPostProcessor.class).values()) {beanFactory.addBeanPostProcessor(processor);}}@Overridepublic Object getBean(String beanName, Object... args) throws BeanException {return getBeanFactory().getBean(beanName, args);}@Overridepublic <T> T getBean(String beanName, Class<T> requiredType) throws BeanException {return getBeanFactory().getBean(beanName, requiredType);}@Overridepublic <T> Map<String, T> getBeansOfType(Class<T> type) throws BeanException {return getBeanFactory().getBeansOfType(type);}@Overridepublic String[] getBeanDefinitionNames() {return getBeanFactory().getBeanDefinitionNames();} }

好大的一個抽象類！我們可以看到它實現了我們剛才說的refresh方法，方法的內容則是：刷新bean工廠同時加載bean定義->獲取bean工廠->執行bean定義后置處理器->注冊bean后置處理器->提前實例化單例對象。其他的方法實現都比較簡單，這里就不再詳細說明。而刷新bean工廠和獲取bean工廠兩個方法是抽象方法，交給子類來具體實現。但這里出現了一個我們前面沒有見過的類：ConfigurableListableBeanFactory，并且調用了一些基于這個類的方法，所以這里可能閱讀起來會有些困難。我們接下來就介紹一下這個類。順帶一提，這里繼承了 DefaultResourceLoader，是為了處理配置資源的加載。

package com.akitsuki.springframework.beans.factory;import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.config.AutowireCapableBeanFactory; import com.akitsuki.springframework.beans.factory.config.BeanDefinition; import com.akitsuki.springframework.beans.factory.config.ConfigurableBeanFactory;/*** 提供分析和修改Bean以及預先實例化的操作接口** @author ziling.wang@hand-china.com* @date 2022/11/10 14:56*/ public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {/*** 獲取BeanDefinition** @param beanName bean名稱* @return beanDefinition* @throws BeanException e*/BeanDefinition getBeanDefinition(String beanName) throws BeanException;/*** 提前實例化單例bean對象** @throws BeanException*/void preInstantiateSingletons() throws BeanException; }

好混亂！這個接口繼承了多個接口，而且名字也很長很奇怪。不過從名字也可以推斷出來，它既有 ListableBeanFactory的功能，也有 ConfigurableBeanFactory的功能。而且還繼承了 AutowireCapableBeanFactory，一下子多出來2個沒有見過的接口，難免有些無所適從。我們來逐個分析。

首先是 ConfigurableBeanFactory接口

package com.akitsuki.springframework.beans.factory.config;import com.akitsuki.springframework.beans.factory.HierarchicalBeanFactory;/*** 可獲取 BeanPostProcessor、BeanClassLoader等的一個配置化接口** @author ziling.wang@hand-china.com* @date 2022/11/10 14:54*/ public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {String SCOPE_SINGLETON = "singleton";String SCOPE_PROTOTYPE = "prototype";/*** 添加一個processor** @param processor processor*/void addBeanPostProcessor(BeanPostProcessor processor); }

又是繼承！SingletonBeanRegistry，這個我們已經了解，是單例bean的注冊接口。但是又多了一個 HierarchicalBeanFactory。到底有完沒完了！再忍一忍，勝利的道路就在眼前了！

package com.akitsuki.springframework.beans.factory;/*** 分等級的BeanFactory** @author ziling.wang@hand-china.com* @date 2022/11/10 14:48*/ public interface HierarchicalBeanFactory extends BeanFactory { }

還好，這里只是為了滿足Spring的結構而創建的一個接口，暫時還沒有什么內容，可以先放下心來。

我們回到上面，ConfigurableBeanFactory這個接口提供了添加bean后置處理器的功能，意味著我們可以通過實現這個接口來為bean添加后置處理器，從而實現bean的擴展。

我們再來看看 AutowireCapableBeanFactory

package com.akitsuki.springframework.beans.factory.config;import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.BeanFactory;/*** 自動化處理bean工廠配置的接口** @author ziling.wang@hand-china.com* @date 2022/11/10 14:52*/ public interface AutowireCapableBeanFactory extends BeanFactory {/*** 執行 BeanPostProcessors 接口實現類的 postProcessBeforeInitialization 方法** @param existingBean bean* @param beanName bean名稱* @return bean* @throws BeanException e*/Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeanException;/*** 執行 BeanPostProcessors 接口實現類的 postProcessorsAfterInitialization 方法** @param existingBean bean* @param beanName bean名稱* @return bean* @throws BeanException e*/Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeanException; }

如果說上個接口是添加處理器，那么這個接口就是執行處理器了。分別在bean初始化前后來執行，也是我們這次要實現的核心功能。

介紹到這里，我們來分別列舉一下 ConfigurableListableBeanFactory接口以及它所繼承的多個接口，分別掌握哪些功能，來對 ConfigurableListableBeanFactory接口有一個整體的認知。

ConfigurableListableBeanFactory所繼承的接口有：

ListableBeanFactory：按類型獲取bean實例、獲取所有beanName

ConfigurableBeanFactory：添加bean后置處理器

HierarchicalBeanFactory：目前沒有實際作用

AutowireCapableBeanFactory：執行bean后置處理器

SingletonBeanRegistry：單例bean注冊

BeanFactory：獲取bean

再加上自己所擁有的獲取bean定義、提前實例化單例bean兩個方法，可以說是從bean定義到bean的實例化再到后置處理，一手包辦了所有功能。

再一次，抽象！逐級繼承！

經過前面的幾次練習，想必我們已經對Spring的這套抽象類分別實現一部分的方法，再逐步繼承直到落實到一個最終的類上面這種玩法，已經逐漸熟悉了。剛才我們也見識到了，有那么龐大的一個接口 ConfigurableListableBeanFactory，這個接口又被 AbstractApplicationContext所實現。在一個類中實現全部的功能是不現實的。所以我們這次又要拿出傳統藝能，抽象，繼承，逐級實現！首先我們看第一位選手：

package com.akitsuki.springframework.context.support;import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.ConfigurableListableBeanFactory; import com.akitsuki.springframework.beans.factory.support.DefaultListableBeanFactory;/*** 實現了父類的刷新bean工廠的方法以及獲取bean工廠的方法** @author ziling.wang@hand-china.com* @date 2022/11/10 16:16*/ public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {private DefaultListableBeanFactory beanFactory;@Overrideprotected void refreshBeanFactory() throws BeanException {DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();//讀取beanDefinitionloadBeanDefinitions(defaultListableBeanFactory);this.beanFactory = defaultListableBeanFactory;}@Overrideprotected ConfigurableListableBeanFactory getBeanFactory() {return beanFactory;}/*** 讀取beanDefinition** @param beanFactory factory*/protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory); }

這里的關鍵，在于實現了刷新beanFactory的方法。我們可以看到，每次刷新beanFactory，都會新建一個DefaultListableBeanFactory，并且重新加載bean定義。這個操作，的確很有刷新的感覺。而如何重新加載bean定義，這里并沒有具體實現，留給子類來進行。接下來是第二位選手

package com.akitsuki.springframework.context.support;import com.akitsuki.springframework.beans.factory.support.DefaultListableBeanFactory; import com.akitsuki.springframework.beans.factory.xml.XmlBeanDefinitionReader;/*** 抽象的通過xml完成beanDefinition讀取注冊的類** @author ziling.wang@hand-china.com* @date 2022/11/10 16:31*/ public abstract class AbstractXmlApplicationContext extends AbstractRefreshableApplicationContext {@Overrideprotected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory, this);String[] configLocations = getConfigLocations();if (null != configLocations) {reader.loadBeanDefinitions(configLocations);}}/*** 獲取配置文件的路徑** @return*/protected abstract String[] getConfigLocations(); }

到這里，其實就比剛才的抽象，要更加明確了一分。如果說剛才的抽象類，是【可刷新的應用上下文】，那么這個類，就明確到了【用xml實現的】可刷新的應用上下文，雖然依然抽象，但還是明確了一些。

這里終于實現了加載bean定義的方法?？梢钥吹?#xff0c;這里利用 XmlBeanDefinitionReader來讀取bean定義。而這里有趣的是，在新建 XmlBeanDefinitionReader的時候，將自身 this，作為參數傳遞了過去。而這個參數，所接受的類型是ResourceLoader。還記得遙遠的 AbstractApplicationContext 嗎？這個抽象類正繼承了 DefaultResourceLoader，所以作為它的多級子類的 AbstractXmlApplicationContext，自然也可以作為 ResourceLoader來使用。

這里的實現，其實就是通過reader，傳入配置路徑，再由其解析bean定義并進行加載。還記得上一次的自動化配置嗎？做的就是這一塊的工作。至于這里的獲取配置路徑，依然是一個抽象方法，因為就像上一次的內容中，我們可以通過多種途徑來獲取配置內容，所以依然需要一個更具體的類來實現。來吧，我們來看看最終實現者。

package com.akitsuki.springframework.context.support;/*** 具體對外給用戶提供的應用上下文方法** @author ziling.wang@hand-china.com* @date 2022/11/10 16:46*/ public class ClasspathXmlApplicationContext extends AbstractXmlApplicationContext {private String[] configLocations;public ClasspathXmlApplicationContext() {this("classpath:spring.xml");}public ClasspathXmlApplicationContext(String configLocation) {this(new String[]{configLocation});}public ClasspathXmlApplicationContext(String[] configLocations) {this.configLocations = configLocations;refresh();}@Overrideprotected String[] getConfigLocations() {return configLocations;} }

終于，我們明確了，是【classpath下的、用xml文件實現的、可刷新的、應用上下文】，這就是我們最終通過逐級繼承實現所得到的結論。留給它的發揮空間已經不多了，只實現簡單的路徑獲取方法就可以。但小伙子可是個富N代，有大把的功能通過繼承得來，真是讓人羨慕！

查漏補缺，完善接口

剛才我們完成了蕩氣回腸的一大套代碼，但好像還有一些零碎被我們遺忘了。比如bean實例化后置處理的真正調用節點（根本不零碎好嘛！多重要的功能！）。說到這里，還記得我們的bean實例化后置處理是由哪個接口提供的嗎？對了，是 AutowireCapableBeanFactory。那么還記得，在前面的幾次練習，有個名字很奇怪的抽象類一直在那里礙眼嗎？這回終于排場用場了。出來吧！AbstractAutowireCapableBeanFactory！

package com.akitsuki.springframework.beans.factory.support;import cn.hutool.core.bean.BeanUtil; import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.config.*;import java.lang.reflect.Constructor;/*** 抽象的實例化Bean類，提供創建Bean的能力，創建完成后，放入單例bean map中進行緩存** @author ziling.wang@hand-china.com* @date 2022/11/7 10:12*/ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {/*** 實例化策略，在構造方法中進行初始化*/private final InstantiationStrategy strategy;protected AbstractAutowireCapableBeanFactory(Class<? extends InstantiationStrategy> clazz) {try {strategy = clazz.newInstance();} catch (InstantiationException | IllegalAccessException e) {throw new BeanException("設置實例化策略出錯", e);}}@Overrideprotected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeanException {Object bean;try {bean = createBeanInstance(beanDefinition, beanName, args);//設置bean屬性applyPropertyValues(beanName, beanDefinition, bean);//初始化bean，執行beanPostProcessor的前置和后置方法initializeBean(beanName, bean, beanDefinition);//創建好的單例bean，放入緩存addSingleton(beanName, bean);} catch (Exception e) {throw new BeanException("創建bean失敗", e);}return bean;}protected Object createBeanInstance(BeanDefinition beanDefinition, String beanName, Object[] args) throws BeanException {//拿到所有的構造方法Constructor<?>[] declaredConstructors = beanDefinition.getBeanClass().getDeclaredConstructors();//開始循環，找到和參數類型一致的方法for (Constructor<?> c : declaredConstructors) {if (c.getParameterTypes().length == args.length) {boolean flag = true;for (int i = 0; i < c.getParameterTypes().length; i++) {if (!args[i].getClass().equals(c.getParameterTypes()[i])) {flag = false;break;}}if (flag) {//調用策略來進行實例化return strategy.instantiate(beanDefinition, beanName, c, args);}}}throw new BeanException("創建bean出錯，未找到對應構造方法");}/*** 為生成的bean設置屬性** @param beanName bean的名稱* @param beanDefinition bean的定義* @param bean 等待設置屬性的bean*/protected void applyPropertyValues(String beanName, BeanDefinition beanDefinition, Object bean) throws BeanException {PropertyValues propertyValues = beanDefinition.getPropertyValues();for (PropertyValue pv : propertyValues.getPropertyValues()) {String name = pv.getName();Object value = pv.getValue();if (value instanceof BeanReference) {try {value = getBean(((BeanReference) value).getName());} catch (Exception e) {throw new BeanException("設置bean屬性時異常:" + beanName, e);}}BeanUtil.setFieldValue(bean, name, value);}}/*** 初始化bean** @param beanName bean名稱* @param bean 待初始化bean* @param beanDefinition bean定義* @return bean*/private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {//執行beanPostProcessor before處理Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);//執行bean初始化內容invokeInitMethod(beanName, wrappedBean, beanDefinition);//執行beanPostProcessor after處理wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);return wrappedBean;}private void invokeInitMethod(String beanName, Object bean, BeanDefinition beanDefinition) {//todo 暫時為空}@Overridepublic Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeanException {Object result = existingBean;for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current = processor.postProcessBeforeInitialization(existingBean, beanName);if (null == current) {return result;}result = current;}return result;}@Overridepublic Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeanException {Object result = existingBean;for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current = processor.postProcessAfterInitialization(existingBean, beanName);if (null == current) {return result;}result = current;}return result;} }

終于，直到今天，我們終于知道了這個類如此命名的原因。原來這個接口是要交給它來實現的。

首先我們查看變化的部分。在 createBean方法中，加入了 initializeBean步驟。那我們來看看這個方法具體做了什么。其實非常單純，分三步走：調用前置處理->初始化->調用后置處理。非常的簡單易懂。那么我們會注意到，這里的【初始化】操作，是留空的。這其實是下一節的內容（開始埋坑了！），暫時先不要在意這些細節。重要的是，這里完成了前置后置處理的切入時間點。

說到這里，我想插入一段討論。到目前為止，我們的bean實例化步驟，到底有哪些步驟？我覺得是下面這些：

讀取配置文件->加載bean定義->調用構造方法創建bean(有參/無參)->設置bean依賴屬性(普通/其他bean)->前置處理->初始化(目前還沒有內容)->后置處理->添加進單例bean緩存->結束。

我們回到代碼的分析，其實一直以來說前置處理、后置處理，是不夠準確的，它們都屬于后置處理器：PostProcessor。更準確的描述是：【bean初始化前】后置處理器、【bean初始化后】后置處理器。那么我們來看這兩個方法的實現，其實兩個方法的實現步驟是類似的，都是通過調用 getBeanProcessors方法，拿到所有的處理器，再去循環調用初始化前/初始化后處理。嗯？不對…不對不對不對，這個方法哪來的！前面說了那么多，都沒有見過這個方法是哪里來的。而且我的這些處理器都存到哪里去了！雖然前面在 AbstractApplicationContext那里，有注冊處理器的地方，調用了beanFactory的 addBeanPostProcessor，但是這個方法又是哪來的啊！！！不要在意這些細節，這一章的內容可能的確比較容易引起混亂，主要是增加了太多的接口和方法，方法的分布又比較分散所導致的。那么這兩個方法究竟在哪里呢？答案很原始，在 AbstractBeanFactory中。至于為什么放在這里，我想是因為所有的BeanFactory都要用到吧，所以需要放在一個很父類的地方。

package com.akitsuki.springframework.beans.factory.support;import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.config.BeanDefinition; import com.akitsuki.springframework.beans.factory.config.BeanPostProcessor; import com.akitsuki.springframework.beans.factory.config.ConfigurableBeanFactory; import com.akitsuki.springframework.beans.factory.config.DefaultSingletonBeanRegistry;import java.util.ArrayList; import java.util.List;/*** 抽象bean工廠，實現了BeanFactory，提供獲取Bean的實現* 在獲取Bean的方法中，調用了兩個抽象方法：獲取定義、創建Bean* 這兩個抽象方法由子類來實現，這里只定義過程** @author ziling.wang@hand-china.com* @date 2022/11/7 10:04*/ public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements ConfigurableBeanFactory {private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<>();@Overridepublic Object getBean(String beanName, Object... args) throws BeanException {//這里先嘗試獲取單例Bean，如果可以獲取到就直接返回Object bean = getSingleton(beanName);if (null != bean) {return bean;}//這里是上面獲取單例Bean失敗的情況，需要先調用抽象的獲取bean定義的方法，拿到bean的定義，然后再通過這個來新創建一個BeanBeanDefinition beanDefinition = getBeanDefinition(beanName);return createBean(beanName, beanDefinition, args);}@Overridepublic <T> T getBean(String beanName, Class<T> requiredType) throws BeanException {Object bean = getBean(beanName);return requiredType.cast(bean);}/*** 獲取Bean的定義** @param beanName bean的名字* @return beanDefinition* @throws BeanException exception*/protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeanException;/*** 創建Bean** @param beanName bean的名字* @param beanDefinition bean的定義* @param args 構造方法參數* @return bean* @throws BeanException exception*/protected abstract Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeanException;@Overridepublic void addBeanPostProcessor(BeanPostProcessor processor) {this.beanPostProcessors.remove(processor);this.beanPostProcessors.add(processor);}public List<BeanPostProcessor> getBeanPostProcessors() {return beanPostProcessors;} }

首先可以看到，它實現了 ConfigurableBeanFactory接口，意味著它要肩負起注冊processor的任務。在類中維護了一個list，作為processor的存放點。要注冊的時候，就先移除，再添加。很好理解。而光有注冊還不行，還得往外提供，于是就有了get方法。這樣就把上面所挖的坑填平了。

道阻且長，終于要測試了

看到這里，不知道大家是否覺得腦子一團漿糊。反正我一開始學到這里的時候，是一團漿糊了。跟著教程把demo寫出來，但是感覺自己完全沒有理解，只是模仿了它的形，沒有領會到它的神。所以我也是學到這里，才決定，要停下來，沉淀總結一下了，于是便有了這個系列。停下來，思考每一步為什么要這樣設計，融入自己的理解，再把它寫成文章，分享出來。如果我的理解和總結能幫到哪怕一個人，那我覺得也值得了。

好了，廢話不多說，我們來開始測試。既然這次的主角是后置處理器，那么我們自然要給我們的測試加上它。

package com.akitsuki.springframework.test.common;import com.akitsuki.springframework.beans.factory.ConfigurableListableBeanFactory; import com.akitsuki.springframework.beans.factory.config.BeanDefinition; import com.akitsuki.springframework.beans.factory.config.BeanFactoryPostProcessor; import com.akitsuki.springframework.beans.factory.config.PropertyValue; import com.akitsuki.springframework.beans.factory.config.PropertyValues;/*** @author ziling.wang@hand-china.com* @date 2022/11/11 16:08*/ public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");PropertyValues propertyValues = beanDefinition.getPropertyValues();propertyValues.addPropertyValue(new PropertyValue("dummyString", "翻斗花園一棵樹，我叫英俊你記住"));} }

首先是我們的BeanFactory后置處理器。還記得這個的切入時間點是什么時候嗎？對了，是在beanDefinition加載完成后，還沒有實例化bean的時候。那在這里，我們修改bean的屬性dummyString為一段霸氣十足的話！

package com.akitsuki.springframework.test.common;import com.akitsuki.springframework.beans.exception.BeanException; import com.akitsuki.springframework.beans.factory.config.BeanPostProcessor; import com.akitsuki.springframework.test.bean.UserService;/*** @author ziling.wang@hand-china.com* @date 2022/11/11 16:08*/ public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeanException {if ("userService".equals(beanName)) {UserService userService = (UserService) bean;userService.setDummyInt(1919810);}return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeanException {return bean;} }

然后是我們的bean實例化后置處理器，我們在初始化前進行修改，把我們的userService中的dummyInt修改為一串意義不明的數字。

到這里，準備工作還不算完。光是這樣實現接口是毫無用處的，我們還需要將這兩個后置處理器注冊成bean，這樣才能被容器識別。

<?xml version="1.0" encoding="utf-8" ?> <beans><bean id="userDao" class="com.akitsuki.springframework.test.bean.UserDao"/><bean id="userService" class="com.akitsuki.springframework.test.bean.UserService"><property name="dummyString" value="dummy"/><property name="dummyInt" value="114514"/><property name="userDao" ref="userDao"/></bean><bean class="com.akitsuki.springframework.test.common.MyBeanFactoryPostProcessor"/><bean class="com.akitsuki.springframework.test.common.MyBeanPostProcessor"/> </beans>

干凈麻利地寫到注冊文件中，到了這個時候才更加感覺出自動配置的好處，比我們手動注冊要強太多了。

來，開始我們的主要測試類

package com.akitsuki.springframework.test;import com.akitsuki.springframework.context.support.ClasspathXmlApplicationContext; import com.akitsuki.springframework.test.bean.UserService; import org.junit.Test;/*** @author ziling.wang@hand-china.com* @date 2022/11/11 16:06*/ public class ApiTest {@Testpublic void test() {ClasspathXmlApplicationContext applicationContext = new ClasspathXmlApplicationContext();UserService userService = applicationContext.getBean("userService", UserService.class);userService.queryUserInfo(1L);userService.queryUserInfo(2L);userService.queryUserInfo(114L);} }

測試結果

dummyString:翻斗花園一棵樹，我叫英俊你記住 dummyInt:1919810 用戶名:akitsuki dummyString:翻斗花園一棵樹，我叫英俊你記住 dummyInt:1919810 用戶名:toyosaki dummyString:翻斗花園一棵樹，我叫英俊你記住 dummyInt:1919810 用戶未找到>_<Process finished with exit code 0

！！！！！

看到這個，不由得潸然淚下。比起前面幾次的，簡直是簡潔太多了！而且和真正的Spring越來越像了。手拿ApplicationContext，別的什么都不用管，getBean！讓我訪問！就可以了。

看到這里，我們來推導一下簡潔的表象下，每一步的步驟，來感受一下精妙的設計吧。

一切的開始，來自于 ClasspathXmlApplicationContext的新建。這里的無參構造方法中，會默認配置文件為 classpath下的 spring.xml。然后兜兜轉轉，執行到了 refresh方法。一旦執行到了 refresh方法，那就意味著打開了開關。刷新bean工廠加載bean定義->調用bean定義后置處理器(在這一步會先創建好后置處理器的bean)->注冊bean后置處理器->實例化單例bean對象(在這一步中會執行bean的后置處理器)。而這一切，都藏在一個 new ClasspathXmlApplicationContext()下面，實在是精妙無比。

那么這次的內容，到這里也就結束了?；仡櫼幌?#xff0c;真的是挺大的一章。下一章我們會填上遺留的那個【bean初始化】的坑，敬請期待。

相關源碼可以參考我的gitee：https://gitee.com/akitsuki-kouzou/mini-spring，這里對應的代碼是mini-spring-06

總結

以上是生活随笔為你收集整理的手写Spring-第六章-让我访问！实现前置后置处理扩展功能的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。