spring框架設計理念與設計模式分析

時間 2019-11-17

原文原文鏈接

Spring 做爲如今最優秀的框架之一，已被普遍的使用，而且有不少對其分析的文章。本文將從另一個視角試圖剖析出 Spring 框架的做者設計 Spring 框架的骨骼架構的設計理念，有那幾個核心組件？爲何須要這些組件？它們又是如何結合在一塊兒構成 Spring 的骨骼架構？ Spring 的 AOP 特性又是如何利用這些基礎的骨骼架構來工做的？ Spring 中又使用了那些設計模式來完成它的這種設計的？它的這種設計理念對對咱們之後的軟件設計有何啓示？本文將詳細解答這些問題。java

Spring 的骨骼架構

Spring 總共有十幾個組件，可是真正核心的組件只有幾個，下面是 Spring 框架的整體架構圖：web

圖 1 .Spring 框架的整體架構圖spring

從上圖中能夠看出 Spring 框架中的核心組件只有三個：Core、Context 和 Beans。它們構建起了整個 Spring 的骨骼架構。沒有它們就不可能有 AOP、Web 等上層的特性功能。下面也將主要從這三個組件入手分析 Spring。編程

Spring 的設計理念

前面介紹了 Spring 的三個核心組件，若是再在它們三個中選出核心的話，那就非 Beans 組件莫屬了，爲什麼這樣說，其實 Spring 就是面向 Bean 的編程（BOP,Bean Oriented Programming），Bean 在 Spring 中才是真正的主角。設計模式

Bean 在 Spring 中做用就像 Object 對 OOP 的意義同樣，沒有對象的概念就像沒有面向對象編程，Spring 中沒有 Bean 也就沒有 Spring 存在的意義。就像一次演出舞臺都準備好了可是卻沒有演員同樣。爲何要 Bean 這種角色 Bean 或者爲什麼在 Spring 如此重要，這由 Spring 框架的設計目標決定，Spring 爲什麼如此流行，咱們用 Spring 的緣由是什麼，想一想你會發現原來 Spring 解決了一個很是關鍵的問題他可讓你把對象之間的依賴關係轉而用配置文件來管理，也就是他的依賴注入機制。而這個注入關係在一個叫 Ioc 容器中管理，那 Ioc 容器中有又是什麼就是被 Bean 包裹的對象。Spring 正是經過把對象包裝在 Bean 中而達到對這些對象管理以及一些列額外操做的目的。數據結構

它這種設計策略徹底相似於 Java 實現 OOP 的設計理念，固然了 Java 自己的設計要比 Spring 複雜太多太多，可是都是構建一個數據結構，而後根據這個數據結構設計他的生存環境，並讓它在這個環境中按照必定的規律在不停的運動，在它們的不停運動中設計一系列與環境或者與其餘個體完成信息交換。這樣想來回過頭想一想咱們用到的其餘框架都是大慨相似的設計理念。架構

核心組件如何協同工做

前面說 Bean 是 Spring 中關鍵因素，那 Context 和 Core 又有何做用呢？前面吧 Bean 比做一場演出中的演員的話，那 Context 就是這場演出的舞臺背景，而 Core 應該就是演出的道具了。只有他們在一塊兒才能具有能演出一場好戲的最基本的條件。固然有最基本的條件還不能使這場演出脫穎而出，還要他表演的節目足夠的精彩，這些節目就是 Spring 能提供的特點功能了。框架

咱們知道 Bean 包裝的是 Object，而 Object 必然有數據，如何給這些數據提供生存環境就是 Context 要解決的問題，對 Context 來講他就是要發現每一個 Bean 之間的關係，爲它們創建這種關係而且要維護好這種關係。因此 Context 就是一個 Bean 關係的集合，這個關係集合又叫 Ioc 容器，一旦創建起這個 Ioc 容器後 Spring 就能夠爲你工做了。那 Core 組件又有什麼用武之地呢？其實 Core 就是發現、創建和維護每一個 Bean 之間的關係所須要的一些列的工具，從這個角度看來，Core 這個組件叫 Util 更能讓你理解。工具

它們之間能夠用下圖來表示：post

圖 2. 三個組件關係

核心組件詳解

這裏將詳細介紹每一個組件內部類的層次關係，以及它們在運行時的時序順序。咱們在使用 Spring 是應該注意的地方。

Bean 組件

