spring設計原理

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

2016-1-27 by Damon

---

摘要：Spring作為現在最優秀的框架之一，被廣泛的使用并有很多對其分析的文章。本文將從另外一個視角試圖剖析出Spring框架的作者設計Spring框架的骨骼架構的設計理念，有那幾個核心組件？為什么需要這些組件？它們又是如何結合在一起構成Spring的骨骼架構？Spring的AOP特性又是如何利用這些基礎的骨骼架構來工作的？Spring中又使用了那些設計模式來完成它的這種設計的？它的這種設計理念對對我們以后的軟件設計有何啟示？本文將詳細解答這些問題。

一、Spring的骨骼架構

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更能讓你理解。

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

核心組件詳解

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

3.1 Bean組件

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

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

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

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

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

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

當然還有具體對tag的解析這里并沒有列出。

3.2 Context組件

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

ApplicationContext是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的大部分功能，或者說是大部分功能的基礎。

3.3 Core組件

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

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

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

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

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

3.4 Ioc容器如何工作

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

3.4.1 如何創建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，這個非常關鍵，因為他設計到后面對這個對象的多種操作，下面看一下這個類的繼承層次類圖：

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

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

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

創建好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的子類。

3.4.2 如何創建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中的一個核心關鍵，下面是這個過程的流程圖。

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

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

3.4.3 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，它可是一個神奇的球模。這個球模不是預先就定型了，而是由你來給他確定它的形狀，既然你可以確定這個球模型的形狀，當然他造出來的球肯定就是你想要的球了，這樣在這個箱子里尼可以發現所有你想要的球。

3.4.4 Ioc容器如何為我所用

前面的介紹了Spring容器的構建過程，那Spring能為我們做什么，Spring的Ioc容器又能做什么呢？我們使用Spring必須要首先構建Ioc容器，沒有它Spring無法工作，ApplicatonContext.xml就是Ioc容器的默認配置文件，Spring的所有特×××都是基于這個Ioc容器工作的，比如后面要介紹的AOP。

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

二、Spring中AOP特性詳解

1.動態代理的實現原理

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

在Jdk的java.lang.reflect包下有個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如何產生代理類的過程，他構造出來的代理類到底是什么樣子？下面揭曉啦。

其實從上圖中可以發現正在構造代理類的是在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參數。整個代理就是這樣實現的。

2.Spring AOP如何實現

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

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

下面是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創建的代理對象的時序圖：

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

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

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

轉載于:https://blog.51cto.com/damon188/1739324

總結

以上是生活随笔為你收集整理的Spring框架的设计理念与设计模式分析的全部內容，希望文章能夠幫你解決所遇到的問題。

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