Spring框架的設計理念與設計模式分析

　　Spring 的骨骼架構

　　Spring 總共有十幾個組件但是真正核心的組件只有幾個下面是 Spring 框架的總體架構圖

　　圖 Spring 框架的總體架構圖

　　 Spring 框架的設計理念與設計模式分析

　　從上圖中可以看出 Spring 框架中的核心組件只有三個CoreContext 和 Beans它們構建起了整個 Spring 的骨骼架構沒有它們就不可能有 AOPWeb 等上層的特性功能下面也將主要從這三個組件入手分析 Spring

　　Spring 的設計理念

　　前面介紹了 Spring 的三個核心組件如果再在它們三個中選出核心的話那就非 Beans 組件莫屬了為何這樣說其實 Spring 就是面向 Bean 的編程(BOPBean 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 更能讓你理解

　　它們之間可以用下圖來表示

　　圖三個組件關系

　　核心組件詳解

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

　　Bean 組件

　　前面已經說明了 Bean 組件對 Spring 的重要性下面看看 Bean 這個組件式怎麼設計的Bean 組件在 Spring 的 orgspringframeworkbeans 包下這個包下的所有類主要解決了三件事Bean 的定義Bean 的創建以及對 Bean 的解析對 Spring 的使用者來說唯一需要關心的就是 Bean 的創建其他兩個由 Spring 在內部幫你完成了對你來說是透明的

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

　　圖 Bean 工廠的繼承關系

　　核心組件：

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

　　Bean 的定義主要有 BeanDefinition 描述如下圖說明了這些類的層次關系

　　圖 Bean 定義的類層次關系圖

　　核心組件：

　　Bean 的定義就是完整的描述了在 Spring 的配置文件中你定義的節點中所有的信息包括各種子節點當 Spring 成功解析你定義的一個節點後在 Spring 的內部他就被轉化成 BeanDefinition 對象以後所有的操作都是對這個對象完成的

　　Bean 的解析過程非常復雜功能被分的很細因為這裡需要被擴展的地方很多必須保證有足夠的靈活性以應對可能的變化Bean 的解析主要就是對 Spring 配置文件的解析這個解析過程主要通過下圖中的類完成

　　圖 Bean 的解析類

　　核心組件：

　　當然還有具體對 tag 的解析這裡並沒有列出

　　Context 組件

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

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

　　圖 Context 相關的類結構圖

　　核心組件：Context 組件

　　從上圖中可以看出 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 相關的類結構圖

　　圖 Resource 相關的類結構圖

　　核心組件：Core 組件

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

　　下面看一下 Context 和 Resource 是如何建立關系的?首先看一下他們的類關系圖

　　圖 Context 和 Resource 的類關系圖

　　核心組件：

　　從上圖可以看出Context 是把資源的加載解析和描述工作委托給了 ResourcePatternResolver 類來完成他相當於一個接頭人他把資源的加載解析和資源的定義整合在一起便於其他組件使用Core 組件中還有很多類似的方式

　　Ioc 容器如何工作

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

　　如何創建 BeanFactory 工廠

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

　　清單 AbstractApplicationContextrefresh

public void refresh() throws BeansException IllegalStateException {
    synchronized (thisstartupShutdownMonitor) {
        // 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 postprocessing 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 (nonlazyinit) 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 的原理和功能了

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

　　注冊可能感興趣的事件

　　創建 Bean 實例對象

　　觸發被監聽的事件

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

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

　　清單 AbstractRefreshableApplicationContext refreshBeanFactory

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

　　這個方法實現了 AbstractApplicationContext 的抽象方法 refreshBeanFactory這段代碼清楚的說明了 BeanFactory 的創建過程注意 BeanFactory 對象的類型的變化前面介紹了他有很多子類在什麼情況下使用不同的子類這非常關鍵BeanFactory 的原始對象是 DefaultListableBeanFactory這個非常關鍵因為他設計到後面對這個對象的多種操作下面看一下這個類的繼承層次類圖

　　圖 DefaultListableBeanFactory 類繼承關系圖

　　如何創建 BeanFactory 工廠

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

　　這個過程可以用下面時序圖解釋

　　圖創建 BeanFactory 時序圖

　　如何創建 BeanFactory 工廠

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

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

　　如何創建 BeanFactory 工廠

　　創建好 BeanFactory 後接下去添加一些 Spring 本身需要的一些工具類這個操作在 AbstractApplicationContext 的 prepareBeanFactory 方法完成

　　AbstractApplicationContext 中接下來的三行代碼對 Spring 的功能擴展性起了至關重要的作用前兩行主要是讓你現在可以對已經構建的 BeanFactory 的配置做修改後面一行就是讓你可以對以後再創建 Bean 的實例對象時添加一些自定義的操作所以他們都是擴展了 Spring 的功能所以我們要學習使用 Spring 必須對這一部分搞清楚

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

　　清單 BeanFactoryPostProcessorpostProcessBeanFactory

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException;

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

　　registerBeanPostProcessors 方法也是可以獲取用戶定義的實現了 BeanPostProcessor 接口的子類並執行把它們注冊到 BeanFactory 對象中的 beanPostProcessors 變量中BeanPostProcessor 中聲明了兩個方法postProcessBeforeInitializationpostProcessAfterInitialization 分別用於在 Bean 對象初始化時執行可以執行用戶自定義的操作

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

　　如何創建 Bean 實例並構建 Bean 的關系網

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

　　清單 AbstractApplicationContextfinishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(
    ConfigurableListableBeanFactory beanFactory) {

    // Stop using the temporary ClassLoader for type matching
    beanFactorysetTempClassLoader(null);

    // Allow for caching all bean definition metadata not expecting further changes
    beanFactoryfreezeConfiguration();

    // Instantiate all remaining (nonlazyinit) singletons
    beanFactorypreInstantiateSingletons();
}

　　從上面代碼中可以發現 Bean 的實例化是在 BeanFactory 中發生的preInstantiateSingletons 方法的代碼如下

　　清單 DefaultListableBeanFactorypreInstantiateSingletons

public void preInstantiateSingletons() throws BeansException {
    if (thisloggerisInfoEnabled()) {
        (Preinstantiating singletons in + this);
    }
    synchronized (thisbeanDefinitionMap) {
        for (String beanName : thisbeanDefinitionNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bdisAbstract() && bdisSingleton()
                && !bdisLazyInit()) {
                if (isFactoryBean(beanName)) {
                    final FactoryBean factory =
                        (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName);
                    boolean isEagerInit;
                    if (SystemgetSecurityManager() != null
                        && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessControllerdoPrivileged(
                            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 中的一個核心關鍵下面是這個過程的流程圖

　　圖 Bean 實例創建流程圖

　　如何創建Bean實例並構建 Bean 的關系網

　　如果是普通的 Bean 就直接創建他的實例是通過調用 getBean 方法下面是創建 Bean 實例的時序圖

　　圖 Bean 實例創建時序圖

　　如何創建Bean實例並構建 Bean 的關系網

　　還有一個非常重要的部分就是建立 Bean 對象實例之間的關系這也是 Spring 框架的核心競爭力何時如何建立他們之間的關系請看下面的時序圖

　　圖 Bean 對象關系建立

　　如何創建Bean實例並構建 Bean 的關系網

　　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 無法工作ApplicatonContextxml 就是 Ioc 容器的默認配置文件Spring 的所有特性功能都是基於這個 Ioc 容器工作的比如後面要介紹的 AOP

　　Ioc 它實際上就是為你構建了一個魔方Spring 為你搭好了骨骼架構這個魔方到底能變出什麼好的東西出來這必須要有你的參與那我們怎麼參與?這就是前面說的要了解 Spring 中那有些擴展點我們通過實現那些擴展點來改變 Spring 的通用行為至於如何實現擴展點來得到我們想要的個性結果Spring 中有很多例子其中 AOP 的實現就是 Spring 本身實現了其擴展點來達到了它想要的特性功能可以拿來參考

　　Spring 中 AOP 特性詳解

　　動態代理的實現原理

　　要了解 Spring 的 AOP 就必須先了解的動態代理的原理因為 AOP 就是基於動態代理實現的動態代理還要從 JDK 本身說起

　　在 Jdk 的 javalangreflect 包下有個 Proxy 類它正是構造代理類的入口這個類的結構入下

　　圖 Proxy 類結構

　　動態代理的實現原理

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

　　清單 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 = clgetConstructor(constructorParams);
        return (Object) consnewInstance(new Object[] { h });
    } catch (NoSuchMethodException e) {
        throw new InternalError(etoString());
    } catch (IllegalAccessException e) {
        throw new InternalError(etoString());
    } catch (InstantiationException e) {
        throw new InternalError(etoString());
    } catch (InvocationTargetException e) {
        throw new InternalError(etoString());
    }
}

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

　　下面還是看看 Proxy 如何產生代理類的過程他構造出來的代理類到底是什麼樣子?下面揭曉啦

　　圖創建代理對象時序圖

　　動態代理的實現原理

　　其實從上圖中可以發現正在構造代理類的是在 ProxyGenerator 的 generateProxyClass 的方法中ProxyGenerator 類在 sunmisc 包下感興趣的話可以看看他的源碼

　　假如有這樣一個接口如下

　　清單 SimpleProxy 類

public interface SimpleProxy {
public void simpleMethod();
public void simpleMethod();
}

　　代理來生成的類結構如下

　　清單 $Proxy 類

public class $Proxy extends javalangreflectProxy implements SimpleProxy{
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;

    int hashCode();
    boolean equals(javalangObject);
    javalangString toString();
    void simpleMethod();
    void simpleMethod();
}

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

　　Spring AOP 如何實現

　　從前面代理的原理我們知道代理的目的是調用目標方法時我們可以轉而執行 InvocationHandler 類的 invoke 方法所以如何在 InvocationHandler 上做文章就是 Spring 實現 Aop 的關鍵所在

　　Spring 的 Aop 實現是遵守 Aop 聯盟的約定同時 Spring 又擴展了它增加了如 PointcutAdvisor 等一些接口使得更加靈活

　　下面是 Jdk 動態代理的類圖

　　圖 Jdk 動態代理的類圖

　　 Spring AOP 的實現

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

　　清單配置代理類 Bean

<bean id=testBeanSingleton
    class=orgspringframeworkaopframeworkProxyFactoryBean>
    <property name=proxyInterfaces>
        <value>
            orgspringframeworkaopframeworkPrototypeTargetTests$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>testInterceptor</value>
        </list>
    </property>
</bean>

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

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

　　前面提到 Spring Aop 也是實現其自身的擴展點來完成這個特性的從這個代理類可以看出它正是繼承了 FactoryBean 的 ProxyFactoryBeanFactoryBean 之所以特別就在它可以讓你自定義對象的創建方法當然代理對象要通過 Proxy 類來動態生成

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

　　圖 Spring 代理對象的產生

　　 Spring AOP 的實現

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

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

　　圖 Spring 調用攔截器

　　 Spring AOP 的實現

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

　　Spring 中設計模式分析

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

　　代理模式

　　代理模式原理

　　代理模式就是給某一個對象創建一個代理對象而由這個代理對象控制對原對象的引用而創建這個代理對象就是可以在調用原對象是可以增加一些額外的操作下面是代理模式的結構

　　圖代理模式的結構

　　 Spring 中設計模式分析

　　Subject抽象主題它是代理對象的真實對象要實現的接口當然這可以是多個接口組成

　　ProxySubject代理類除了實現抽象主題定義的接口外還必須持有所代理對象的引用

　　RealSubject被代理的類是目標對象

　　Spring 中如何實現代理模式

　　Spring Aop 中 Jdk 動態代理就是利用代理模式技術實現的在 Spring 中除了實現被代理對象的接口外還會有 orgspringframeworkaopSpringProxy 和 orgspringframeworkaopframeworkAdvised 兩個接口Spring 中使用代理模式的結構圖如下

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

　　 Spring 中設計模式分析

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

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

　　清單代理對象 $Proxy

public class $Proxy extends javalangreflectProxy implements
    orgspringframeworkaopframeworkPrototypeTargetTests$TestBean
    orgspringframeworkaopSpringProxy
    orgspringframeworkaopframeworkAdvised
{
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;
    javalangreflectMethod m;

    int hashCode();
    int indexOf(orgspringframeworkaopAdvisor);
    int indexOf(orgaopallianceaopAdvice);
    boolean equals(javalangObject);
    javalangString toString();
    void sayhello();
    void doSomething();
    void doSomething();
    javalangClass getProxiedInterfaces();
    javalangClass getTargetClass();
    boolean isProxyTargetClass();
    orgspringframeworkaopAdvisor; getAdvisors();
    void addAdvisor(int orgspringframeworkaopAdvisor)
        throws orgspringframeworkaopframeworkAopConfigException;
    void addAdvisor(orgspringframeworkaopAdvisor)
        throws orgspringframeworkaopframeworkAopConfigException;
    void setTargetSource(orgspringframeworkaopTargetSource);
    orgspringframeworkaopTargetSource getTargetSource();
    void setPreFiltered(boolean);
    boolean isPreFiltered();
    boolean isInterfaceProxied(javalangClass);
    boolean removeAdvisor(orgspringframeworkaopAdvisor);
    void removeAdvisor(int)throws orgspringframeworkaopframeworkAopConfigException;
    boolean replaceAdvisor(orgspringframeworkaopAdvisor
        orgspringframeworkaopAdvisor)
        throws orgspringframeworkaopframeworkAopConfigException;
    void addAdvice(orgaopallianceaopAdvice)
        throws orgspringframeworkaopframeworkAopConfigException;
    void addAdvice(int orgaopallianceaopAdvice)
        throws orgspringframeworkaopframeworkAopConfigException;
    boolean removeAdvice(orgaopallianceaopAdvice);
    javalangString toProxyConfigString();
    boolean isFrozen();
    void setExposeProxy(boolean);
    boolean isExposeProxy();
}

　　策略模式

　　策略模式原理

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

　　下面是策略模式的結構

　　圖策略模式的結構

　　策略模式

　　Context使用不同策略的環境它可以根據自身的條件選擇不同的策略實現類來完成所要的操作它持有一個策略實例的引用創建具體策略對象的方法也可以由他完成

　　Strategy抽象策略定義每個策略都要實現的策略方法

　　ConcreteStrategy具體策略實現類實現抽象策略中定義的策略方法

　　Spring 中策略模式的實現

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

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

　　圖 Spring 中策略模式結構圖

　　策略模式

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

　　總結

　　本文通過從 Spring 的幾個核心組件入手試圖找出構建 Spring 框架的骨骼架構進而分析 Spring 在設計的一些設計理念是否從中找出一些好的設計思想對我們以後程序設計能提供一些思路接著再詳細分析了 Spring 中是如何實現這些理念的以及在設計模式上是如何使用的

　　通過分析 Spring 給我一個很大的啟示就是其這套設計理念其實對我們有很強的借鑒意義它通過抽象復雜多變的對象進一步做規范然後根據它定義的這套規范設計出一個容器容器中構建它們的復雜關系其實現在有很多情況都可以用這種類似的處理方法

　　雖然我很想把我對 Spring 的想法完全闡述清楚但是所謂書不盡言言不盡意有什麼不對或者不清楚的地方大家還是看看其源碼吧

From:http://tw.wingwit.com/Article/program/Java/ky/201311/28629.html