前面已經說明了 Bean 組件對 Spring 的重要性，下面看看 Bean 這個組件式怎麼設計的。Bean 組件在 Spring 的 org.springframework.beans 包下。這個包下的全部類主要解決了三件事：Bean 的定義、Bean 的建立以及對 Bean 的解析。對 Spring 的使用者來講惟一須要關心的就是 Bean 的建立，其餘兩個由 Spring 在內部幫你完成了，對你來講是透明的。

Spring Bean 的建立時典型的工廠模式，他的頂級接口是 BeanFactory，下圖是這個工廠的繼承層次關係：

圖 4. Bean 工廠的繼承關係

BeanFactory 有三個子類：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。可是從上圖中咱們能夠發現最終的默認實現類是 DefaultListableBeanFactory，他實現了全部的接口。那爲什麼要定義這麼多層次的接口呢？查閱這些接口的源碼和說明發現，每一個接口都有他使用的場合，它主要是爲了區分在 Spring 內部在操做過程當中對象的傳遞和轉化過程當中，對對象的數據訪問所作的限制。例如 ListableBeanFactory 接口表示這些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是這些 Bean 是有繼承關係的，也就是每一個 Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定義 Bean 的自動裝配規則。這四個接口共同定義了 Bean 的集合、Bean 之間的關係、以及 Bean 行爲。

Bean 的定義主要有 BeanDefinition 描述，以下圖說明了這些類的層次關係：

圖 5. Bean 定義的類層次關係圖

Bean 的定義就是完整的描述了在 Spring 的配置文件中你定義的 <bean/> 節點中全部的信息，包括各類子節點。當 Spring 成功解析你定義的一個 <bean/> 節點後，在 Spring 的內部他就被轉化成 BeanDefinition 對象。之後全部的操做都是對這個對象完成的。

Bean 的解析過程很是複雜，功能被分的很細，由於這裏須要被擴展的地方不少，必須保證有足夠的靈活性，以應對可能的變化。Bean 的解析主要就是對 Spring 配置文件的解析。這個解析過程主要經過下圖中的類完成：

圖 6. Bean 的解析類

固然還有具體對 tag 的解析這裏並無列出。

Context 組件

Context 在 Spring 的 org.springframework.context 包下，前面已經講解了 Context 組件在 Spring 中的做用，他實際上就是給 Spring 提供一個運行時的環境，用以保存各個對象的狀態。下面看一下這個環境是如何構建的。

ApplicationContext 是 Context 的頂級父類，他除了能標識一個應用環境的基本信息外，他還繼承了五個接口，這五個接口主要是擴展了 Context 的功能。下面是 Context 的類結構圖：

圖 7. Context 相關的類結構圖

（查看圖 7 的清晰版本。）

從上圖中能夠看出 ApplicationContext 繼承了 BeanFactory，這也說明了 Spring 容器中運行的主體對象是 Bean，另外 ApplicationContext 繼承了 ResourceLoader 接口，使得 ApplicationContext 能夠訪問到任何外部資源，這將在 Core 中詳細說明。

ApplicationContext 的子類主要包含兩個方面：

ConfigurableApplicationContext 表示該 Context 是可修改的，也就是在構建 Context 中用戶能夠動態添加或修改已有的配置信息，它下面又有多個子類，其中最常用的是可更新的 Context，即 AbstractRefreshableApplicationContext 類。
WebApplicationContext 顧名思義，就是爲 web 準備的 Context 他能夠直接訪問到 ServletContext，一般狀況下，這個接口使用的少。

再往下分就是按照構建 Context 的文件類型，接着就是訪問 Context 的方式。這樣一級一級構成了完整的 Context 等級層次。

整體來講 ApplicationContext 必需要完成如下幾件事：

標識一個應用環境
利用 BeanFactory 建立 Bean 對象
保存對象關係表
可以捕獲各類事件

Context 做爲 Spring 的 Ioc 容器，基本上整合了 Spring 的大部分功能，或者說是大部分功能的基礎。

Core 組件

Core 組件做爲 Spring 的核心組件，他其中包含了不少的關鍵類，其中一個重要組成部分就是定義了資源的訪問方式。這種把全部資源都抽象成一個接口的方式很值得在之後的設計中拿來學習。下面就重要看一下這個部分在 Spring 的做用。

下圖是 Resource 相關的類結構圖：

圖 8. Resource 相關的類結構圖

（查看圖 8 的清晰版本。）

