1、Spring 的骨骼架構(gòu)Spring 總共有十幾個組件，但是真正架的總體架構(gòu)圖：的組件只有幾個，下面是Spring框圖1.Spring框架的總體架構(gòu)圖從上圖中可以看出 Spring 框架中的組件只有三個：Core、Context 和Beans。它們構(gòu)建起了整個 Spring 的骨骼架構(gòu)。沒有它們就不可能有 AOP、Web等上層的特性功能。下面也將主要從這三個組件入手分析 Spring。Spring 的設(shè)計理念前 面了 Spring 的三個組件，如果再在它們?nèi)齻€中選出的話，那就非 Beans 組件莫屬了，為何這樣說，其實（BOP,Bean Oriented Programming），BeanSp

2、ring 就是面向 Bean 的編程在 Spring 中才是真正的主角。Bean 在 Spring 中作用就像 Object 對 OOP的意義一樣，沒有對象的概念就像沒有面向?qū)ο缶幊?，Spring 中沒有 Bean 也就沒有 Spring的意義。就像一次演出舞臺都準備好了但是卻沒有演員一樣。為什么要 Bean 這種Bean或者為Spring 如此重要，這由 Spring 框架的設(shè)計目標決定，Spring 為何如此流行，我們用 Spring 的是什么，想想你會發(fā)現(xiàn)原來 Spring 解決了一個非常關(guān)鍵的他可以讓你把對象之間的依賴轉(zhuǎn)而用配置文件來管理，也就是他的依賴注入機制。而這個注入在一個叫 I

3、oc 容器中管理，那 Ioc容器中有又是什么就是被 Bean 包裹的對象。Spring 正是通過把對象包裝在Bean 中而達到對這些對象管理以及一些列額外操作的目的。它這種設(shè)計策略完全類似于 Java 實現(xiàn) OOP 的設(shè)計理念，當然了 Java 本身的設(shè)計要比 Spring 復雜太多太多，但是都是構(gòu)建一個數(shù)據(jù)結(jié)構(gòu)，然后根據(jù)這個數(shù)據(jù)結(jié)構(gòu)設(shè)計他的生存環(huán)境，并讓它在這個環(huán)境中按照一定的規(guī)律在不停的運動，在它們的不停運動中設(shè) 計一系列與環(huán)境或者與其他完成信息交換。這樣想來回過頭想想我們用到的其他框架都是大慨類似的設(shè)計理念。組件如何協(xié)同工作前 面說 Bean 是 Spring 中關(guān)鍵因素，那 Conte

4、xt 和 Core 又有何作用呢？前面吧 Bean 比作一場演出中的演員的話，那 Context 就是這場演出的舞臺背景， 而 Core 應(yīng)該就是演出的道具了。只有他們在一起才能具備能演出一場好戲的最基本的條件。當然有最基本的條件還不能使這場演出脫穎而出，還要他表演的節(jié)目足夠的，這些就是 Spring 能提供的特色功能了。我們知道 Bean 包裝的是Object，而要解決的Object 必然有數(shù)據(jù)，如何給這些數(shù)據(jù)提，對 Context 來說他就是要發(fā)現(xiàn)每個供生存環(huán)境就是Bean 之間的就是一個 BeanContext，為它們建立這種的集合，這個并且要維護好這種。所以 Context集合又叫 I

5、oc 容器，一旦建立起這個 Ioc容器后 Spring就可以為你工作了。那Core 組件又有什么用武之地呢？其實Core 就是發(fā)現(xiàn)、建立和維護每個這個角度看來，Core 這個組件叫Bean Util之間的所需要的一些列的工具，從更能讓你理解。它們之間可以用下圖來表示：圖 2. 三個組件組件詳解這里將詳細每個組件內(nèi)部類的層次，以及它們在運行時的時序順序。我們在使用 Spring 是應(yīng)該注意的地方。Bean 組件前 面已經(jīng)說明了 Bean 組件對 Spring 的重要性，下面看看 Bean 這個組件式怎么設(shè)計的。Bean 組件在 Spring 的 org.springframework.beans

