本文主要剖析Spring框架的作者設計Spring框架的骨骼架構的設計理念，有那幾個核心組件？為什么需要這些組件？它們又是如何結合在一起構成Spring的骨骼架構？Spring的AOP特性又是如何利用這些基礎的骨骼架構來工作的？Spring中又使用了那些設計模式來完成它的這種設計的？它的這種設計理念對我們以后的軟件設計有何啟示？本文將詳細解答這些問題。
Spring的骨骼架構
Spring總共有十幾個組件，但是真正核心的組件只有幾個，下面是Spring框架的總體架構圖：
圖1.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更能讓你理解。
它們之間可以用下圖來表示：
圖2.三個組件關系
核心組件詳解
這里將詳細介紹每個組件內部類的層次關系，以及它們在運行時的時序順序。我們在使用Spring是應該注意的地方。
Bean組件
前面已經說明了Bean組件對Spring的重要性，下面看看Bean這個組件式怎么設計的。Bean組件在Spring的org.springframework.beans包下。這個包下的所有類主要解決了三件事：Bean的定義、Bean 的創建以及對Bean的解析。對Spring的使用者來說唯一需要關心的就是Bean的創建，其他兩個由Spring在內部幫你完成了，對你來說是透明的。
SpringBean的創建時典型的工廠模式，他的頂級接口是BeanFactory，下圖是這個工廠的繼承層次關系：
圖4.Bean工廠的繼承關系
BeanFactory有三個子類：ListableBeanFactory、HierarchicalBeanFactory和Autowire Capable Bean Factory。但是從上圖中我們可以發現最終的默認實現類是DefaultListableBeanFactory，他實 現了所有的接口。那為何要定義這么多層次的接口呢？查閱這些接口的源碼和說明發現，每個接口都有他使用的場合，它主要是為了區分在Spring內部在操作過程中對象的傳遞和轉化過程中，對對象的 數據訪問所做的限制。例如ListableBeanFactory接口表示這些Bean是可列表的，而HierarchicalBeanFactory表示的是這些Bean是有繼承關系的，也就是每個Bean有可能有父Bean。 AutowireCapableBeanFactory接口定義Bean的自動裝配規則。這四個接口共同定義了Bean的集合、Bean之間的關系、以及Bean行為。
Bean的定義主要有BeanDefinition描述，如下圖說明了這些類的層次關系：
圖5.Bean定義的類層次關系圖
Bean的定義就是完整的描述了在Spring的配置文件中你定義的節點中所有的信息，包括各種子節點。當Spring成功解析你定義的一個節點后，在Spring的內部他就被轉化 成BeanDefinition對象。以后所有的操作都是對這個對象完成的。
Bean的解析過程非常復雜，功能被分的很細，因為這里需要被擴展的地方很多，必須保證有足夠的靈活性，以應對可能的變化。Bean的解析主要就是對Spring配置文件的解析。這個解析過程主要通過 下圖中的類完成：
圖6.Bean的解析類
當然還有具體對tag的解析這里并沒有列出。
Context組件
Context在Spring的org.springframework.context包下，前面已經講解了Context組件在Spring中的作用，他實際上就是給Spring提供一個運行時的環境，用以保存各個對象的狀態。下面看一下這個 環境是如何構建的。
ApplicationContext是Context的頂級父類，他除了能標識一個應用環境的基本信息外，他還繼承了五個接口，這五個接口主要是擴展了Context的功能。下面是Context的類結構圖：
圖7.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相關的類結構圖：
圖8.Resource相關的類結構圖
從上圖可以看出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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
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& nbsp;the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean crea tion. registerBeanPostProcessors (beanFactory); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific contex t 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 dangl ing 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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
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& nbsp;parsing bean definition source for " + getDisplayName (), ex); } } |
這個方法實現了AbstractApplicationContext的抽象方法refreshBeanFactory，這段代碼清楚的說明了BeanFactory的創建過程。注意BeanFactory對象的類型的變化，前 面介紹了他有很多子類，在什么情況下使用不同的子類這非常關鍵。BeanFactory的原始對象是DefaultListableBeanFactory，這個非常關鍵，因為他設計到后面對這個對象的多種操作，下面看一下這個 類的繼承層次類圖：
圖10.DefaultListableBeanFactory類繼承關系圖
從這個圖中發現除了BeanFactory相關的類外，還發現了與Bean的register相關。這在refreshBeanFactory方法中有一行loadBeanDefinitions(beanFactory)將找到答案，這個方法將開始加載、解析 Bean的定義，也就是把用戶定義的數據結構轉化為Ioc容器中的特定數據結構。
這個過程可以用下面時序圖解釋：
圖11.創建BeanFactory時序圖
Bean的解析和登記流程時序圖如下：
圖12.解析和登記Bean對象時序圖
創建好BeanFactory后，接下去添加一些Spring本身需要的一些工具類，這個操作在AbstractApplicationContext的prepareBeanFactory方法完成。
AbstractApplicationContext中接下來的三行代碼對Spring的功能擴展性起了至關重要的作用。前兩行主要是讓你現在可以對已經構建的BeanFactory的配置做修改，后面一行就是讓你可以對以后再 創建Bean的實例對象時添加一些自定義的操作。所以他們都是擴展了Spring的功能，所以我們要學習使用Spring必須對這一部分搞清楚。
其中在invokeBeanFactoryPostProcessors方法中主要是獲取實現BeanFactoryPostProcessor接口的子類。并執行它的postProcessBeanFactory方法，這個方法的聲明如下：
清單3.BeanFactoryPostProcessor.postProcessBeanFactory
|
1
2
3
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
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( &nb sp; new PrivilegedAction<Boolean>() { &nb sp; public Boolean run() { return ((SmartFactoryBean) factory).isEagerInit(); &nb sp; } }, getAcce ssControlContext()); } else { isEagerInit = factory instanceof SmartFactoryBean &nb sp; && ((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實例創建流程圖
如果是普通的Bean就直接創建他的實例，是通過調用getBean方法。下面是創建Bean實例的時序圖：
圖14.Bean實例創建時序圖
還有一個非常重要的部分就是建立Bean對象實例之間的關系，這也是Spring框架的核心競爭力，何時、如何建立他們之間的關系請看下面的時序圖：
圖15.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無法工作，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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
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類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public interface SimpleProxy { public void simpleMethod1(); public void simpleMethod2(); } |
代理來生成的類結構如下：
清單 8.$Proxy2類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
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參數。整個代理就是這樣實現的。
SpringAOP如何實現
從前面代理的原理我們知道，代理的目的是調用目標方法時我們可以轉而執行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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
<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>truevalue>property> <property name="interceptorNames"> <list> <value>testInterceptorvalue> <value>testInterceptor2value> list> property> bean> |
配置上看到要設置被代理的接口，和接口的實現類也就是目標類，以及攔截器也就在執行目標方法之前被調用，這里Spring中定義的各種各樣的攔截器，可以選擇使用。
下面看看Spring如何完成了代理以及是如何調用攔截器的。
前面提到Spring Aop也是實現其自身的擴展點來完成這個特性的，從這個代理類可以看出它正是繼承了Factory Bean的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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
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 (ClassLoaderclassLoader)方法來完成操作。
總結
本文通過從Spring的幾個核心組件入手，試圖找出構建Spring框架的骨骼架構，進而分析Spring在設計的一些設計理念，是否從中找出一些好的設計思想，對我們以后程序設計能提供一些思路。接著 再詳細分析了Spring中是如何實現這些理念的，以及在設計模式上是如何使用的。