從上圖能夠看出 Resource 接口封裝了各類可能的資源類型，也就是對使用者來講屏蔽了文件類型的不一樣。對資源的提供者來講，如何把資源包裝起來交給其餘人用這也是一個問題，咱們看到 Resource 接口繼承了 InputStreamSource 接口，這個接口中有個 getInputStream 方法，返回的是 InputStream 類。這樣全部的資源都被能夠經過 InputStream 這個類來獲取，因此也屏蔽了資源的提供者。另外還有一個問題就是加載資源的問題，也就是資源的加載者要統一，從上圖中能夠看出這個任務是由 ResourceLoader 接口完成，他屏蔽了全部的資源加載者的差別，只須要實現這個接口就能夠加載全部的資源，他的默認實現是 DefaultResourceLoader。

下面看一下 Context 和 Resource 是如何創建關係的？首先看一下他們的類關係圖：

圖 9. Context 和 Resource 的類關係圖

從上圖能夠看出，Context 是把資源的加載、解析和描述工做委託給了 ResourcePatternResolver 類來完成，他至關於一個接頭人，他把資源的加載、解析和資源的定義整合在一塊兒便於其餘組件使用。Core 組件中還有不少相似的方式。

Ioc 容器如何工做

前面介紹了 Core 組件、Bean 組件和 Context 組件的結構與相互關係，下面這裏從使用者角度看一下他們是如何運行的，以及咱們如何讓 Spring 完成各類功能，Spring 到底能有那些功能，這些功能是如何得來的，下面介紹。

如何建立 BeanFactory 工廠

正如圖 2 描述的那樣，Ioc 容器實際上就是 Context 組件結合其餘兩個組件共同構建了一個 Bean 關係網，如何構建這個關係網？構建的入口就在 AbstractApplicationContext 類的 refresh 方法中。這個方法的代碼以下：

清單 1. AbstractApplicationContext.refresh

public void refresh() throws BeansException, IllegalStateException { 
    synchronized (this.startupShutdownMonitor) { 
        // Prepare this context for refreshing. 
        prepareRefresh(); 
        // Tell the subclass to refresh the internal bean factory. 
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
        // Prepare the bean factory for use in this context. 
        prepareBeanFactory(beanFactory); 
        try { 
            // Allows post-processing of the bean factory in context subclasses. 
            postProcessBeanFactory(beanFactory); 
            // Invoke factory processors registered as beans in the context. 
            invokeBeanFactoryPostProcessors(beanFactory); 
            // Register bean processors that intercept bean creation. 
            registerBeanPostProcessors(beanFactory); 
            // Initialize message source for this context. 
            initMessageSource(); 
            // Initialize event multicaster for this context. 
            initApplicationEventMulticaster(); 
            // Initialize other special beans in specific context subclasses. 
            onRefresh(); 
            // Check for listener beans and register them. 
            registerListeners(); 
            // Instantiate all remaining (non-lazy-init) singletons. 
            finishBeanFactoryInitialization(beanFactory); 
            // Last step: publish corresponding event. 
            finishRefresh(); 
        } 
        catch (BeansException ex) { 
            // Destroy already created singletons to avoid dangling resources. 
            destroyBeans(); 
            // Reset 'active' flag. 
            cancelRefresh(ex); 
            // Propagate exception to caller. 
            throw ex; 
        } 
    } 
}

這個方法就是構建整個 Ioc 容器過程的完整的代碼，瞭解了裏面的每一行代碼基本上就瞭解大部分 Spring 的原理和功能了。

這段代碼主要包含這樣幾個步驟：

構建 BeanFactory，以便於產生所需的「演員」
註冊可能感興趣的事件
建立 Bean 實例對象
觸發被監聽的事件

下面就結合代碼分析這幾個過程。

第二三句就是在建立和配置 BeanFactory。這裏是 refresh 也就是刷新配置，前面介紹了 Context 有可更新的子類，這裏正是實現這個功能，當 BeanFactory 已存在是就更新，若是沒有就新建立。下面是更新 BeanFactory 的方法代碼：

清單 2. AbstractRefreshableApplicationContext. refreshBeanFactory

protected final void refreshBeanFactory() throws BeansException { 
    if (hasBeanFactory()) { 
        destroyBeans(); 
        closeBeanFactory(); 
    } 
    try { 
        DefaultListableBeanFactory beanFactory = createBeanFactory(); 
        beanFactory.setSerializationId(getId()); 
        customizeBeanFactory(beanFactory); 
        loadBeanDefinitions(beanFactory); 
        synchronized (this.beanFactoryMonitor) { 
            this.beanFactory = beanFactory; 
        } 
    } 
    catch (IOException ex) { 
        throw new ApplicationContextException(
			"I/O error parsing bean definition source for " 
			+ getDisplayName(), ex); 
    } 
}