6、 包下。這個包下的所有類主要解決了三件事：Bean 的定義、Bean 的創(chuàng)建以及對 Bean 的解析。對 Spring 的使用者來說唯一需要關(guān)心的就是 Bean 的創(chuàng)建，其他兩個由Spring 在內(nèi)部幫你完成了，對你來說是透明的。Spring Bean 的創(chuàng)建時典型的工廠模式，他的頂級接口是BeanFactory，下圖是這個工廠的繼承層次：圖 4. Bean 工廠的繼承BeanFactory 有三個子類：ListableBeanFactory、HierarchicalBeanFactory和AutowireCapableBeanFactory。但是從上圖中我們可以發(fā)現(xiàn)最終的默認實現(xiàn)類是Defa

7、ultListableBeanFactory，他實現(xiàn)了所有的接口。那為何要定義這么多層次的接口呢？查閱這些接口的源碼和說明發(fā)現(xiàn)，每個接口 都有他使用的場合，它主要是為了區(qū)分在 Spring 內(nèi)部在操作過程中對象的傳遞和轉(zhuǎn)化過程中，對對象的數(shù)據(jù)所做的限制。例如 ListableBeanFactory 接口表示這些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是這些 Bean 是有繼承的，也就是每個 Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定義Bean以及的自動裝配規(guī)則。這四個接口共同定義了 Bean 的集合、B

8、ean 之間的Bean 行為。、Bean的定義主要有 BeanDefinition 描述，如下圖說明了這些類的層次：圖 5.Bean 定義的類層次圖Bean 的是完整的描述了在 Spring 的配置文件中你定義的 <bean/> 節(jié)點中所有的信息，各節(jié)點。當 Spring你定義的一個 <bean/>節(jié)點后，在 Spring 的內(nèi)部他就被轉(zhuǎn)化成 BeanDefinition 對象。以后所有的操作都是對這個對象完成的。Bean 的過程非常復雜，功能被分的很細，因為這里需要被擴展的地方很多，必須保證有足夠的靈活性，以應(yīng)對可能的變化。Bean 的主要就是對Spring配置文件的

9、。這個過程主要通過下圖中的類完成：圖 6. Bean 的類當然還有具體對 tag 的這里并沒有列出。Context 組件Context 在 Spring 的 org.springframework.context 包下，前面已經(jīng)講解了Context 組件在 Spring 中的作用，他實際上就是給 Spring 提供一個運行時的環(huán)境，用以保存各個對象的狀態(tài)。下面看一下這個環(huán)境是如何構(gòu)建的。ApplicationContext 是 Context 的頂級父類，他除了能標識一個應(yīng)用環(huán)境的基本信息外，他還繼承了五個接口，這五個接口主要是擴展了下面是 Context 的類結(jié)構(gòu)圖：Context的功能。圖

10、 7. Context 相關(guān)的類結(jié)構(gòu)圖（查看 圖 7 的清晰版本。）從 上圖中可以看出 ApplicationContext繼承了 BeanFactory，這也說明了Spring 容器中運行的主體對象是 Bean，另外 ApplicationContext 繼承了ResourceLoader 接口，使得 ApplicationContext 可以到任何外部這將在 Core 中詳細說明。，ApplicationContext 的子類主要包含兩個方面：1. ConfigurableApplicationContext 表示該 Context 是可修改的，也就是在構(gòu)建 Context 中用戶可以動態(tài)

11、添加或修改已有的配置信息，它下面又有多個子類，其中最經(jīng)常使用的是可更新的 Context，即AbstractRefreshableApplicationContext 類。2. WebApplicationContext 顧名思義，就是為 web 準備的 Context 他可以直接到 ServletContext，通常情況下，這個接口使用的少。再往下分就是按照構(gòu)建 Context 的文件類型，接著就是Context 的方式。這樣一級一級了完整的 Context 等級層次?？傮w來說 ApplicationContext 必須要完成以下幾件事：· 標識一個應(yīng)用環(huán)境··

12、·利用 BeanFactory 創(chuàng)建 Bean 對象保存對象表能夠捕獲各種Context 作為 Spring 的 Ioc者說是大部分功能的基礎(chǔ)。容器，基本上整合了 Spring 的大部分功能，或Core 組件Core 組件作為 Spring 的要組成部分就是定義了組件，他其中包含了很多的，其中一個重的方式。這種把所有都抽象成一個接口的方式很值得在以后的設(shè)計中拿來學習。下面就重要看一下這個部分在用。Spring的作下圖是 Resource 相關(guān)的類結(jié)構(gòu)圖：圖 8. Resource 相關(guān)的類結(jié)構(gòu)圖（查看 圖 8 的清晰版本。）從 上圖可以看出 Resource 接口封裝了各種可能的類型

