Spring AOP 之編譯期織入、裝載期織入、運行時織入(轉)

時間  2019-11-20
標籤 spring aop 編譯 織入 裝載 運行時 欄目 Spring 简体版
原文   原文鏈接

https://blog.csdn.net/wenbingoon/article/details/22888619html

一   前言

               AOP 實現的關鍵就在於 AOP 框架自動建立的 AOP 代理，AOP 代理則可分爲靜態代理和動態代理兩大類，其中靜態代理是指使用 AOP 框架提供的命令進行編譯，從而在編譯階段就可生成 AOP 代理類，所以也稱爲編譯時加強；而動態代理則在運行時藉助於 JDK 動態代理、CGLIB 等在內存中「臨時」生成 AOP 動態代理類，所以也被稱爲運行時加強。

       靜態代理分爲：編譯時織入（特殊編譯器實現）、類加載時織入（特殊的類加載器實現）。
       動態代理有  ：  jdk動態代理（基於接口來實現）、CGlib（基於類實現）。
 
          
     0---aspectj的類加載期織入的實現方式
    

一 概念理解         

    1     AOP的術語重在理解。

  • Join Point:(鏈接點) Spring AOP中，join point就是一個方法。（通俗來說就是起做用的那個方法，具體執行的方法）java

  • Pointcut:(切入點)  用來指定join point（通俗來說就是描述的一組符合某個條件的join point）。一般使用pointcut表達式來限定joint point，Spring默認使用AspectJ pointcut expression language。web

  • Advice: 在join point上特定的時刻執行的操做，Advice有幾種不一樣類型，下文將會討論（通俗地來說就是起做用的內容和時間點）。正則表達式

  • Introduction：給對象增長方法或者屬性。spring

  • Target object: Advice起做用的那個對象。express

  • AOP proxy: 爲實現AOP所生成的代理。在Spring中有兩種方式生成代理:JDK代理和CGLIB代理。編程

  • Aspect: 組合了Pointcut與Advice，在Spring中有時候也稱爲Advisor。某些資料說Advisor是一種特殊的Aspect，其區別是Advisor只能包含一對pointcut和advice，可是aspect能夠包含多對。AOP中的aspect能夠類比於OOP中的class。安全

  • Weaving：將Advice織入join point的這個過程。session

2  Advice的類型

  • Before advice:  執行在join point以前的advice,可是它不能阻止joint point的執行流程，除非拋出了一個異常（exception）。app

  • After returning advice: 執行在join point這個方法返回以後的advice。

  • After throwing advice: 執行在join point拋出異常以後的advice。

  • After(finally) advice: 執行在join point返回以後或者拋出異常以後的advice，一般用來釋放所使用的資源。

  • Around advice: 執行在join point這個方法執行以前與以後的advice。

3 兩種代理

Spring AOP是基於代理機制的。上文說到，Spring AOP經過JDK Proxy和CGLIB Proxy兩種方法實現代理。

若是target object沒有實現任何接口，那麼Spring將使用CGLIB來實現代理。CGLIB是一個開源項目,它是一個強大的,高性能,高質量的Code生成類庫,它能夠在運行期擴展Java類與實現Java接口。

若是target object實現了一個以上的接口，那麼Spring將使用JDK Proxy來實現代理，由於Spring默認使用的就是JDK Proxy，而且JDK Proxy是基於接口的。這也是Spring提倡的面向接口編程。固然，你也能夠強制使用CGLIB來進行代理，可是這樣可能會形成性能上的降低。

   4  Spring對AOP的支持 

一、若是目標對象實現了接口，默認會採用JDK的動態代理機制實現AOP 
二、若是目標對象實現了接口，能夠強制使用CGLIB實現AOP 
三、若是目標對象沒有實現接口，必須使用CGLIB生成代理，spring會自動在CGLIB和JDK動態代理之間切換 

4.如何強制使用CGLIB生成代理？ 