這個方法實現了 AbstractApplicationContext 的抽象方法 refreshBeanFactory，這段代碼清楚的說明了 BeanFactory 的建立過程。注意 BeanFactory 對象的類型的變化，前面介紹了他有不少子類，在什麼狀況下使用不一樣的子類這很是關鍵。BeanFactory 的原始對象是 DefaultListableBeanFactory，這個很是關鍵，由於他設計到後面對這個對象的多種操做，下面看一下這個類的繼承層次類圖：

圖 10. DefaultListableBeanFactory 類繼承關係圖

（查看圖 10 的清晰版本。）

從這個圖中發現除了 BeanFactory 相關的類外，還發現了與 Bean 的 register 相關。這在 refreshBeanFactory 方法中有一行 loadBeanDefinitions(beanFactory) 將找到答案，這個方法將開始加載、解析 Bean 的定義，也就是把用戶定義的數據結構轉化爲 Ioc 容器中的特定數據結構。

這個過程能夠用下面時序圖解釋：

圖 11. 建立 BeanFactory 時序圖

（查看圖 11 的清晰版本。）

Bean 的解析和登記流程時序圖以下：

圖 12. 解析和登記 Bean 對象時序圖

（查看圖 12 的清晰版本。）

建立好 BeanFactory 後，接下去添加一些 Spring 自己須要的一些工具類，這個操做在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。

AbstractApplicationContext 中接下來的三行代碼對 Spring 的功能擴展性起了相當重要的做用。前兩行主要是讓你如今能夠對已經構建的 BeanFactory 的配置作修改，後面一行就是讓你能夠對之後再建立 Bean 的實例對象時添加一些自定義的操做。因此他們都是擴展了 Spring 的功能，因此咱們要學習使用 Spring 必須對這一部分搞清楚。

其中在 invokeBeanFactoryPostProcessors 方法中主要是獲取實現 BeanFactoryPostProcessor 接口的子類。並執行它的 postProcessBeanFactory 方法，這個方法的聲明以下：

清單 3. BeanFactoryPostProcessor.postProcessBeanFactory

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
    throws BeansException;

它的參數是 beanFactory，說明能夠對 beanFactory 作修改，這裏注意這個 beanFactory 是 ConfigurableListableBeanFactory 類型的，這也印證了前面介紹的不一樣 BeanFactory 所使用的場合不一樣，這裏只能是可配置的 BeanFactory，防止一些數據被用戶隨意修改。

registerBeanPostProcessors 方法也是能夠獲取用戶定義的實現了 BeanPostProcessor 接口的子類，並執行把它們註冊到 BeanFactory 對象中的 beanPostProcessors 變量中。BeanPostProcessor 中聲明瞭兩個方法：postProcessBeforeInitialization、postProcessAfterInitialization 分別用於在 Bean 對象初始化時執行。能夠執行用戶自定義的操做。

後面的幾行代碼是初始化監聽事件和對系統的其餘監聽者的註冊，監聽者必須是 ApplicationListener 的子類。

如何建立 Bean 實例並構建 Bean 的關係網

下面就是 Bean 的實例化代碼，是從 finishBeanFactoryInitialization 方法開始的。

清單 4. AbstractApplicationContext.finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(
	ConfigurableListableBeanFactory beanFactory) { 

    // Stop using the temporary ClassLoader for type matching. 
    beanFactory.setTempClassLoader(null); 

    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration(); 

    // Instantiate all remaining (non-lazy-init) singletons. 
    beanFactory.preInstantiateSingletons(); 
}

從上面代碼中能夠發現 Bean 的實例化是在 BeanFactory 中發生的。preInstantiateSingletons 方法的代碼以下：

清單 5. DefaultListableBeanFactory.preInstantiateSingletons