13、，也就是對使用者來說了文件類型的不同。對的提供者來說，如何把包裝起來交給其他人用這也是一個，我們看到 Resource 接口繼承了 InputStreamSource接口，這個接口中有個 getInputStream，返回的是 InputStream 類。這樣所有的都被可以通過 InputStream 這個類來獲取，所以也了的，提供者。另外還有一個就是加載的，也就是的加載者從上圖中可以看出這個任務(wù)是由 ResourceLoader 接口完成，他了所有的資源加載者的差異，只需要實現(xiàn)這個接口就可以加載所有的DefaultResourceLoader。，他的默認實現(xiàn)是下面看一下 Context 和

14、Resource 是如何建立系圖：的？首先看一下他們的類關(guān)圖9.Context和Resource的類圖從上圖可以看出，Context 是把的加載、和描述工作委托給了ResourcePatternResolver 類來完成，他相當于一個接頭人，他把的加載、和 方式。的定義整合在一起便于其他組件使用。Core 組件中還有很多類似的Ioc 容器如何工作前面了 Core 組件、Bean 組件和 Context 組件的結(jié)構(gòu)與相互，下面這里從使用者角度看一下他們是如何運行的，以及我們?nèi)绾巫?Spring 完成各種功能，Spring 到底能有那些功能，這些功能是如何得來的，下面。如何創(chuàng)建 BeanFacto

15、ry 工廠正 如圖 2 描述的那樣，Ioc 容器實際上就是Context 組件結(jié)合其他兩個組件共同構(gòu)建了一個 Bean網(wǎng)，如何構(gòu)建這個網(wǎng)？構(gòu)建的中。這個就在的代碼如下：AbstractApplicationContext 類的 refresh1. AbstractApplicationContext.refreshpublic void refresh() throws BeansException, IllegalStateException synchronized (this.startupShutdownMonitor) / Prepare this context for refre

16、shing. 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 contextsubcla

17、sses.postProcessBeanFactory(beanFactory);/ Invoke factory processors registered as beans in thecontext.invokeBeanFactoryPostProcessors(beanFactory);/ Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory);/ Initialize message source for this context. initMessa

18、geSource();/ Initialize event multicaster for this context. initApplicationEventMulticaster();/ Initialize other special beans in specific contextsubclasses.onRefresh();/ Check for listener beans and register them. registerListeners();/ Instantiate all remaining (non-lazy-init) singletons. finishBea

19、nFactoryInitialization(beanFactory);/ Last step: publish corresponding event. finishRefresh();catch (BeansException ex) / Destroy already created singletons to avoid danglingresources.destroyBeans();/ Reset 'active' flag. cancelRefresh(ex);/ Propagate exception to caller. throw ex;這個就是構(gòu)建整個 I

20、oc 容器過程的完整的代碼，了解了里面的每一行代碼基本上就了解大部分 Spring 的原理和功能了。這段代碼主要包含這樣幾個步驟：·構(gòu)建 BeanFactory，以便于產(chǎn)生所需的“演員”···可能感的創(chuàng)建 Bean 實例對象觸發(fā)被的下面就結(jié)合代碼分析這幾個過程。第 二三句就是在創(chuàng)建和配置 BeanFactory。這里是 refresh 也就是刷新配置， 前面了 Context 有可更新的子類，這里正是實現(xiàn)這個功能，當 BeanFactory已是就更新，如果沒有就新創(chuàng)建。下面是更新 BeanFactory 的代碼：2. AbstractRefreshabl

