溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
Spring的工作原理是什么呢，很多新手對(duì)此不是很清楚，為了幫助大家解決這個(gè)難題，下面小編將為大家詳細(xì)講解，有這方面需求的人可以來(lái)學(xué)習(xí)下，希望你能有所收獲。
Spring 總共有十幾個(gè)組件，但是真正核心的組件只有幾個(gè)，下面是 Spring 框架的總體架構(gòu)圖：
圖 1 .Spring 框架的總體架構(gòu)圖
從上圖中可以看出 Spring 框架中的核心組件只有三個(gè)：Core、Context 和 Beans。它們構(gòu)建起了整個(gè) Spring 的骨骼架構(gòu)。沒(méi)有它們就不可能有 AOP、Web 等上層的特性功能。下面也將主要從這三個(gè)組件入手分析 Spring。
前面介紹了 Spring 的三個(gè)核心組件，如果再在它們?nèi)齻€(gè)中選出核心的話，那就非 Beans 組件莫屬了，為何這樣說(shuō)，其實(shí) Spring 就是面向 Bean 的編程（BOP,Bean Oriented Programming），Bean 在 Spring 中才是真正的主角。
Bean 在 Spring 中作用就像 Object 對(duì) OOP 的意義一樣，沒(méi)有對(duì)象的概念就像沒(méi)有面向?qū)ο缶幊蹋?span lang="EN-US">Spring 中沒(méi)有 Bean 也就沒(méi)有 Spring 存在的意義。就像一次演出舞臺(tái)都準(zhǔn)備好了但是卻沒(méi)有演員一樣。為什么要 Bean 這種角色 Bean 或者為何在 Spring 如此重要，這由 Spring 框架的設(shè)計(jì)目標(biāo)決定，Spring 為何如此流行，我們用 Spring 的原因是什么，想想你會(huì)發(fā)現(xiàn)原來(lái) Spring 解決了一個(gè)非常關(guān)鍵的問(wèn)題他可以讓你把對(duì)象之間的依賴關(guān)系轉(zhuǎn)而用配置文件來(lái)管理，也就是他的依賴注入機(jī)制。而這個(gè)注入關(guān)系在一個(gè)叫 Ioc 容器中管理，那 Ioc 容器中有又是什么就是被 Bean 包裹的對(duì)象。Spring 正是通過(guò)把對(duì)象包裝在 Bean 中而達(dá)到對(duì)這些對(duì)象管理以及一些列額外操作的目的。
它這種設(shè)計(jì)策略完全類似于 Java 實(shí)現(xiàn) OOP 的設(shè)計(jì)理念，當(dāng)然了 Java 本身的設(shè)計(jì)要比 Spring 復(fù)雜太多太多，但是都是構(gòu)建一個(gè)數(shù)據(jù)結(jié)構(gòu)，然后根據(jù)這個(gè)數(shù)據(jù)結(jié)構(gòu)設(shè)計(jì)他的生存環(huán)境，并讓它在這個(gè)環(huán)境中按照一定的規(guī)律在不停的運(yùn)動(dòng)，在它們的不停運(yùn)動(dòng)中設(shè)計(jì)一系列與環(huán)境或者與其他個(gè)體完成信息交換。這樣想來(lái)回過(guò)頭想想我們用到的其他框架都是大慨類似的設(shè)計(jì)理念。
前面說(shuō) Bean 是 Spring 中關(guān)鍵因素，那 Context 和 Core 又有何作用呢？前面吧 Bean 比作一場(chǎng)演出中的演員的話，那 Context 就是這場(chǎng)演出的舞臺(tái)背景，而 Core 應(yīng)該就是演出的道具了。只有他們?cè)谝黄鸩拍芫邆淠苎莩鲆粓?chǎng)好戲的最基本的條件。當(dāng)然有最基本的條件還不能使這場(chǎng)演出脫穎而出，還要他表演的節(jié)目足夠的精彩，這些節(jié)目就是 Spring 能提供的特色功能了。
我們知道 Bean 包裝的是 Object，而 Object 必然有數(shù)據(jù)，如何給這些數(shù)據(jù)提供生存環(huán)境就是 Context 要解決的問(wèn)題，對(duì) Context 來(lái)說(shuō)他就是要發(fā)現(xiàn)每個(gè) Bean 之間的關(guān)系，為它們建立這種關(guān)系并且要維護(hù)好這種關(guān)系。所以 Context 就是一個(gè) Bean 關(guān)系的集合，這個(gè)關(guān)系集合又叫 Ioc 容器，一旦建立起這個(gè) Ioc 容器后 Spring 就可以為你工作了。那 Core 組件又有什么用武之地呢？其實(shí) Core 就是發(fā)現(xiàn)、建立和維護(hù)每個(gè) Bean 之間的關(guān)系所需要的一些列的工具，從這個(gè)角度看來(lái)，Core 這個(gè)組件叫 Util 更能讓你理解。
它們之間可以用下圖來(lái)表示：
圖 2. 三個(gè)組件關(guān)系
這里將詳細(xì)介紹每個(gè)組件內(nèi)部類的層次關(guān)系，以及它們?cè)谶\(yùn)行時(shí)的時(shí)序順序。我們?cè)谑褂?span lang="EN-US"> Spring 是應(yīng)該注意的地方。
Bean 組件
前面已經(jīng)說(shuō)明了 Bean 組件對(duì) Spring 的重要性，下面看看 Bean 這個(gè)組件式怎么設(shè)計(jì)的。Bean 組件在 Spring 的 org.springframework.beans 包下。這個(gè)包下的所有類主要解決了三件事：Bean 的定義、Bean 的創(chuàng)建以及對(duì) Bean 的解析。對(duì) Spring 的使用者來(lái)說(shuō)唯一需要關(guān)心的就是 Bean 的創(chuàng)建，其他兩個(gè)由 Spring 在內(nèi)部幫你完成了，對(duì)你來(lái)說(shuō)是透明的。
Spring Bean 的創(chuàng)建時(shí)典型的工廠模式，他的頂級(jí)接口是 BeanFactory，
BeanFactory 有三個(gè)子類：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是從上圖中我們可以發(fā)現(xiàn)最終的默認(rèn)實(shí)現(xiàn)類是 DefaultListableBeanFactory，他實(shí)現(xiàn)了所有的接口。那為何要定義這么多層次的接口呢？查閱這些接口的源碼和說(shuō)明發(fā)現(xiàn)，每個(gè)接口都有他使用的場(chǎng)合，它主要是為了區(qū)分在 Spring 內(nèi)部在操作過(guò)程中對(duì)象的傳遞和轉(zhuǎn)化過(guò)程中，對(duì)對(duì)象的數(shù)據(jù)訪問(wèn)所做的限制。例如 ListableBeanFactory 接口表示這些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是這些 Bean 是有繼承關(guān)系的，也就是每個(gè) Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定義 Bean 的自動(dòng)裝配規(guī)則。這四個(gè)接口共同定義了 Bean 的集合、Bean 之間的關(guān)系、以及 Bean 行為。
Bean 的定義主要有 BeanDefinition 描述
Bean 的定義就是完整的描述了在 Spring 的配置文件中你定義的 <bean/> 節(jié)點(diǎn)中所有的信息，包括各種子節(jié)點(diǎn)。當(dāng) Spring 成功解析你定義的一個(gè) <bean/> 節(jié)點(diǎn)后，在 Spring 的內(nèi)部他就被轉(zhuǎn)化成 BeanDefinition 對(duì)象。以后所有的操作都是對(duì)這個(gè)對(duì)象完成的。
Bean 的解析過(guò)程非常復(fù)雜，功能被分的很細(xì)，因?yàn)檫@里需要被擴(kuò)展的地方很多，必須保證有足夠的靈活性，以應(yīng)對(duì)可能的變化。Bean 的解析主要就是對(duì) Spring 配置文件的解析。
Context 組件
Context 在 Spring 的 org.springframework.context 包下，前面已經(jīng)講解了 Context 組件在 Spring 中的作用，他實(shí)際上就是給 Spring 提供一個(gè)運(yùn)行時(shí)的環(huán)境，用以保存各個(gè)對(duì)象的狀態(tài)。下面看一下這個(gè)環(huán)境是如何構(gòu)建的。
ApplicationContext 是 Context 的頂級(jí)父類，他除了能標(biāo)識(shí)一個(gè)應(yīng)用環(huán)境的基本信息外，他還繼承了五個(gè)接口，這五個(gè)接口主要是擴(kuò)展了 Context 的功能。下面是 Context 的類結(jié)構(gòu)圖：
圖 7. Context 相關(guān)的類結(jié)構(gòu)圖
（查看 圖 7 的清晰版本。）
從上圖中可以看出 ApplicationContext 繼承了 BeanFactory，這也說(shuō)明了 Spring 容器中運(yùn)行的主體對(duì)象是 Bean，另外 ApplicationContext 繼承了 ResourceLoader 接口，使得 ApplicationContext 可以訪問(wèn)到任何外部資源，這將在 Core 中詳細(xì)說(shuō)明。
ApplicationContext 的子類主要包含兩個(gè)方面：
1. ConfigurableApplicationContext 表示該 Context 是可修改的，也就是在構(gòu)建 Context 中用戶可以動(dòng)態(tài)添加或修改已有的配置信息，它下面又有多個(gè)子類，其中最經(jīng)常使用的是可更新的 Context，即 AbstractRefreshableApplicationContext 類。
2. WebApplicationContext 顧名思義，就是為 web 準(zhǔn)備的 Context 他可以直接訪問(wèn)到 ServletContext，通常情況下，這個(gè)接口使用的少。
再往下分就是按照構(gòu)建 Context 的文件類型，接著就是訪問(wèn) Context 的方式。這樣一級(jí)一級(jí)構(gòu)成了完整的 Context 等級(jí)層次。
總體來(lái)說(shuō) ApplicationContext 必須要完成以下幾件事：
標(biāo)識(shí)一個(gè)應(yīng)用環(huán)境
利用 BeanFactory 創(chuàng)建 Bean 對(duì)象
保存對(duì)象關(guān)系表
能夠捕獲各種事件
Context 作為 Spring 的 Ioc 容器，基本上整合了 Spring 的大部分功能，或者說(shuō)是大部分功能的基礎(chǔ)。
Core 組件
Core 組件作為 Spring 的核心組件，他其中包含了很多的關(guān)鍵類，其中一個(gè)重要組成部分就是定義了資源的訪問(wèn)方式。這種把所有資源都抽象成一個(gè)接口的方式很值得在以后的設(shè)計(jì)中拿來(lái)學(xué)習(xí)。下面就重要看一下這個(gè)部分在 Spring 的作用。
從上圖可以看出 Resource 接口封裝了各種可能的資源類型，也就是對(duì)使用者來(lái)說(shuō)屏蔽了文件類型的不同。對(duì)資源的提供者來(lái)說(shuō)，如何把資源包裝起來(lái)交給其他人用這也是一個(gè)問(wèn)題，我們看到 Resource 接口繼承了 InputStreamSource 接口，這個(gè)接口中有個(gè) getInputStream 方法，返回的是 InputStream 類。這樣所有的資源都被可以通過(guò) InputStream 這個(gè)類來(lái)獲取，所以也屏蔽了資源的提供者。另外還有一個(gè)問(wèn)題就是加載資源的問(wèn)題，也就是資源的加載者要統(tǒng)一，從上圖中可以看出這個(gè)任務(wù)是由 ResourceLoader 接口完成，他屏蔽了所有的資源加載者的差異，只需要實(shí)現(xiàn)這個(gè)接口就可以加載所有的資源，他的默認(rèn)實(shí)現(xiàn)是 DefaultResourceLoader。
下面看一下 Context 和 Resource 是如何建立關(guān)系的？
Context 是把資源的加載、解析和描述工作委托給了 ResourcePatternResolver 類來(lái)完成，他相當(dāng)于一個(gè)接頭人，他把資源的加載、解析和資源的定義整合在一起便于其他組件使用。Core 組件中還有很多類似的方式。
Ioc 容器如何工作
前面介紹了 Core 組件、Bean 組件和 Context 組件的結(jié)構(gòu)與相互關(guān)系，下面這里從使用者角度看一下他們是如何運(yùn)行的，以及我們?nèi)绾巫?span lang="EN-US"> Spring 完成各種功能，Spring 到底能有那些功能，這些功能是如何得來(lái)的，下面介紹。
如何創(chuàng)建 BeanFactory 工廠
正如圖 2 描述的那樣，Ioc 容器實(shí)際上就是 Context 組件結(jié)合其他兩個(gè)組件共同構(gòu)建了一個(gè) Bean 關(guān)系網(wǎng)，如何構(gòu)建這個(gè)關(guān)系網(wǎng)？構(gòu)建的入口就在 AbstractApplicationContext 類的 refresh 方法中。這個(gè)方法的代碼如下：
清單 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 | 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; } } } |
這個(gè)方法就是構(gòu)建整個(gè) Ioc 容器過(guò)程的完整的代碼，了解了里面的每一行代碼基本上就了解大部分 Spring 的原理和功能了。
這段代碼主要包含這樣幾個(gè)步驟：
構(gòu)建 BeanFactory，以便于產(chǎn)生所需的“演員”
注冊(cè)可能感興趣的事件
創(chuàng)建 Bean 實(shí)例對(duì)象
觸發(fā)被監(jiān)聽(tīng)的事件
下面就結(jié)合代碼分析這幾個(gè)過(guò)程。
第二三句就是在創(chuàng)建和配置 BeanFactory。這里是 refresh 也就是刷新配置，前面介紹了 Context 有可更新的子類，這里正是實(shí)現(xiàn)這個(gè)功能，當(dāng) BeanFactory 已存在是就更新，如果沒(méi)有就新創(chuàng)建。下面是更新 BeanFactory 的方法代碼：
清單 2. AbstractRefreshableApplicationContext. refreshBeanFactory
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 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); } } |
這個(gè)方法實(shí)現(xiàn)了 AbstractApplicationContext 的抽象方法 refreshBeanFactory，這段代碼清楚的說(shuō)明了 BeanFactory 的創(chuàng)建過(guò)程。注意 BeanFactory 對(duì)象的類型的變化，前面介紹了他有很多子類，在什么情況下使用不同的子類這非常關(guān)鍵。BeanFactory 的原始對(duì)象是 DefaultListableBeanFactory，這個(gè)非常關(guān)鍵，因?yàn)樗O(shè)計(jì)到后面對(duì)這個(gè)對(duì)象的多種操作。
從這個(gè)圖中發(fā)現(xiàn)除了 BeanFactory 相關(guān)的類外，還發(fā)現(xiàn)了與 Bean 的 register 相關(guān)。這在 refreshBeanFactory 方法中有一行 loadBeanDefinitions(beanFactory) 將找到答案，這個(gè)方法將開始加載、解析 Bean 的定義，也就是把用戶定義的數(shù)據(jù)結(jié)構(gòu)轉(zhuǎn)化為 Ioc 容器中的特定數(shù)據(jù)結(jié)構(gòu)。
這個(gè)過(guò)程可以用Bean 的解析和登記流程時(shí)序圖解釋
創(chuàng)建好 BeanFactory 后，接下去添加一些 Spring 本身需要的一些工具類，這個(gè)操作在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。
AbstractApplicationContext 中接下來(lái)的三行代碼對(duì) Spring 的功能擴(kuò)展性起了至關(guān)重要的作用。前兩行主要是讓你現(xiàn)在可以對(duì)已經(jīng)構(gòu)建的 BeanFactory 的配置做修改，后面一行就是讓你可以對(duì)以后再創(chuàng)建 Bean 的實(shí)例對(duì)象時(shí)添加一些自定義的操作。所以他們都是擴(kuò)展了 Spring 的功能，所以我們要學(xué)習(xí)使用 Spring 必須對(duì)這一部分搞清楚。
其中在 invokeBeanFactoryPostProcessors 方法中主要是獲取實(shí)現(xiàn) BeanFactoryPostProcessor 接口的子類。并執(zhí)行它的 postProcessBeanFactory 方法，這個(gè)方法的聲明如下：
清單 3. BeanFactoryPostProcessor.postProcessBeanFactory
1 2 | void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException; |
它的參數(shù)是 beanFactory，說(shuō)明可以對(duì) beanFactory 做修改，這里注意這個(gè) beanFactory 是 ConfigurableListableBeanFactory 類型的，這也印證了前面介紹的不同 BeanFactory 所使用的場(chǎng)合不同，這里只能是可配置的 BeanFactory，防止一些數(shù)據(jù)被用戶隨意修改。
registerBeanPostProcessors 方法也是可以獲取用戶定義的實(shí)現(xiàn)了 BeanPostProcessor 接口的子類，并執(zhí)行把它們注冊(cè)到 BeanFactory 對(duì)象中的 beanPostProcessors 變量中。BeanPostProcessor 中聲明了兩個(gè)方法：postProcessBeforeInitialization、postProcessAfterInitialization 分別用于在 Bean 對(duì)象初始化時(shí)執(zhí)行。可以執(zhí)行用戶自定義的操作。
后面的幾行代碼是初始化監(jiān)聽(tīng)事件和對(duì)系統(tǒng)的其他監(jiān)聽(tīng)者的注冊(cè)，監(jiān)聽(tīng)者必須是 ApplicationListener 的子類。
如何創(chuàng)建 Bean 實(shí)例并構(gòu)建 Bean 的關(guān)系網(wǎng)
下面就是 Bean 的實(shí)例化代碼，是從 finishBeanFactoryInitialization 方法開始的。
清單 4. AbstractApplicationContext.finishBeanFactoryInitialization
1 2 3 4 5 6 7 8 9 10 11 12 | 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(); } |
從上面代碼中可以發(fā)現(xiàn) Bean 的實(shí)例化是在 BeanFactory 中發(fā)生的。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 | 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); } } } } } |
這里出現(xiàn)了一個(gè)非常重要的 Bean —— FactoryBean，可以說(shuō) Spring 一大半的擴(kuò)展的功能都與這個(gè) Bean 有關(guān)，這是個(gè)特殊的 Bean 他是個(gè)工廠 Bean，可以產(chǎn)生 Bean 的 Bean，這里的產(chǎn)生 Bean 是指 Bean 的實(shí)例，如果一個(gè)類繼承 FactoryBean 用戶可以自己定義產(chǎn)生實(shí)例對(duì)象的方法只要實(shí)現(xiàn)他的 getObject 方法。然而在 Spring 內(nèi)部這個(gè) Bean 的實(shí)例對(duì)象是 FactoryBean，通過(guò)調(diào)用這個(gè)對(duì)象的 getObject 方法就能獲取用戶自定義產(chǎn)生的對(duì)象，從而為 Spring 提供了很好的擴(kuò)展性。Spring 獲取 FactoryBean 本身的對(duì)象是在前面加上 & 來(lái)完成的。
如何創(chuàng)建 Bean 的實(shí)例對(duì)象以及如何構(gòu)建 Bean 實(shí)例對(duì)象之間的關(guān)聯(lián)關(guān)系式 Spring 中的一個(gè)核心關(guān)鍵。
如果是普通的 Bean 就直接創(chuàng)建他的實(shí)例，是通過(guò)調(diào)用 getBean 方法。
還有一個(gè)非常重要的部分就是建立 Bean 對(duì)象實(shí)例之間的關(guān)系，這也是 Spring 框架的核心競(jìng)爭(zhēng)力。
Ioc 容器的擴(kuò)展點(diǎn)
現(xiàn)在還有一個(gè)問(wèn)題就是如何讓這些 Bean 對(duì)象有一定的擴(kuò)展性，就是可以加入用戶的一些操作。那么有哪些擴(kuò)展點(diǎn)呢？ Spring 又是如何調(diào)用到這些擴(kuò)展點(diǎn)的？
對(duì) Spring 的 Ioc 容器來(lái)說(shuō)，主要有這么幾個(gè)。BeanFactoryPostProcessor， BeanPostProcessor。他們分別是在構(gòu)建 BeanFactory 和構(gòu)建 Bean 對(duì)象時(shí)調(diào)用。還有就是 InitializingBean 和 DisposableBean 他們分別是在 Bean 實(shí)例創(chuàng)建和銷毀時(shí)被調(diào)用。用戶可以實(shí)現(xiàn)這些接口中定義的方法，Spring 就會(huì)在適當(dāng)?shù)臅r(shí)候調(diào)用他們。還有一個(gè)是 FactoryBean 他是個(gè)特殊的 Bean，這個(gè) Bean 可以被用戶更多的控制。
這些擴(kuò)展點(diǎn)通常也是我們使用 Spring 來(lái)完成我們特定任務(wù)的地方，如何精通 Spring 就看你有沒(méi)有掌握好 Spring 有哪些擴(kuò)展點(diǎn)，并且如何使用他們，要知道如何使用他們就必須了解他們內(nèi)在的機(jī)理?？梢杂孟旅嬉粋€(gè)比喻來(lái)解釋。
我們把 Ioc 容器比作一個(gè)箱子，這個(gè)箱子里有若干個(gè)球的模子，可以用這些模子來(lái)造很多種不同的球，還有一個(gè)造這些球模的機(jī)器，這個(gè)機(jī)器可以產(chǎn)生球模。那么他們的對(duì)應(yīng)關(guān)系就是 BeanFactory 就是那個(gè)造球模的機(jī)器，球模就是 Bean，而球模造出來(lái)的球就是 Bean 的實(shí)例。那前面所說(shuō)的幾個(gè)擴(kuò)展點(diǎn)又在什么地方呢？ BeanFactoryPostProcessor 對(duì)應(yīng)到當(dāng)造球模被造出來(lái)時(shí)，你將有機(jī)會(huì)可以對(duì)其做出設(shè)當(dāng)?shù)男拚?，也就是他可以幫你修改球模。?span lang="EN-US"> InitializingBean 和 DisposableBean 是在球模造球的開始和結(jié)束階段，你可以完成一些預(yù)備和掃尾工作。BeanPostProcessor 就可以讓你對(duì)球模造出來(lái)的球做出適當(dāng)?shù)男拚?。最后還有一個(gè) FactoryBean，它可是一個(gè)神奇的球模。這個(gè)球模不是預(yù)先就定型了，而是由你來(lái)給他確定它的形狀，既然你可以確定這個(gè)球模型的形狀，當(dāng)然他造出來(lái)的球肯定就是你想要的球了，這樣在這個(gè)箱子里尼可以發(fā)現(xiàn)所有你想要的球
Ioc 容器如何為我所用
前面的介紹了 Spring 容器的構(gòu)建過(guò)程，那 Spring 能為我們做什么，Spring 的 Ioc 容器又能做什么呢？我們使用 Spring 必須要首先構(gòu)建 Ioc 容器，沒(méi)有它 Spring 無(wú)法工作，ApplicatonContext.xml 就是 Ioc 容器的默認(rèn)配置文件，Spring 的所有特性功能都是基于這個(gè) Ioc 容器工作的，比如后面要介紹的 AOP。
Ioc 它實(shí)際上就是為你構(gòu)建了一個(gè)魔方，Spring 為你搭好了骨骼架構(gòu)，這個(gè)魔方到底能變出什么好的東西出來(lái)，這必須要有你的參與。那我們?cè)趺磪⑴c？這就是前面說(shuō)的要了解 Spring 中那有些擴(kuò)展點(diǎn)，我們通過(guò)實(shí)現(xiàn)那些擴(kuò)展點(diǎn)來(lái)改變 Spring 的通用行為。至于如何實(shí)現(xiàn)擴(kuò)展點(diǎn)來(lái)得到我們想要的個(gè)性結(jié)果，Spring 中有很多例子，其中 AOP 的實(shí)現(xiàn)就是 Spring 本身實(shí)現(xiàn)了其擴(kuò)展點(diǎn)來(lái)達(dá)到了它想要的特性功能。
要了解 Spring 的 AOP 就必須先了解的動(dòng)態(tài)代理的原理，因?yàn)?span lang="EN-US"> AOP 就是基于動(dòng)態(tài)代理實(shí)現(xiàn)的。動(dòng)態(tài)代理還要從 JDK 本身說(shuō)起。
在 Jdk 的 java.lang.reflect 包下有個(gè) Proxy 類，它正是構(gòu)造代理類的入口。
發(fā)現(xiàn)最后面四個(gè)是公有方法。而最后一個(gè)方法 newProxyInstance 就是創(chuàng)建代理對(duì)象的方法。這個(gè)方法的源碼如下：
清單 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 | 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()); } } |
這個(gè)方法需要三個(gè)參數(shù)：ClassLoader，用于加載代理類的 Loader 類，通常這個(gè) Loader 和被代理的類是同一個(gè) Loader 類。Interfaces，是要被代理的那些那些接口。InvocationHandler，就是用于執(zhí)行除了被代理接口中方法之外的用戶自定義的操作，他也是用戶需要代理的最終目的。用戶調(diào)用目標(biāo)方法都被代理到 InvocationHandler 類中定義的唯一方法 invoke 中。這在后面再詳解。
下面還是看看 Proxy 如何產(chǎn)生代理類的過(guò)程，他構(gòu)造出來(lái)的代理類到底是什么樣子？
其實(shí)從上圖中可以發(fā)現(xiàn)正在構(gòu)造代理類的是在 ProxyGenerator 的 generateProxyClass 的方法中。ProxyGenerator 類在 sun.misc 包下，感興趣的話可以看看他的源碼。
假如有這樣一個(gè)接口，如下：
清單 7. SimpleProxy 類
1 2 3 4 5 6 7 | public interface SimpleProxy {
public void simpleMethod1();
public void simpleMethod2();
} |
代理來(lái)生成的類結(jié)構(gòu)如下：
清單 8. $Proxy2 類
1 2 3 4 5 6 7 8 9 10 11 12 13 | 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(); } |
這個(gè)類中的方法里面將會(huì)是調(diào)用 InvocationHandler 的 invoke 方法，而每個(gè)方法也將對(duì)應(yīng)一個(gè)屬性變量，這個(gè)屬性變量 m 也將傳給 invoke 方法中的 Method 參數(shù)。整個(gè)代理就是這樣實(shí)現(xiàn)的。
從前面代理的原理我們知道，代理的目的是調(diào)用目標(biāo)方法時(shí)我們可以轉(zhuǎn)而執(zhí)行 InvocationHandler 類的 invoke 方法，所以如何在 InvocationHandler 上做文章就是 Spring 實(shí)現(xiàn) Aop 的關(guān)鍵所在。
Spring 的 Aop 實(shí)現(xiàn)是遵守 Aop 聯(lián)盟的約定。同時(shí) Spring 又?jǐn)U展了它，增加了如 Pointcut、Advisor 等一些接口使得更加靈活。
上圖清楚的顯示了 Spring 引用了 Aop Alliance 定義的接口。姑且不討論 Spring 如何擴(kuò)展 Aop Alliance，先看看 Spring 如何實(shí)現(xiàn)代理類的，要實(shí)現(xiàn)代理類在 Spring 的配置文件中通常是這樣定一個(gè) Bean 的，如下：
清單 9. 配置代理類 Bean
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | <beanid="testBeanSingleton" class="org.springframework.aop.framework.ProxyFactoryBean"> <propertyname="proxyInterfaces"> <value> org.springframework.aop.framework.PrototypeTargetTests$TestBean </value> </property> <propertyname="target"><reflocal="testBeanTarget"></ref> </property> <propertyname="singleton"><value>true</value></property> <propertyname="interceptorNames"> <list> <value>testInterceptor</value> <value>testInterceptor2</value> </list> </property> </bean> |
配置上看到要設(shè)置被代理的接口，和接口的實(shí)現(xiàn)類也就是目標(biāo)類，以及攔截器也就在執(zhí)行目標(biāo)方法之前被調(diào)用，這里 Spring 中定義的各種各樣的攔截器，可以選擇使用。
下面看看 Spring 如何完成了代理以及是如何調(diào)用攔截器的。
前面提到 Spring Aop 也是實(shí)現(xiàn)其自身的擴(kuò)展點(diǎn)來(lái)完成這個(gè)特性的，從這個(gè)代理類可以看出它正是繼承了 FactoryBean 的 ProxyFactoryBean，FactoryBean 之所以特別就在它可以讓你自定義對(duì)象的創(chuàng)建方法。當(dāng)然代理對(duì)象要通過(guò) Proxy 類來(lái)動(dòng)態(tài)生成。
Spring 創(chuàng)建了代理對(duì)象后，當(dāng)你調(diào)用目標(biāo)對(duì)象上的方法時(shí)，將都會(huì)被代理到 InvocationHandler 類的 invoke 方法中執(zhí)行，這在前面已經(jīng)解釋。在這里 JdkDynamicAopProxy 類實(shí)現(xiàn)了 InvocationHandler 接口。
下面再看看 Spring 是如何調(diào)用攔截器的。
以上所說(shuō)的都是 Jdk 動(dòng)態(tài)代理，Spring 還支持一種 CGLIB 類代理，感興趣自己看吧。
Spring 中使用的設(shè)計(jì)模式也很多，比如工廠模式、單例模式、模版模式等，這里主要介紹代理模式和策略模式。
代理模式原理
代理模式就是給某一個(gè)對(duì)象創(chuàng)建一個(gè)代理對(duì)象，而由這個(gè)代理對(duì)象控制對(duì)原對(duì)象的引用，而創(chuàng)建這個(gè)代理對(duì)象就是可以在調(diào)用原對(duì)象是可以增加一些額外的操作。
Subject：抽象主題，它是代理對(duì)象的真實(shí)對(duì)象要實(shí)現(xiàn)的接口，當(dāng)然這可以是多個(gè)接口組成。
ProxySubject：代理類除了實(shí)現(xiàn)抽象主題定義的接口外，還必須持有所代理對(duì)象的引用
RealSubject：被代理的類，是目標(biāo)對(duì)象。
Spring 中如何實(shí)現(xiàn)代理模式
Spring Aop 中 Jdk 動(dòng)態(tài)代理就是利用代理模式技術(shù)實(shí)現(xiàn)的。在 Spring 中除了實(shí)現(xiàn)被代理對(duì)象的接口外，還會(huì)有 org.springframework.aop.SpringProxy 和 org.springframework.aop.framework.Advised 兩個(gè)接口。
$Proxy 就是創(chuàng)建的代理對(duì)象，而 Subject 是抽象主題，代理對(duì)象是通過(guò) InvocationHandler 來(lái)持有對(duì)目標(biāo)對(duì)象的引用的。
Spring 中一個(gè)真實(shí)的代理對(duì)象結(jié)構(gòu)如下：
清單 10 代理對(duì)象 $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 | 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(); } |
策略模式原理
策略模式顧名思義就是做某事的策略，這在編程上通常是指完成某個(gè)操作可能有多種方法，這些方法各有千秋，可能有不同的適應(yīng)的場(chǎng)合，然而這些操作方法都有可能用到。各一個(gè)操作方法都當(dāng)作一個(gè)實(shí)現(xiàn)策略，使用者可能根據(jù)需要選擇合適的策略。
Context：使用不同策略的環(huán)境，它可以根據(jù)自身的條件選擇不同的策略實(shí)現(xiàn)類來(lái)完成所要的操作。它持有一個(gè)策略實(shí)例的引用。創(chuàng)建具體策略對(duì)象的方法也可以由他完成。
Strategy：抽象策略，定義每個(gè)策略都要實(shí)現(xiàn)的策略方法
ConcreteStrategy：具體策略實(shí)現(xiàn)類，實(shí)現(xiàn)抽象策略中定義的策略方法
Spring 中策略模式的實(shí)現(xiàn)
Spring 中策略模式使用有多個(gè)地方，如 Bean 定義對(duì)象的創(chuàng)建以及代理對(duì)象的創(chuàng)建等。這里主要看一下代理對(duì)象創(chuàng)建的策略模式的實(shí)現(xiàn)。
前面已經(jīng)了解 Spring 的代理方式有兩個(gè) Jdk 動(dòng)態(tài)代理和 CGLIB 代理。這兩個(gè)代理方式的使用正是使用了策略模式。
在上面結(jié)構(gòu)圖中與標(biāo)準(zhǔn)的策略模式結(jié)構(gòu)稍微有點(diǎn)不同，這里抽象策略是 AopProxy 接口，Cglib2AopProxy 和 JdkDynamicAopProxy 分別代表兩種策略的實(shí)現(xiàn)方式，ProxyFactoryBean 就是代表 Context 角色，它根據(jù)條件選擇使用 Jdk 代理方式還是 CGLIB 方式，而另外三個(gè)類主要是來(lái)負(fù)責(zé)創(chuàng)建具體策略對(duì)象，ProxyFactoryBean 是通過(guò)依賴的方法來(lái)關(guān)聯(lián)具體策略對(duì)象的，它是通過(guò)調(diào)用策略對(duì)象的 getProxy(ClassLoader classLoader) 方法來(lái)完成操作。
看完上述內(nèi)容是否對(duì)您有幫助呢？如果還想對(duì)相關(guān)知識(shí)有進(jìn)一步的了解或閱讀更多相關(guān)文章，請(qǐng)關(guān)注億速云行業(yè)資訊頻道，感謝您對(duì)億速云的支持。
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如果涉及侵權(quán)請(qǐng)聯(lián)系站長(zhǎng)郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號(hào)
手機(jī)網(wǎng)站二維碼