public void preInstantiateSingletons() throws BeansException { 
    if (this.logger.isInfoEnabled()) { 
        this.logger.info("Pre-instantiating singletons in " + this); 
    } 
    synchronized (this.beanDefinitionMap) { 
        for (String beanName : this.beanDefinitionNames) { 
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); 
            if (!bd.isAbstract() && bd.isSingleton() 
                && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) { 
                    final FactoryBean factory = 
                        (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName); 
                    boolean isEagerInit; 
                    if (System.getSecurityManager() != null 
                        && factory instanceof SmartFactoryBean) { 
                        isEagerInit = AccessController.doPrivileged(
                            new PrivilegedAction<Boolean>() { 
                            public Boolean run() { 
                                return ((SmartFactoryBean) factory).isEagerInit(); 
                            } 
                        }, getAccessControlContext()); 
                    } 
                    else { 
                        isEagerInit = factory instanceof SmartFactoryBean 
                            && ((SmartFactoryBean) factory).isEagerInit(); 
                    } 
                    if (isEagerInit) { 
                        getBean(beanName); 
                    } 
                } 
                else { 
                    getBean(beanName); 
                } 
            } 
        } 
    } 
}

這裏出現了一個很是重要的 Bean —— FactoryBean，能夠說 Spring 一大半的擴展的功能都與這個 Bean 有關，這是個特殊的 Bean 他是個工廠 Bean，能夠產生 Bean 的 Bean，這裏的產生 Bean 是指 Bean 的實例，若是一個類繼承 FactoryBean 用戶能夠本身定義產生實例對象的方法只要實現他的 getObject 方法。然而在 Spring 內部這個 Bean 的實例對象是 FactoryBean，經過調用這個對象的 getObject 方法就能獲取用戶自定義產生的對象，從而爲 Spring 提供了很好的擴展性。Spring 獲取 FactoryBean 自己的對象是在前面加上 & 來完成的。

如何建立 Bean 的實例對象以及如何構建 Bean 實例對象之間的關聯關係式 Spring 中的一個核心關鍵，下面是這個過程的流程圖。

圖 13.Bean 實例建立流程圖

點擊查看大圖

（查看圖 13 的清晰版本。）

若是是普通的 Bean 就直接建立他的實例，是經過調用 getBean 方法。下面是建立 Bean 實例的時序圖：

圖 14.Bean 實例建立時序圖

（查看圖 14 的清晰版本。）

還有一個很是重要的部分就是創建 Bean 對象實例之間的關係，這也是 Spring 框架的核心競爭力，什麼時候、如何創建他們之間的關係請看下面的時序圖：

圖 15.Bean 對象關係創建

（查看圖 15 的清晰版本。）

Ioc 容器的擴展點

如今還有一個問題就是如何讓這些 Bean 對象有必定的擴展性，就是能夠加入用戶的一些操做。那麼有哪些擴展點呢？ Spring 又是如何調用到這些擴展點的？

對 Spring 的 Ioc 容器來講，主要有這麼幾個。BeanFactoryPostProcessor， BeanPostProcessor。他們分別是在構建 BeanFactory 和構建 Bean 對象時調用。還有就是 InitializingBean 和 DisposableBean 他們分別是在 Bean 實例建立和銷燬時被調用。用戶能夠實現這些接口中定義的方法，Spring 就會在適當的時候調用他們。還有一個是 FactoryBean 他是個特殊的 Bean，這個 Bean 能夠被用戶更多的控制。

這些擴展點一般也是咱們使用 Spring 來完成咱們特定任務的地方，如何精通 Spring 就看你有沒有掌握好 Spring 有哪些擴展點，而且如何使用他們，要知道如何使用他們就必須瞭解他們內在的機理。能夠用下面一個比喻來解釋。

咱們把 Ioc 容器比做一個箱子，這個箱子裏有若干個球的模子，能夠用這些模子來造不少種不一樣的球，還有一個造這些球模的機器，這個機器能夠產生球模。那麼他們的對應關係就是 BeanFactory 就是那個造球模的機器，球模就是 Bean，而球模造出來的球就是 Bean 的實例。那前面所說的幾個擴展點又在什麼地方呢？ BeanFactoryPostProcessor 對應到當造球模被造出來時，你將有機會能夠對其作出設當的修正，也就是他能夠幫你修改球模。而 InitializingBean 和 DisposableBean 是在球模造球的開始和結束階段，你能夠完成一些預備和掃尾工做。BeanPostProcessor 就可讓你對球模造出來的球作出適當的修正。最後還有一個 FactoryBean，它但是一個神奇的球模。這個球模不是預先就定型了，而是由你來給他肯定它的形狀，既然你能夠肯定這個球模型的形狀，固然他造出來的球確定就是你想要的球了，這樣在這個箱子里尼能夠發現全部你想要的球