21、eApplicationContext. refreshBeanFactoryprotected final void refreshBeanFactory() throws BeansException if (hasBeanFactory() destroyBeans(); closeBeanFactory();try DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId(); customizeBeanFactory(beanFactory);

22、loadBeanDefinitions(beanFactory);synchronized (this.beanFactoryMonitor) this.beanFactory = beanFactory;catch (IOException ex) throw new ApplicationContextException("I/O error parsing bean definition source for "+ getDisplayName(), ex);這個實現(xiàn)了 AbstractApplicationContext 的抽象refreshBeanFactory，

23、這段代碼清楚的說明了 BeanFactory 的創(chuàng)建過程。注意BeanFactory 對象的類型的變化，前面了他有很多子類，在什么情況下使用不同的子類這非常關(guān)鍵。BeanFactory 的原始對象是DefaultListableBeanFactory，這個非常關(guān)鍵，因為他設(shè)計到后面對這個對象的多種操作，下面看一下這個類的繼承層次類圖：圖 10. DefaultListableBeanFactory 類繼承圖（查看 圖 10 的清晰版本。）從 這個圖中發(fā)現(xiàn)除了 BeanFactory 相關(guān)的類外，還發(fā)現(xiàn)了與 Bean 的register 相關(guān)。這在 refreshBeanFactory load

24、BeanDefinitions(beanFactory) 將找到中有一行，這個將開始加載、Bean 的定義，也就是把用戶定義的數(shù)據(jù)結(jié)構(gòu)轉(zhuǎn)化為Ioc容器中的特定數(shù)據(jù)結(jié)構(gòu)。這個過程可以用下面時序圖解釋：圖 11. 創(chuàng)建 BeanFactory 時序圖（查看 圖 11 的清晰版本。）Bean 的和登記流程時序圖如下：圖 12.和登記 Bean 對象時序圖（查看 圖 12 的清晰版本。）創(chuàng)建好 BeanFactory 后，接下去添加一些 Spring 本身需要的一些工具類，這個操作在 AbstractApplicationContext 的 prepareBeanFactory完成。AbstractA

25、pplicationContext 中接下來的三行代碼對 Spring 的功能擴展性起了的作用。前兩行主要是讓你現(xiàn)在可以對已經(jīng)構(gòu)建的 BeanFactory 的配置做修改，后面一行就是讓你可以對以后再創(chuàng)建 Bean 的實例對象時添加一些自定義的操作。所以他們都是擴展了 Spring 的功能，所以我們要學習使用Spring 必須對這一部分搞清楚。其中在 invokeBeanFactoryPostProcessors中主要是獲取實現(xiàn)BeanFactoryPostProcessor 接口的子類。并執(zhí)行它的 postProcessBeanFactory，這個的如下：3. BeanFactoryPost

26、Processor.postProcessBeanFactoryvoid postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throws BeansException;它的參數(shù)是 beanFactory，說明可以對 beanFactory 做修改，這里注意這個beanFactory 是 ConfigurableListableBeanFactory 類型的，這也印證了前面的不同 BeanFactory 所使用的場合不同，這里只能是可配置的BeanFactory，防止一些數(shù)據(jù)被用戶隨意修改。registerBea

27、nPostProcessors也是可以獲取用戶定義的實現(xiàn)了BeanPostProcessor 接口的子類，并執(zhí)行把它們到 BeanFactory 對象中的beanPostProcessors 變量中。BeanPostProcessor 中了兩個：postProcessBeforeInitialization、postProcessAfterInitialization 分別用于在 Bean 對象初始化時執(zhí)行?？梢詧?zhí)行用戶自定義的操作。后面的幾行代碼是初始化ApplicationListener 的子類。和對系統(tǒng)的其他者的者必須是如何創(chuàng)建 Bean 實例并構(gòu)建 Bean 的網(wǎng)下面就是 Bean

28、的實例化代碼，是從 finishBeanFactoryInitialization開始的。4. AbstractApplicationContext.finishBeanFactoryInitializationprotected void finishBeanFactoryInitialization( ConfigurableListableBeanFactory beanFactory) / Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null);/ Allo

29、w for caching all bean definition metadata, not expecting further changes.beanFactory.freezeConfiguration();/ Instantiate all remaining (non-lazy-init) singletons. beanFactory.preInstantiateSingletons();從上面代碼中可以發(fā)現(xiàn) Bean 的實例化是在 BeanFactory 中發(fā)生的。preInstantiateSingletons的代碼如下：5. DefaultListableBeanFacto

30、ry.preInstantiateSingletonspublic void preInstantiateSingletons() throws BeansException if (this.logger.isInfoEnabled() ("Pre-instantiating singletons in " + this);synchronized (this.beanDefinitionMap) for (String beanName : this.beanDefinitionNames) RootBeanDefinition bd =

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

32、 instanceof SmartFactoryBean) isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() public Boolean run() return (SmartFactoryBean)factory).isEagerInit();, getAccessControlContext();else isEagerInit = factory instanceofSmartFactoryBean&& (SmartFactoryBean)factory).