* 添加CGLIB庫，SPRING_HOME/lib/cglib/*.jar 

* 在spring的配置文件中加入： 

<aop:aspectj-autoproxy proxy-target-class="true"/> 
       <aop:config proxy-target-class="true">
       </aop:config>

   5  當使用@AspectJ自動代理時要強制使用CGLIB，

    請將<aop:aspectj-autoproxy>的proxy-target-class屬性設置爲true:（組合使用）

<aop:aspectj-autoproxy proxy-target-class="true"/>

    6   JDK代理和CGLIB代理的區別？ 

* JDK代理只能對實現了接口的類生成代理，而不能針對類 
* CGLIB是針對類實現代理的，主要對指定的類生成一個子類，並覆蓋其中的方法， 
 由於是繼承，因此不能使用final來修飾類或方法<aop:aspectj-autoproxy proxy-target-class="true"/> 
在什麼狀況下，Spring使用CGLIB作代理？ 
1.在AOP(二)基礎上若是將UserManagerImpl.java修改成以下，則Spring會自動使用CGLIB作動態代理； 

Java代碼   收藏代碼
  1. package com.wlh.spring;  
  2.   
  3.  //public class UserManagerImpl implements UserManager {  
  4.  public class UserManagerImpl{  
  5.      //目標類不實現接口的狀況下，Spring自動使用CGLIB作代理  
  6.     public void addUser(String username, String pwd) {  
  7.       System.out.println("====addUser()=====");  
  8.     }  
  9.   
  10.     public void delUser(int id) {  
  11.          System.out.println("====delUser()=====");  
  12.     }  
  13.   
  14.     public void findUser(int id) {  
  15.          System.out.println("====findUser()=====");  
  16.     }  
  17.   
  18.     public void updateUser(int id, String username, String pwd) {  
  19.          System.out.println("====updateUser()=====");  
  20.     }  
  21.   
  22. }  


二、若是UserManagerImpl.java類步變，仍然實現了接口UserManager，而後咱們在配置文件中，添加一個標籤：<aop:aspectj-autoproxy proxy-target-class="true"/> 
Spring也會使用CGLIB作代理類： 
<!--<aop:aspectj-autoproxy proxy-target-class="true"/> 支持CGLIB代理 --> 

<bean id="userManager" class="com.wlh.spring.UserManagerImpl" /> 

<bean id="securityHandler" class="com.wlh.spring.SecurityHandler" /><!-- 切面類 --> 
<aop:config> 
<aop:aspect id="securityAspect" ref="securityHandler"><!-- 引用切面類 --> 
<!-- 表達式方法聲明匹配被切入的類及其方法 --> 
<aop:pointcut id="applyMethod" 
expression="execution(* com.wlh.spring.*.add*(..)) || execution(* com.wlh.spring.*.del*(..))" /> 
<aop:before pointcut-ref="applyMethod" 
method="checkSecurity" /><!-- 聲明切面類的要切入方法 --> 
</aop:aspect> 
</aop:config> 

二   經過靜態方法實例化一個bean,實例化出來的bean的類型 對應於靜態方法的返回類型，這地點不一樣於普通的bean

   (1) 靜態方法 無參數：

   <bean id="thefmbean" class="springtest.FactoryMethodBean" factory-method="getInstance" />

   (2) 靜態方法有一個參數

   <bean id="thenamedfmbean" class="springtest.FactoryMethodBean" 
         factory-method="getNamedInstance">
        <constructor-arg value="China" />
  </bean>
      這裏<constructor-arg value="China" />表示爲靜態方法參數的值

  (3) 對於(2)實例化出來的bean，再進行屬性set

   <bean id="thenamedfmbean" class="springtest.FactoryMethodBean" 
         factory-method="getNamedInstance">
        <constructor-arg value="China" />
        <property name="id" value="20" />
  </bean>

 （4）. 對一個已經實例化的bean，獲得其普通方法返回的對象,參數方式與1徹底相同

  <bean id="duke" class="springtest.Juggler">
    <constructor-arg value="15" />
  </bean>
    <constructor-arg value="Mike" />
    <property name="id" value="18" />
  </bean>

三  基於XML的spring AOP配置

   AOP（Aspect-Oriented Programming，面向切面編程），能夠說是OOP（Object-Oriented Programing，面向對象編程）的補充和完善。OOP引入封裝、繼承和多態性等概念來創建一種對象層次結構，用以模擬公共行爲的一個集合。當咱們須要爲分散的對象引入公共行爲的時候，OOP則顯得無能爲力。也就是說，OOP容許你定義從上到下的關係，但並不適合定義從左到右的關係。例如日誌功能。日誌代碼每每水平地散佈在全部對象層次中，而與它所散佈到的對象的核心功能毫無關係。對於其餘類型的代碼，如安全性、異常處理和透明的持續性也是如此。這種散佈在各處的無關的代碼被稱爲橫切（cross-cutting）代碼，在OOP設計中，它致使了大量代碼的重複，而不利於各個模塊的重用。

  <bean id="employee" factory-bean="duke" factory-method="getYourEmployee">

     而AOP技術則偏偏相反，它利用一種稱爲「橫切」的技術，剖解開封裝的對象內部，並將那些影響了多個類的公共行爲封裝到一個可重用模塊，並將其名爲「Aspect」，即切面。所謂「切面」，簡單地說，就是將那些與業務無關，卻爲業務模塊所共同調用的邏輯或責任封裝起來，便於減小系統的重複代碼，下降模塊間的耦合度，並有利於將來的可操做性和可維護性。AOP表明的是一個橫向的關係，若是說「對象」是一個空心的圓柱體，其中封裝的是對象的屬性和行爲；那麼面向切面編程的方法，就彷彿一把利刃，將這些空心圓柱體剖開，以得到其內部的消息。而剖開的切面，也就是所謂的「切面」了。而後它又以巧奪天功的妙手將這些剖開的切面復原，不留痕跡。

      使用「橫切」技術，AOP把軟件系統分爲兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關係不大的部分是橫切關注點。橫切關注點的一個特色是，他們常常發生在覈心關注點的多處，而各處都基本類似。好比權限認證、日誌、事務處理。Aop 的做用在於分離系統中的各類關注點，將核心關注點和橫切關注點分離開來。正如Avanade公司的高級方案構架師Adam Magee所說，AOP的核心思想就是「將應用程序中的商業邏輯同對其提供支持的通用服務進行分離。」

 

      實現AOP的技術，主要分爲兩大類：一是採用動態代理技術，利用截取消息的方式，對該消息進行裝飾，以取代原有對象行爲的執行；二是採用靜態織入的方式，引入特定的語法建立「切面」，從而使得編譯器能夠在編譯期間織入有關「切面」的代碼。然而異曲同工，實現AOP的技術特性倒是相同的，分別爲：

      一、join point（鏈接點）：是程序執行中的一個精確執行點，例如類中的一個方法。它是一個抽象的概念，在實現AOP時，並不須要去定義一個join point。
      二、point cut（切入點）：本質上是一個捕獲鏈接點的結構。在AOP中，能夠定義一個point cut，來捕獲相關方法的調用。
      三、advice（通知）：是point cut的執行代碼，是執行「切面」的具體邏輯。
      四、aspect（切面）：point cut和advice結合起來就是aspect，它相似於OOP中定義的一個類，但它表明的更可能是對象間橫向的關係。
      五、introduce（引入）：爲對象引入附加的方法或屬性，從而達到修改對象結構的目的。有的AOP工具又將其稱爲mixin。

      六、AOP代理（AOP Proxy）：AOP框架建立的對象，這個對象一般能夠做爲目標對象的替代品，而AOP代理提供比目標對象更增強大的功能。真實的情形是，當應用調用AOP代理的方法時，AOP代理會在本身的方法中回調目標對象的方法，從而完成應用的調用。關於AOP代理的典型例子就是Spring中的事務代理Bean。一般，目標Bean的方法不是事務性的，而AOP代理包含目標Bean的所有方法，並且這 些方法通過增強變成了事務性方法。簡單地說，目標對象是藍本，AOP代理是目標對象的增強，在目標對象的基礎上，增長屬性和方法，提供更強大的功能。
目標對象包含一系列切入點。切入點能夠觸發處理鏈接點集合。用戶能夠本身定義切入點，如使用正則表達式。AOP代理包裝目標對象，在切入點處加入處理。在切入點加入的處理，使得目標對象的方法功能更強。Spring 默認使用JDK動態代理實現AOP代理，主要用於代理接口。也可使用CGLIB代理。實現類的代理，而不是接口。若是業務對象沒有實現接口，默認使用 CGLIB代理。但面向接口編程是良好的習慣，儘可能不要面向具體類編程。所以，業務對象一般應實現一個或多個接口。

      七、目標對象（Target Object）：包含一個鏈接點的對象，也被稱爲代理對象。

      八、 前置通知（Before advice）：在某鏈接點（JoinPoint）以前執行的通知，但這個通知不能阻止鏈接點前的執行。ApplicationContext中在<aop:aspect>裏面使用<aop:before>元素進行聲明。 

      九、後通知（After advice） ：當某鏈接點退出的時候執行的通知（不管是正常返回仍是異常退出）。ApplicationContext中在<aop:aspect>裏面使用<aop:after>元素進行聲明。

      十、返回後通知（After return advice） ：在某鏈接點正常完成後執行的通知，不包括拋出異常的狀況。ApplicationContext中在<aop:aspect>裏面使用<after-returning>元素進行聲明。 

      十一、環繞通知（Around advice） ：包圍一個鏈接點的通知，相似Web中Servlet規範中的Filter的doFilter方法。能夠在方法的調用先後完成自定義的行爲，也能夠選擇不執行。ApplicationContext中在<aop:aspect>裏面使用<aop:around>元素進行聲明。

      十二、拋出異常後通知（After throwing advice） ： 在方法拋出異常退出時執行的通知。 ApplicationContext中在<aop:aspect>裏面使用<aop:after-throwing>元素進行聲明。

     Spring2.0目前只支持使用方法調用做爲鏈接點（join point）。

     Spring 定義切入點語法：excution（modifiers-pattern？ret-type-pattern declaring-type-pattern ？name-pattern（param-pattern）throws-pattern？）

      除了ret-type-pattern （即返回類型模式）、name-pattern（param-pattern）（名字模式和參數模式）外，其餘模式都是可選的。返回類型模式決定了方法的返回類型必須依次匹配一個鏈接點（即一個方法）。使用最頻繁的一個返回類型模式是*，它表明了匹配任意的返回類型。若是寫明瞭返回類型，好比String，那麼只能匹配返回String類型的鏈接點（方法）。名字模式匹配的是方法名。你能夠用*通配符表示匹配全部方法名。參數模式中，（）表示匹配了不接受任何參數的方法，而（。。）表示匹配任意數量參數的方法。模式（*）表示匹配任意類型參數的方法。模式（*，String）表示匹配：第一個爲任意參數類型，第二個必須爲String類型的方法。

       modifiers-pattern：方法的操做權限

       ret-type-pattern：返回值

       declaring-type-pattern：方法所在的包

       name-pattern：方法名

        parm-pattern：參數名

       throws-pattern：異常

      下面是定義切入點的例子：

       。任意公共方法的執行：

          excution（public * *（。。））

       。任何一個以set開頭的方法執行：

          excution（* set*（。。））

       。AccountService接口的任意方法的執行：

          excution（* com.xyz.service.AccountService.*(。。))

       。定義在service包的任意方法的執行：

          excution(* com.xyz.service.*.*(。。))

       。定義在service包或子包的任意方法的執行：

           excution（* com.xyz.service..*.*(。。))

-----------------------------------------------------華麗的分隔線----------------------------------------------

 

        在Spring配置文件裏，全部的切面和通知器都要配置在<aop:config>標籤裏，一個applicationContext能夠包含多個<aop:config>，一個<aop:config>能夠包含pointcut、advisor、aspect元素（注意必須是這個順序）。

        一、聲明一個切面

         <aop:config>

              <aop:aspect id="myAspect" ref="myBean">

                   。。。。。

              </aop:aspect>

         </aop:config>

         <bean id="myBean" class="">

              。。。。。

          </Bean>

         說明：切面用<aop:aspect>來聲明，backing bean（支持bean）用ref引用。

         二、聲明一個切入點

         <aop:config>

               <aop:pointcut id="myPointcut" expression="excution(* com.service.*.*(..))"/>

         </aop:config>

         三、聲明一個通知

           Spring2.0經過<aop:advisors>元素來支持advisors概念，大多數狀況下，它將和transaction advice一塊兒使用，格式以下：

           <aop:config>

                <aop:pointcut id="myService" expression="excution(* com.xyz.service.*.*(..))"/>

                <aop:advisors pointcut-ref="myService" advice-ref="tx-advice"/>

           </aop:config>

          <txt:advice id="tx-advice">

                <tx:attributes>

                      <tx:method name="inser*" propagation="REQUIRED" rollback-for="Exception"/>
                      <tx:method name="updat*" propagation="REQUIRED" rollback-for="Exception" />
                      <tx:method name="delet*" propagation="REQUIRED" rollback-for="Exception" />
                      <tx:method name="process*" propagation="REQUIRED" rollback-for="Exception" />
                      <tx:method name="*" propagation="SUPPORTS" read-only="true"/>

                </tx:attributes>

           </txt:advice>  

           說明：advisors 執行切入點方法時都要執行advice-ref引用的事務處理

四  <aop:aspectj-autoproxy />  與<aop:config proxy-target-class="true">的做用

 

4.1  <aop:aspectj-autoproxy />

      經過配置織入@Aspectj切面

雖然能夠經過編程的方式織入切面，可是通常狀況下，咱們仍是使用spring的配置自動完成建立代理織入切面的工做。

 

經過aop命名空間的<aop:aspectj-autoproxy />聲明自動爲spring容器中那些配置@aspectJ切面的bean建立代理，織入切面。固然，spring

在內部依舊採用AnnotationAwareAspectJAutoProxyCreator進行自動代理的建立工做，但具體實現的細節已經被<aop:aspectj-autoproxy />隱藏起來了

 

<aop:aspectj-autoproxy />有一個proxy-target-class屬性，默認爲false，表示使用jdk動態代理織入加強；


當配爲<aop:aspectj-autoproxy  poxy-target-class="true"/>時，表示使用CGLib動態代理技術織入加強；


不過即便proxy-target-class設置爲false，若是目標類沒有聲明接口，則spring將自動使用CGLib動態代理。

 

 

 4.2 <aop:config proxy-target-class="true">

Spring AOP使用JDK動態代理或者CGLIB來爲目標對象建立代理。（建議優先使用JDK的動態代理）

    1  若是被代理的目標對象實現了至少一個接口，則會使用JDK動態代理。全部該目標類型實現的接口都將被代理。 

    2  若該目標對象沒有實現任何接口，則建立一個CGLIB代理。

    3  若是你但願強制使用CGLIB代理，（例如：但願代理目標對象的全部方法，而不僅是實現自接口的方法） 那也能夠。可是須要考慮如下問題: 

  • 沒法通知（advise）final方法，由於他們不能被覆寫。

  • 代理對象的構造器會被調用兩次。由於在CGLIB代理模式下每個代理對象都會 產生一個子類。每個代理實例會生成兩個對象：實際代理對象和它的一個實現了通知的子類實例 而是用JDK代理時不會出現這樣的行爲。一般狀況下，調用代理類型的構造器兩次並非問題， 由於除了會發生指派外沒有任何真正的邏輯被實現。
  • 且CGLib的效率沒有使用JDK代理機制高，速度平均要慢8倍左右。
強制使用CGLIB代理須要將<aop:config>的proxy-target-class屬性設爲true:
1 <aop:config proxy-target-class="true">
2    ...
3 </aop:config>

當使用@AspectJ自動代理時要強制使用CGLIB，請將<aop:aspectj-autoproxy>的proxy-target-class屬性設置爲true:（組合使用）

<aop:aspectj-autoproxy proxy-target-class="true"/>

 

五 Spring經常使用註解，自動掃描裝配Bean

 

spring自動掃描機制

spring2.5爲咱們引入了組件自動掃描機制，它能夠在classPath路徑底下尋找標註了@Component、@Service、@Controller、@Repository註解的類，並把這些類歸入進spring容器中管理。它的做用和在xml文件中使用bean節點配置組件是同樣的。

也就是要spring自動掃描機制只會查找指定類路徑下包含@Component、@Service、@Controller、@Repository這四種註解的類。

要使用自動掃描機制，咱們須要打開如下配置信息:

一、引入context命名空間 須要在xml配置文件中配置如下信息： 同上先引入context 命名空間，同時

二、在配置文件中添加context:component-scan標籤

<context:component-scan base-package="*"/> 

其中base-package爲須要掃描的包(含子包)。

注:

一、在使用組件掃描元素時，AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor會隱式地被包括進來。 也就是說，連個組件都會被自動檢測並織入 - 全部這一切都不須要在XML中提供任何bean配置元數據。也就是說若是使用了context:component-scan標籤，就能夠不須要再引入context:annotation-config標籤

<context:component-scan />還容許定義過濾器將基包下的某些類歸入或排除。Spring支持如下4種類型的過濾方式：
過濾器類型 表達式範例 說明 
註解 org.example.SomeAnnotation 將全部使用SomeAnnotation註解的類過濾出來 
類名指定 org.example.SomeClass 過濾指定的類 
正則表達式 com\.kedacom\.spring\.annotation\.web\..* 經過正則表達式過濾一些類 
AspectJ表達式 org.example..*Service+ 經過AspectJ表達式過濾一些類 

以正則表達式爲例，我列舉一個應用實例：

Java代碼 
<context:component-scan base-package="com.casheen.spring.annotation"> 
    <context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />
</context:component-scan> 

        <context:component-scan base-package="com.casheen.spring.annotation">
                <context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />
        </context:component-scan>

值得注意的是<context:component-scan />配置項不但啓用了對類包進行掃描以實施註釋驅動Bean定義的功能，同時還啓用了註釋驅動自動注入的功能（即還隱式地在內部註冊了AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），所以當使用<context:component-scan />後，就能夠將<context:annotation-config />移除了。


六   經常使用註解

 

--定義Bean的註解

 

@Controller

@Controller("Bean的名稱")

定義控制層Bean,如Action

 

@Service          

@Service("Bean的名稱")

定義業務層Bean

 

@Repository   

@Repository("Bean的名稱")

定義DAO層Bean

 

@Component  

定義Bean, 很差歸類時使用.

 

--自動裝配Bean （選用一種註解就能夠）

@Autowired  (Srping提供的)

默認按類型匹配,自動裝配(Srping提供的)，能夠寫在成員屬性上,或寫在setter方法上

 

@Autowired(required=true)  

必定要找到匹配的Bean，不然拋異常。 默認值就是true 

 

@Autowired

@Qualifier("bean的名字") 

按名稱裝配Bean,與@Autowired組合使用，解決按類型匹配找到多個Bean問題。

 

@Resource   JSR-250提供的

默認按名稱裝配,當找不到名稱匹配的bean再按類型裝配.

能夠寫在成員屬性上,或寫在setter方法上

能夠經過@Resource(name="beanName") 指定被注入的bean的名稱, 要是未指定name屬性, 默認使用成員屬性的變量名,通常不用寫name屬性.

@Resource(name="beanName")指定了name屬性,按名稱注入但沒找到bean, 就不會再按類型裝配了.

 

@Inject   是JSR-330提供的

按類型裝配，功能比@Autowired少，沒有使用的必要。

 

--定義Bean的做用域和生命過程

@Scope("prototype")

值有:singleton,prototype,session,request,session,globalSession

 

@PostConstruct 

至關於init-method,使用在方法上，當Bean初始化時執行。

 

@PreDestroy 

至關於destory-method，使用在方法上，當Bean銷燬時執行。

 

--聲明式事務

@Transactional

六   配置工廠Bean 

         一般由應用程序直接使用new建立新對象，爲了將對象的建立與使用相分離，採用工廠模式，即應用程序將對象的建立與初始化交給工廠來完成。
       通常狀況下，應用程序有本身的工廠對象來建立bean，若是將工廠對象交給Springle管理，那麼Spring管理的就不是普通的bean，而是工廠Bean。調用getBean（）方法，Spring返回的不是直接建立的Bean的實例，而是由工廠建立的Bean實例。


通常在Spring中配置工廠Bean,有3中不一樣類型的工廠Bean的配置. 

1.靜態工廠 創建具體Bean實例的是靜態方法 


[java] view plain copy
  1. import java.util.Random;   
  2. public class Static FactoryBean{   
  3. public static  
  4. Integer createRandom() {   
  5. return new  
  6. Integer(new Random().nextInt());  
  7. }  
  8. }   
    將其納入Spring容器來管理,須要通過factory-method指定靜態方法名稱，方法必須是static的，才能找到。
[java] view plain copy
  1.   
[java] view plain copy
  1. <bean id="random"  
  2. class="example.chapter3.StaticFactoryBean"  
  3. factory-method="createRandom"//createRandom方法必須是static的,才能找到  
  4. scope="prototype"  
  5. />   


測試: 
[java] view plain copy
  1. public static void main(String[] args) {  
  2. XmlBeanFactory factory = new XmlBeanFactory(new  
  3. ClassPathResource("config.xml"));  
  4. System.out.println(factory.getBean("random").toString());   
  5. //StaticFactoryBean sfb =  
  6. (StaticFactoryBean)factory.getBean("random");  
  7. //System.out.println(sfb.createRandom().toString());   
  8.   
  9. //調用getBean()時,返回隨機數.若是沒有指定factory-method,會返回StaticFactoryBean的實例,即返回工廠Bean的實例  
  10. }   

2.實例工廠  創建具體Bean實例的是實例,不是靜態方法 

[java] view plain copy
  1. import java.text.SimpleDateFormat;  
  2. import java.util.Date;   
  3. public class InstanceFactoryBean {   
  4. private String format = "yy-MM-dd HH:mm:ss";   
  5. public void setFormat(String format) {  
  6. this.format = format;  
  7. } public String createTime() {  
  8. return new SimpleDateFormat(format).format(new Date());  
  9. }  
  10. }  


 配置文件須要配置兩個bean:第一個Bean和普通的Bean沒有區別,第二個bean定義如何通過工廠Bean獲取Bean, 須要指定工廠Bean的名稱和方法名稱 
 
[java] view plain copy
  1. <bean id="instanceFactoryBean" class="example.chapter3.InstanceFactoryBean">  
  2.      <property name="format" value="yyyy-MM-dd HH:mm:ss"/>  
  3. </bean>   
  4. <bean id="currentTime" factory-bean="instanceFactoryBean" factory-method="createTime"/>   
 
測試: 
[java] view plain copy
  1. public static void main(String[] args) {  
  2. XmlBeanFactory factory = new XmlBeanFactory(new  
  3. ClassPathResource("config.xml"));  
  4. System.out.println(factory.getBean("currentTime"));  
  5. }   

3.實現FactoryBean接口 

[java] view plain copy
  1. public class PiFactoryBean implements FactoryBean {   
  2. public Object getObject() throws Exception {  
  3. return new Double(3.14159265358979);  
  4. } public Class getObjectType() {  
  5. return Double.class;  
  6. } public boolean isSingleton() {  
  7. return true;  
  8. } }   
實現了FactoryBean接口的Bean,再也不被視爲普通的Bean.Spring會自動檢測. 

[java] view plain copy
  1. <bean id="pi"class="example.chapter3.PiFactoryBean"/>  
 
 測試 
[java] view plain copy
  1. public static void main(String[] args) throws Exception {  
  2. XmlBeanFactory factory = new XmlBeanFactory(new  
  3. ClassPathResource("config.xml"));  
  4. System.out.println(factory.getBean("pi"));//返回PiFactoryBean  
  5. 的工廠方法getObject返回的Double對象實例  
  6. //PiFactoryBean p =  
  7. (PiFactoryBean)factory.getBean("&pi");  
  8. //加"&"返回工廠Bean的實例.  
  9. //System.out.println(p.getObject());  
  10. }  

參考：
     
      http://log-cd.iteye.com/blog/562056   使用AspectJ LTW(Load Time Weaving)--aop整體理解       http://blog.csdn.net/hannover100/article/details/7882893       http://tc.chinawin.net/it/softwaredev/article-24a4f.html       http://www.cnblogs.com/yangy608/archive/2010/11/14/1876839.html

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程