Ioc 容器如何爲我所用

前面的介紹了 Spring 容器的構建過程，那 Spring 能爲咱們作什麼，Spring 的 Ioc 容器又能作什麼呢？咱們使用 Spring 必需要首先構建 Ioc 容器，沒有它 Spring 沒法工做，ApplicatonContext.xml 就是 Ioc 容器的默認配置文件，Spring 的全部特性功能都是基於這個 Ioc 容器工做的，好比後面要介紹的 AOP。

Ioc 它實際上就是爲你構建了一個魔方，Spring 爲你搭好了骨骼架構，這個魔方到底能變出什麼好的東西出來，這必需要有你的參與。那咱們怎麼參與？這就是前面說的要了解 Spring 中那有些擴展點，咱們經過實現那些擴展點來改變 Spring 的通用行爲。至於如何實現擴展點來獲得咱們想要的個性結果，Spring 中有不少例子，其中 AOP 的實現就是 Spring 自己實現了其擴展點來達到了它想要的特性功能，能夠拿來參考。

回頁首

Spring 中 AOP 特性詳解

動態代理的實現原理

要了解 Spring 的 AOP 就必須先了解的動態代理的原理，由於 AOP 就是基於動態代理實現的。動態代理還要從 JDK 自己提及。

在 Jdk 的 java.lang.reflect 包下有個 Proxy 類，它正是構造代理類的入口。這個類的結構入下：

圖 16. Proxy 類結構

從上圖發現最後面四個是公有方法。而最後一個方法 newProxyInstance 就是建立代理對象的方法。這個方法的源碼以下：

清單 6. Proxy. newProxyInstance

public static Object newProxyInstance(ClassLoader loader, 
    Class<?>[] interfaces, 
    InvocationHandler h) 
    throws IllegalArgumentException { 
    
	if (h == null) { 
        throw new NullPointerException(); 
    } 
    Class cl = getProxyClass(loader, interfaces); 
    try { 
        Constructor cons = cl.getConstructor(constructorParams);
        return (Object) cons.newInstance(new Object[] { h }); 
    } catch (NoSuchMethodException e) { 
        throw new InternalError(e.toString()); 
    } catch (IllegalAccessException e) { 
        throw new InternalError(e.toString()); 
    } catch (InstantiationException e) { 
        throw new InternalError(e.toString()); 
    } catch (InvocationTargetException e) { 
        throw new InternalError(e.toString()); 
    } 
}

這個方法須要三個參數：ClassLoader，用於加載代理類的 Loader 類，一般這個 Loader 和被代理的類是同一個 Loader 類。Interfaces，是要被代理的那些那些接口。InvocationHandler，就是用於執行除了被代理接口中方法以外的用戶自定義的操做，他也是用戶須要代理的最終目的。用戶調用目標方法都被代理到 InvocationHandler 類中定義的惟一方法 invoke 中。這在後面再詳解。

下面仍是看看 Proxy 如何產生代理類的過程，他構造出來的代理類究竟是什麼樣子？下面揭曉啦。

圖 17. 建立代理對象時序圖

其實從上圖中能夠發現正在構造代理類的是在 ProxyGenerator 的 generateProxyClass 的方法中。ProxyGenerator 類在 sun.misc 包下，感興趣的話能夠看看他的源碼。

假若有這樣一個接口，以下：

清單 7. SimpleProxy 類

public interface SimpleProxy { 

    public void simpleMethod1(); 
	
    public void simpleMethod2(); 

}

代理來生成的類結構以下：

清單 8. $Proxy2 類

public class $Proxy2 extends java.lang.reflect.Proxy implements SimpleProxy{ 
    java.lang.reflect.Method m0; 
    java.lang.reflect.Method m1; 
    java.lang.reflect.Method m2; 
    java.lang.reflect.Method m3; 
    java.lang.reflect.Method m4; 

    int hashCode(); 
    boolean equals(java.lang.Object); 
    java.lang.String toString(); 
    void simpleMethod1(); 
    void simpleMethod2(); 
}

這個類中的方法裏面將會是調用 InvocationHandler 的 invoke 方法，而每一個方法也將對應一個屬性變量，這個屬性變量 m 也將傳給 invoke 方法中的 Method 參數。整個代理就是這樣實現的。

Spring AOP 如何實現