33、isEagerInit();if (isEagerInit) getBean(beanName);else getBean(beanName);這里出現(xiàn)了一個非常重要的 Bean FactoryBean，可以說 Spring一大半的擴展的功能都與這個 Bean 有關(guān)，這是個特殊的 Bean 他是個工廠 Bean，可以產(chǎn)生 Bean 的 Bean，這里的產(chǎn)生 Bean 是指 Bean 的實例，如果一個類繼承FactoryBean 用戶可以定義產(chǎn)生實例對象的只要實現(xiàn)他的 getObject。在 Spring 內(nèi)部這個 Bean 的實例對象是 FactoryBean，通過調(diào)用這個對象的 getObj

34、ect就能獲取用戶自定義產(chǎn)生的對象，從而為 Spring 提供了很好的擴展性。Spring 獲取 FactoryBean 本身的對象是在前面加上 & 來完成的。如何創(chuàng)建 Bean 的實例對象以及如何構(gòu)建 Bean 實例對象之間的關(guān)聯(lián)式Spring 中的一個關(guān)鍵，下面是這個過程的流程圖。圖13.Bean 實例創(chuàng)建流程圖點擊查看大圖（查看 圖 13 的清晰版本。）如果是普通的 Bean 就直接創(chuàng)建他的實例，是通過調(diào)用創(chuàng)建 Bean 實例的時序圖：getBean。下面是圖 14.Bean 實例創(chuàng)建時序圖（查看 圖 14 的清晰版本。）還有一個非常重要的部分就是建立 Bean 對象實例之間的，

35、這也是 Spring框架的競爭力，何時、如何建立他們之間的請看下面的時序圖：圖 15.Bean 對象建立（查看 圖 15 的清晰版本。）Ioc 容器的擴展點現(xiàn)在還有一個就是如何讓這些 Bean 對象有一定的擴展性，就是可以加入用戶的一些操作。那么有哪些擴展點呢？ Spring 又是如何調(diào)用到這些擴展點的？對 Spring 的 Ioc 容器來說，主要有這么幾個。BeanFactoryPostProcessor， BeanPostProcessor。他們分別是在構(gòu)建 BeanFactory 和構(gòu)建 Bean 對象時調(diào)用。還有就是 InitializingBean 和 DisposableBean

36、他們分別是在 Bean 實例創(chuàng)建和銷毀時被調(diào)用。用戶可以實現(xiàn)這些接口中定義的，Spring 就會在適當?shù)臅r候調(diào)用他們。還有一個是 FactoryBean 他是個特殊的 Bean，這個 Bean 可以被用戶的。這些擴展點通常也是我們使用 Spring 來完成我們特定任務(wù)的地方，如何精通Spring 就看你有沒有掌握好 Spring 有哪些擴展點，并且如何使用他們，要知道如何使用他們就必須了解他們內(nèi)在的機理?？梢杂孟旅嬉粋€比喻來解釋。我 們把 Ioc 容器比作一個箱子，這個箱子里有若干個球的模子，可以用這些模子來造很多種不同的球，還有一個造這些球模的，這個可以產(chǎn)生球模。，球模就是那么他們的對應(yīng)就是

37、 BeanFactory 就是那個造球模的Bean，而球模造出來的球就是 Bean 的實例。那前面所說的幾個擴展點又在什么地方呢？ BeanFactoryPostProcessor 對應(yīng)到當造球模被造出來時，你將有機會可以對其做出設(shè)當?shù)?，也就是他可以幫你修改球模。?InitializingBean和 DisposableBean 是在球模造球的開始和結(jié)束階段，你可以完成一些預(yù)備和掃尾工作。BeanPostProcessor 就可以讓你對球模造出來的球做出適當?shù)?。最后還有一個 FactoryBean，它一個神奇的球模。這個球模不是預(yù)先就定型了，而是由你來給他確定它的形狀，既然你可以確定這個球模