從前面代理的原理咱們知道，代理的目的是調用目標方法時咱們能夠轉而執行 InvocationHandler 類的 invoke 方法，因此如何在 InvocationHandler 上作文章就是 Spring 實現 Aop 的關鍵所在。

Spring 的 Aop 實現是遵照 Aop 聯盟的約定。同時 Spring 又擴展了它，增長了如 Pointcut、Advisor 等一些接口使得更加靈活。

下面是 Jdk 動態代理的類圖：

圖 18. Jdk 動態代理的類圖

上圖清楚的顯示了 Spring 引用了 Aop Alliance 定義的接口。姑且不討論 Spring 如何擴展 Aop Alliance，先看看 Spring 如何實現代理類的，要實現代理類在 Spring 的配置文件中一般是這樣定一個 Bean 的，以下：

清單 9. 配置代理類 Bean

<bean id="testBeanSingleton" 
    class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces">
        <value>
            org.springframework.aop.framework.PrototypeTargetTests$TestBean
        </value>
    </property>
    <property name="target"><ref local="testBeanTarget"></ref> </property>
    <property name="singleton"><value>true</value></property>
    <property name="interceptorNames">
        <list>
            <value>testInterceptor</value>
            <value>testInterceptor2</value>
        </list>
    </property>
</bean>

配置上看到要設置被代理的接口，和接口的實現類也就是目標類，以及攔截器也就在執行目標方法以前被調用，這裏 Spring 中定義的各類各樣的攔截器，能夠選擇使用。

下面看看 Spring 如何完成了代理以及是如何調用攔截器的。

前面提到 Spring Aop 也是實現其自身的擴展點來完成這個特性的，從這個代理類能夠看出它正是繼承了 FactoryBean 的 ProxyFactoryBean，FactoryBean 之因此特別就在它可讓你自定義對象的建立方法。固然代理對象要經過 Proxy 類來動態生成。

下面是 Spring 建立的代理對象的時序圖：

圖 19.Spring 代理對象的產生

Spring 建立了代理對象後，當你調用目標對象上的方法時，將都會被代理到 InvocationHandler 類的 invoke 方法中執行，這在前面已經解釋。在這裏 JdkDynamicAopProxy 類實現了 InvocationHandler 接口。

下面再看看 Spring 是如何調用攔截器的，下面是這個過程的時序圖：

圖 20.Spring 調用攔截器

以上所說的都是 Jdk 動態代理，Spring 還支持一種 CGLIB 類代理，感興趣本身看吧。

回頁首

Spring 中設計模式分析

Spring 中使用的設計模式也不少，好比工廠模式、單例模式、模版模式等，在《 Webx 框架的系統架構與設計模式》、《 Tomcat 的系統架構與模式設計分析》已經有介紹，這裏就不贅述了。這裏主要介紹代理模式和策略模式。

代理模式

代理模式原理

代理模式就是給某一個對象建立一個代理對象，而由這個代理對象控制對原對象的引用，而建立這個代理對象就是能夠在調用原對象是能夠增長一些額外的操做。下面是代理模式的結構：

圖 21. 代理模式的結構

Subject：抽象主題，它是代理對象的真實對象要實現的接口，固然這能夠是多個接口組成。
ProxySubject：代理類除了實現抽象主題定義的接口外，還必須持有所代理對象的引用
RealSubject：被代理的類，是目標對象。

Spring 中如何實現代理模式

Spring Aop 中 Jdk 動態代理就是利用代理模式技術實現的。在 Spring 中除了實現被代理對象的接口外，還會有 org.springframework.aop.SpringProxy 和 org.springframework.aop.framework.Advised 兩個接口。Spring 中使用代理模式的結構圖以下：

圖 22. Spring 中使用代理模式的結構圖

$Proxy 就是建立的代理對象，而 Subject 是抽象主題，代理對象是經過 InvocationHandler 來持有對目標對象的引用的。

Spring 中一個真實的代理對象結構以下：

清單 10 代理對象 $Proxy4

public class $Proxy4 extends java.lang.reflect.Proxy implements 
    org.springframework.aop.framework.PrototypeTargetTests$TestBean 
	org.springframework.aop.SpringProxy 
	org.springframework.aop.framework.Advised
{
    java.lang.reflect.Method m16;
    java.lang.reflect.Method m9;
    java.lang.reflect.Method m25;
    java.lang.reflect.Method m5;
    java.lang.reflect.Method m2;
    java.lang.reflect.Method m23;
    java.lang.reflect.Method m18;
    java.lang.reflect.Method m26;
    java.lang.reflect.Method m6;
    java.lang.reflect.Method m28;
    java.lang.reflect.Method m14;
    java.lang.reflect.Method m12;
    java.lang.reflect.Method m27;
    java.lang.reflect.Method m11;
    java.lang.reflect.Method m22;
    java.lang.reflect.Method m3;
    java.lang.reflect.Method m8;
    java.lang.reflect.Method m4;
    java.lang.reflect.Method m19;
    java.lang.reflect.Method m7;
    java.lang.reflect.Method m15;
    java.lang.reflect.Method m20;
    java.lang.reflect.Method m10;
    java.lang.reflect.Method m1;
    java.lang.reflect.Method m17;
    java.lang.reflect.Method m21;
    java.lang.reflect.Method m0;
    java.lang.reflect.Method m13;
    java.lang.reflect.Method m24;

    int hashCode();
    int indexOf(org.springframework.aop.Advisor);
    int indexOf(org.aopalliance.aop.Advice);
    boolean equals(java.lang.Object);
    java.lang.String toString();
    void sayhello();
    void doSomething();
    void doSomething2();
    java.lang.Class getProxiedInterfaces();
    java.lang.Class getTargetClass();
    boolean isProxyTargetClass();
    org.springframework.aop.Advisor; getAdvisors();
    void addAdvisor(int, org.springframework.aop.Advisor) 
		throws org.springframework.aop.framework.AopConfigException;
    void addAdvisor(org.springframework.aop.Advisor)
		throws org.springframework.aop.framework.AopConfigException;
    void setTargetSource(org.springframework.aop.TargetSource);
    org.springframework.aop.TargetSource getTargetSource();
    void setPreFiltered(boolean);
    boolean isPreFiltered();
    boolean isInterfaceProxied(java.lang.Class);
    boolean removeAdvisor(org.springframework.aop.Advisor);
    void removeAdvisor(int)throws org.springframework.aop.framework.AopConfigException;
    boolean replaceAdvisor(org.springframework.aop.Advisor, 
		org.springframework.aop.Advisor)
		throws org.springframework.aop.framework.AopConfigException;
    void addAdvice(org.aopalliance.aop.Advice) 
		throws org.springframework.aop.framework.AopConfigException;
    void addAdvice(int, org.aopalliance.aop.Advice) 
		throws org.springframework.aop.framework.AopConfigException;
    boolean removeAdvice(org.aopalliance.aop.Advice);
    java.lang.String toProxyConfigString();
    boolean isFrozen();
    void setExposeProxy(boolean);
    boolean isExposeProxy();
}

策略模式

策略模式原理

策略模式顧名思義就是作某事的策略，這在編程上一般是指完成某個操做可能有多種方法，這些方法各有千秋，可能有不一樣的適應的場合，然而這些操做方法都有可能用到。各一個操做方法都看成一個實現策略，使用者可能根據須要選擇合適的策略。

下面是策略模式的結構：

圖 23. 策略模式的結構

Context：使用不一樣策略的環境，它能夠根據自身的條件選擇不一樣的策略實現類來完成所要的操做。它持有一個策略實例的引用。建立具體策略對象的方法也能夠由他完成。
Strategy：抽象策略，定義每一個策略都要實現的策略方法
ConcreteStrategy：具體策略實現類，實現抽象策略中定義的策略方法

Spring 中策略模式的實現

Spring 中策略模式使用有多個地方，如 Bean 定義對象的建立以及代理對象的建立等。這裏主要看一下代理對象建立的策略模式的實現。

前面已經瞭解 Spring 的代理方式有兩個 Jdk 動態代理和 CGLIB 代理。這兩個代理方式的使用正是使用了策略模式。它的結構圖以下所示：

圖 24. Spring 中策略模式結構圖

在上面結構圖中與標準的策略模式結構稍微有點不一樣，這裏抽象策略是 AopProxy 接口，Cglib2AopProxy 和 JdkDynamicAopProxy 分別表明兩種策略的實現方式，ProxyFactoryBean 就是表明 Context 角色，它根據條件選擇使用 Jdk 代理方式仍是 CGLIB 方式，而另外三個類主要是來負責建立具體策略對象，ProxyFactoryBean 是經過依賴的方法來關聯具體策略對象的，它是經過調用策略對象的 getProxy(ClassLoader classLoader) 方法來完成操做。