38、型的形狀，當然他造出來 的球肯定就是你想要的球了，這樣在這個箱子可以發(fā)現(xiàn)所有你想要的球Ioc 容器如何為我所用前的它面的了 Spring 容器的構(gòu)建過程，那 Spring 能為我們做什么，SpringIoc 容器又能做什么呢？我們使用 Spring 必須要首先構(gòu)建 Ioc 容器，沒有Spring 無法工作，ApplicatonContext.xml 就是 Ioc 容器的默認配置文件，Spring 的所有特性功能都是基于這個 Ioc 容器工作的，比如后面要的 AOP。Ioc 它實際上就是為你構(gòu)建了一個魔方，Spring 為你搭好了骨骼架構(gòu)，這個魔方到底能變出什么好的東西出來，這必須要有你的參與。

39、那我們怎么參與？這就是前面說的要了解 Spring 中那有些擴展點，我們通過實現(xiàn)那些擴展點來改變Spring 的通用行為。至于如何實現(xiàn)擴展點來得到我們想要的個性結(jié)果，Spring 中有很多例子，其中 AOP 的實現(xiàn)就是 Spring 本身實現(xiàn)了其擴展點來達到了它想要的特性功能，可以拿來參考?；仨撌譙pring 中 AOP 特性詳解動態(tài)的實現(xiàn)原理要了解 Spring 的 AOP 就必須先了解的動態(tài)的原理，因為 AOP 就是基于動態(tài)實現(xiàn)的。動態(tài)還要從 JDK 本身說起。在 Jdk 的 java.lang.reflect 包下有個 Proxy 類，它正是構(gòu)造這個類的結(jié)構(gòu)入下：類的。圖 16. Pro

40、xy 類結(jié)構(gòu)從上圖發(fā)現(xiàn)最后面四個是公有。而最后一個newProxyInstance 就是創(chuàng)建對象的。這個的源碼如下：6. Proxy. newProxyInstancepublic static Object newProxyInstance(ClassLoader loader, Class<?> interfaces,InvocationHandler h)throws IllegalArgumentException if (h = null) throw new NullPointerException();Class cl = getProxyClass(loader,

41、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) thro

42、w new InternalError(e.toString(); catch (InvocationTargetException e) throw new InternalError(e.toString();這個需要三個參數(shù)：ClassLoader，用于加載類的 Loader 類，通常這個 Loader 和被的類是同一個 Loader 類。Interfaces，是要被的那些之外的用都被代那些接口。InvocationHandler，就是用于執(zhí)行除了被接口中戶自定義的操作， 他也是用戶需要的最終目的。用戶調(diào)用目標理到 InvocationHandler 類中定義的唯一invoke 中。這在

43、后面再詳解。下面還是看看 Proxy 如何產(chǎn)生樣子？下面揭曉啦。類的過程，他構(gòu)造出來的類到底是什么圖17.創(chuàng)建對象時序圖其實從上圖中可以發(fā)現(xiàn)正在構(gòu)造類的是在 ProxyGenerator的generateProxyClass 的中。ProxyGenerator 類在 sun.misc 包下，感的話他的源碼。假這樣一個接口，如下：7. SimpleProxy 類public interface SimpleProxy public void simpleMethod1();public void simpleMethod2();來生成的類結(jié)構(gòu)如下：8. $Proxy2 類public class

44、 $Proxy2 extends SimpleProxyjava.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Methodjava.lang.reflect.Proxyimplementsm0;m1;m2;m3;m4;int hashCode();boolean equals(java.lang.Object); java.lang.String toString();void simpleMethod1(); v

45、oid simpleMethod2();這個類中的里面將會是調(diào)用 InvocationHandler 的invoke invoke，而每個中的也將對應(yīng)一個屬性變量，這個屬性變量 m 也將傳給Method 參數(shù)。整個就是這樣實現(xiàn)的。Spring AOP 如何實現(xiàn)從前面的原理我們知道，的目的是調(diào)用目標時我們可以轉(zhuǎn)而執(zhí)行InvocationHandler 上做InvocationHandler 類的 invoke，所以如文章就是 Spring 實現(xiàn) Aop 的關(guān)鍵所在。Spring 的 Aop 實現(xiàn)是遵守 Aop的約定。同時 Spring 又擴展了它，增加了如 Pointcut、Advisor 等一

46、些接口使得更加靈活。下面是 Jdk 動態(tài)的類圖：圖 18. Jdk 動態(tài)的類圖上 圖清楚的顯示了 Spring了 Aop Alliance 定義的接口。姑且不討論Spring 如何擴展 Aop Alliance，先看看 Spring 如何實現(xiàn)類的，要實現(xiàn)代理類在 Spring 的配置文件中通常是這樣定一個 Bean 的，如下：9. 配置類 Bean<bean id="testBeanSingleton" class="org.springframework.aop.framework.ProxyFactoryBean"><propert

47、y name="proxyInterfaces"><value>org.springframework.aop.framework.PrototypeTargetTests$TestBean</value></property><property</property><property<propertyname="target"><ref local="testBeanTarget"></ref>name="singleto

48、n"><value>true</value></property> name="interceptorNames"><list><value>testInterceptor</value><value>testInterceptor2</value></list></property></bean>配置上看到要設(shè)置被的接口，和接口的實現(xiàn)類也就是目標類，以及器也器，可以就在執(zhí)行目標之前被調(diào)用，這里 Spring 中定義的各種

49、各樣的選擇使用。下面看看 Spring 如何完成了以及是如何調(diào)用器的。前 面提到 Spring Aop 也是實現(xiàn)其自身的擴展點來完成這個特性的，從這個代理類可以看出它正是繼承了 FactoryBean 的 ProxyFactoryBean，F(xiàn)actoryBean之所以特別就在它可以讓你自定義對象的創(chuàng)建類來動態(tài)生成。當然對象要通過Proxy下面是 Spring創(chuàng)建的對象的時序圖：圖19.Spring對象的產(chǎn)生Spring 創(chuàng)建了對象后，當你調(diào)用目標對象上的時，將都會被到InvocationHandler 類的 invoke中執(zhí)行，這在前面已經(jīng)解釋。在這里JdkDynamicAopProxy 類實

50、現(xiàn)了 InvocationHandler 接口。下面再看看 Spring 是如何調(diào)用器的，下面是這個過程的時序圖：圖 20.Spring 調(diào)用器以上所說的都是 Jdk 動態(tài)己看吧。，Spring 還支持一種 CGLIB 類，感自回頁首Spring 中設(shè)計模式分析Spring 中使用的設(shè)計模式也很多，比如工廠模式、單例模式、模版模式等，在 Webx 框架的系統(tǒng)架構(gòu)與設(shè)計模式、 Tomcat 的系統(tǒng)架構(gòu)與模式設(shè)計分析已經(jīng)有，這里就不贅述了。這里主要模式和策略模式。模式模式原理模式就是給某一個對象創(chuàng)建一個對象，而由這個對象對原對象的，而創(chuàng)建這個對象就是可以在調(diào)用原對象是可以增加一些額外的操作。下面是

51、模式的結(jié)構(gòu)：圖21.模式的結(jié)構(gòu)·Subject：抽象，它是對象的真實對象要實現(xiàn)的接口，當然這可以是多個接口組成。·ProxySubject： 理對象的RealSubject：被類除了實現(xiàn)抽象定義的接口外，還必須持有所代·的類，是目標對象。Spring 中如何實現(xiàn)模式Spring Aop 中 Jdk 動態(tài)就是利用模式技術(shù)實現(xiàn)的。在 Spring 中除了實現(xiàn)被對象的接口外，還會有 org.springframework.aop.SpringProxy 和org.springframework.aop.framework.Advised 兩個接口。Spring 中使用模

52、式的結(jié)構(gòu)圖如下：圖 22. Spring 中使用模式的結(jié)構(gòu)圖$Proxy 就是創(chuàng)建的對象，而 Subject 是抽象，對象是通過InvocationHandler 來持有對目標對象的的。Spring中一個真實的對象結(jié)構(gòu)如下：10對象 $Proxy4publicclass $Proxy4 extends java.lang.reflect.Proxy implementsorg.springframework.aop.framework.PrototypeTargetTests$TestBean org.springframework.aop.SpringProxy org.springfram

53、ework.aop.framework.Advisedjava.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Metho

54、d java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Methodm16;m9; m25;m5;m2; m23; m18; m26;m6; m28; m14; m12; m27; m11; m22;m3;m8;m4; m19;java.lang.reflect.M

55、ethod java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Method java.lang.reflect.Methodm7; m15; m20; m10;m1; m17; m21;m0; m13; m24;int int inthashCode(); indexOf(org.springframework.aop.Advisor); indexOf(org.aopalliance.aop.Advice);boolean equals(java.lang.Object); java.lang.String toString();void void voidsayhello(); doSomething(); doSomething2();java.lang.Class getProxiedInterfaces(); jav