javascript
Spring面向切面编程
?????? JAVA就業套餐課：https://edu.csdn.net/combo/detail/1230
?????? 第1章主要介紹了Spring管理實體對象的應用，通過ApplicationContext容器來了解Spring管理實體對象的原理以及設值注入、構造方法及自動注入等不同的注入方式。本章先介紹為什么需要AOP以及使用AOP的好處，然后采用手動代理的方式介紹什么是代理及代理的必要性，最后結合商場手機進貨和收獲的案例分別介紹前置通知、后置通知、環繞通知和異常通知。在介紹前置通知的時候，分別采用Spring1.x和Spring2.x的方式進行配置，為后續課程的學習打下鋪墊。
核心技能部分
?
第1章?
1.1?Spring AOP簡介
1.1.1?為什么需要AOP
通過依賴注入，在編寫程序的時候，我們不必關心依賴的組件如何實現，然而在實際開發過程中我們還需要將程序中涉及的公共問題集中解決，如圖2.1.1所示。
?
圖2.1.1 Spring的兩個重要模塊
看下面的一個應用：
?
public void doSameBusiness (long lParam,String sParam){ // 記錄日志log.info("調用 doSameBusiness方法，參數是："+lParam);// 輸入合法性驗證if (lParam<=0){throws new IllegalArgumentException("xx應該大于0");}try{ //真正的業務邏輯代碼//事務控制}catch(){tx.rollback();}// 事務控制tx.commit(); }?
這是一個典型的業務處理方法。日志、參數合法性驗證、異常處理、事務控制等都是一個健壯的業務系統所必需的；否則系統出現問題或者有錯誤的業務操作時沒有日志可查；傳入的出庫參數為負數，出庫反而導致庫存增加；轉賬時，打款方的錢已經被扣了，方法卻異常退出，而收款方還沒有收到，已經進行的交易沒有回滾。這樣的系統顯然是沒有人敢用的。
為了保證系統健壯可用，就要在每個業務方法里都反復編寫這些代碼，如果需要修改，則每個業務方法都需要修改，這樣的代碼質量很難保障。
我們怎樣才能把心用在真正的業務邏輯上呢？這就是AOP要解決的問題。
1.1.1?什么是AOP
AOP 是Aspect-Oriented Programming的簡稱，意思是面向切面編程。AOP是對OOP的補充和完善。比如剛才的問題，程序中所有的業務方法都需要日志記錄、參數驗證、事務處理，這些公共的處理如果放在每個業務方法里，系統會變的臃腫，而且很難去維護。散布在系統各處的需要在實現業務系統時關注的事情就被成為“切面”，也稱為關注點，AOP的思想就是把這些公共部分從業務方法中提取出來，集中處理。
編寫代碼的時候，“切面”代碼并不放在業務方法中，但是程序運行的時候，Spring會攔截到方法的執行，并運行這些“切面”代碼。
OOP 引人了封裝、繼承及多態性等概念來建立對象層次結構，用于模擬公共行為的集合。在OOP思想中，代碼的重復可以被提取出來放在父類中被復用。但是方法中的重復代碼，OOP卻無能為力。例如，在日志信息記錄中，日志代碼常水平地散布在所有對象層次中，與對象的核心功能毫無關系。對于其他類型的代碼，如安全性、異常處理以及透明的持續性也同樣如此。散布在各處且無關的代碼稱為橫切 (Cross-cutting) 代碼，這種代碼在OOP 的設計中導致了大量重復且不利于各個模塊重用。
AOP技術則剛好相反，它代表橫向關系，通過利用“橫切”技術解剖封裝的對象并獲得其內部，將影響多個類的公共行為封裝至可重用模塊并命名為“Aspect”(切面)。簡而言之，即 AOP技術將與業務無關卻由業務模塊共同調用的邏輯進行封裝，減少系統的重復代碼，降低模塊間的耦合度，提高系統的可操作性及可維護性。若將“對象”視為空心的圓柱體，將屬性與行為都封裝于柱體中，則 AOP技術的作用類似于刀，將空心圓柱體剖開并獲得內部的消息，剖開的面即“切面”。
通過使用“橫切”技術，AOP將軟件系統分為兩個部分：核心關注點與橫切關注點。業務處理的主要流程即核心關注點，與之關系較小的部分就是橫切關注點。橫切關注點常發生在核心關注點的多處且各處基本相似，如權限認證、日志、事務處理等。AOP 的作用在于分離系統中的各種關注點，將核心關注點與橫切關注點進行分離，其核心思想是將應用程序中的商業邏輯與向其提供支持的通用服務進行分離。
AOP 中包含許多新的概念與術語，說明如下：
(1)切面 (Aspect)：切面是系統中抽象出來的的某一個功能模塊。
(2)連接點 (Joinpoint)：程序執行過程中某個特定的點，如調用某方法或者處理異常時。在SpringAOP中，連接點總是代表某個方法的執行。
(3)通知 (Advice)：通知是切面的具體實現，是放置“切面代碼”的類。
(4)切入點 (Pointcut)：多個連接點組成一個切入點，可以使用切入點表達式來表示。
(5)目標對象 (Target Object)：包含一個連接點的對象，即被攔截的對象。
(6)AOP代理 (AOP Proxy)：AOP框架產生的對象，是通知和目標對象的結合體。
(7)織入 (Weaving)：將切入點和通知結合的過程稱為織入。
1.1?AOP代理
在生活中，“代理”一詞出現的頻率較高，并且現實事物能夠形象、直觀地反映代理模式的抽象過程及本質。下面我們以購買手機和出售房屋為例，初步分析“代理”的概念。
眾所周知，手機或電腦都可以直接從廠家購買，但是這種方式卻很少使用。因為一般情況下，顧客都希望在購買時獲得額外的充值卡、鼠標等，廠家卻很少提供，但是顧客可以在代理商處獲得此類額外物件。房屋買賣中同樣存在類似情況：房屋待售時，屋主可以通過互聯網發布出售信息尋找買家，同咨詢者看房、洽談、交易、過戶以實現成交，需要占用賣家大量時間；此外還可以交給中介管理，由其處理瑣碎的交易過程。實際上，中介即賣家的代理。
接下來我們看一個需求，某手機商店需要購買手機和銷售手機，現要求購買和銷售手機時記錄日志。
根據需求我們知道，本系統有兩個業務操作：購買手機和銷售手機。兩個業務方法都用著相同的日志操作，因此日志操作為該系統的“切面”代碼，我們可以將這些代碼從業務方法中分離出來。我們可以定義一個手機業務接口、一個手機業務接口實現和一個日志操作類。手機接口和手機接口的實現如示例2.1所示。
示例2.1
?
//手機業務接口 public interface PhoneBiz { public void buyPhone(int num);//購買手機 public void salePhone(int num);//賣手機 } //手機業務接口實現 public class PhoneBizImpl implements PhoneBiz {public void buyPhone(int num) {System.out.println("手機進貨，進貨數量 為" + num + "部");}public void salePhone(int num) {System.out.println("銷售手機，銷售數量為" + num + "部");} }?
日志操作類如示例2.2所示。
示例2.2
public class LogUtil {public void log(String type,int num) {System.out.println("日志:"+currentTime()+type+"手機"+num+"部...");}public String currentTime() {SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");return sdf.format(new Date());} }接下來我們編寫一個測試類，對系統的業務方法進行測試，測試代碼如示例2.3所示。
示例2.3
PhoneBiz phoneBiz=new PhoneBizImpl();//創建目標對象 phoneBiz.buyPhone(10); phoneBiz.salePhone(3);?
上面的測試結果可以實現手機的進貨和銷售，但是日志記錄卻無法實現，原因是目標對象的方法沒有日志相關的代碼（日志代碼從業務方法中提取出去了），那么如何能在程序運行過程中加入“切面”代碼（日志）呢？這個時候，代理的作用就體現出來了，我們可以設計一個針對目標對象的代理。手機業務代理類如示例2.4所示。
?
示例2.4
public class PhoneBizImplProxy implements PhoneBiz {private PhoneBiz phoneBiz=new PhoneBizImpl();// 目標對象private LogUtil logUtil=new LogUtil();// 日志操作對象public void buyPhone(int num) {phoneBiz.buyPhone(num);// 調用目標對象的手機進貨方法logUtil.log("購買", num);//日志操作}public void salePhone(int num) {phoneBiz.salePhone(num);// 調用目標對象的手機銷售方法logUtil.log("銷售", num);//日志操作}//setter & getter }通過上面的代碼我們知道，該代理類中包含兩個重要屬性：目標對象和“切面對象”。
要想把公共代碼提取出來，又在業務方法運行的時候加上公共代碼，我們可以調用代理對象的方法。測試代碼如示例2.5所示。
示例2.5
PhoneBiz phoneBiz=new PhoneBizImplProxy();//創建代理對象 phoneBiz.buyPhone(10);//調用代理對象的進貨方法 phoneBiz.salePhone(3);//調用代理對象的銷售方法?
綜上，代理通常可以作為目標對象的替代品，且提供更加強大的功能。代理包含目標Bean的所有方法，代理就是目標對象的加強，通過以目標對象為基礎來增加屬性與方法，提供更加強大的功能。AOP代理是由 AOP框架創建的對象。
?
如果在Spring項目中使用AOP,則需要在Spring項目中添加Spring Libraries類庫。
1.1?Spring AOP的實現
本章繼續以2.2節中手機商店的進貨和銷售業務為例，以日志管理為需求，講解Spring AOP技術的具體使用方法。
1.1.1?引入AOP命名空間
首先我們需要在Spring應用容器配置文件中引入Spring AOP命名空間，否則無法在Spring容器配置文件中使用AOP相關xml標簽。如示例2.6所示，將其中加粗部分代碼，添加在你的applicationContext.xml中即可：
示例2.6?
<beans xmlns=http://www.springframework.org/schema/beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"></beans>?
1.1.1?目標對象（Target Object）
?
包含業務關注點（本例是需要日志管理的點）的對象，稱為目標對象。在本例中，我們的目標對象是手機業務對象，即s3spring.ch2.biz.impl.PhoneBizImpl類的對象，它實現s3spring.ch2.biz.PhoneBiz接口，我們需要在applicationContext.xml中將其配置成Spring bean，如示例2.7所示：
示例2.7
<bean id="phoneBiz" class="s3spring.ch2.biz.impl.PhoneBizImpl"></bean>
1.1.2?連接點（JoinPoint）
程序執行過程中的某個業務關注點（本例是需要日志管理的點）被稱作連接點（JoinPoint）。在Spring AOP中，連接點總是代表某個方法的執行。在本例中PhoneBizImpl類的buyPhone(int)方法和salePhone(int)的執行都是連接點。
1.1.3?切入點（PointCut）
多個連接點組成一個切入點。我們用切入點表達式來描述多個連接點的集合。為了選擇方法，我們可以使用下面這些條件來構造切入點表達式：
l?切入點指示符：如execution，最常用的切入點指示符，表示方法的執行。
l?布爾運算符：AND（&&）、OR（||）和NOT（!），可以將多個表達式組合成一個新的表達式來縮小選擇連接點的范圍。
l?通配符：星號（*），用于匹配任何方法、類名或者參數類型。雙點號（..），用于表示0個或者多個參數類型。
l?方法可見性修飾符：將選擇連接點的范圍縮小到某種可見性的方法。如public的。
l?方法返回類型：如void、int、String等，也可以使用*，表示所有類型。
l?類名：指定完整的類名（包括完整的包名稱，如java.lang.String），將選擇連接點的范圍縮小到某個目標類。
l?方法名稱：可以是全名。也可以是*（任何名稱）。也可以是部分名稱結合通配符，如get*，即所有名稱以get開頭的方法。
l?方法聲明拋出的異常：如 throws java.lang.IOException。
使用execution切入點指示符描述連接點范圍時，除了方法返回類型、方法名稱和方法參數是必須描述的以外， 其它所有的部分都是可選的（方法可見性修飾符、類名、方法聲明拋出的異常）。
示例2.8表達式描述了PhoneBizImpl類名字以Phone結尾，參數只有一個且類型為int，返回類型為void，可見性為public的方法的執行，當然也包括了buyPhone(int)方法和salePhone(int)方法。
示例2.8 ?
execution( public void s3spring.ch2.biz.impl.PhoneBizImpl.*Phone(int) )
如果想描述所有業務類的所有業務方法，可以象示例2.9這樣描述：
示例2.9
execution(* s3spring.ch2.biz.impl.*.* (..) )
示例2.9中第一個*表示任意返回類型。第二個*表示任意類名。第三個*表示任意方法名稱。..表示0或多個任意類型的方法參數。
示例2.9也可以用within切入點指示符進行簡化。within表示某一范圍內的連接點，如某包內，某類內。示例2.10表示s3spring.ch2.biz.impl包中所有的連接點：
示例2.10
within( s3spring.ch2.biz.impl.* )
示例2.11表示s3spring.ch2.biz.impl.PhoneBizImpl類中所有的連接點：
示例2.11
within( s3spring.ch2.biz.impl.PhoneBizImpl )
示例2.12表示s3spring.ch2.biz.impl 包及其所有子孫包中所有的連接點：
示例2.12
within( s3spring.ch2.biz.impl.PhoneBizImpl..* )
1.1.4?切面(Aspect)
切面是系統中抽象出來的的某一個系統服務功能模塊。在本例中是日志管理模塊，它可以保含多個實現日志管理操作的通知。我們用一個POJO （Plain Old Java Ojbect，簡單普通的Java對象）類來表示抽象的切面，用方法表示通知，并把切面類配置成一個Spring bean。示例2.13 是日志管理切面類，目前它還沒有包含任何通知：
示例2.13
package s3spring.ch2.log;
public class LogAspect {
}
此時，LogAspect僅僅是一個類，還不能代表一個切面，我們接著需要把它配置成一個Spring bean，請看示例:
示例2.14
<bean id="logAspectBean" class="s3spring.ch2.log.LogAspect"></bean>
然后，我們可以利用示例2.6 引入的Spring AOP命名空間將“logAspectBean” bean 配置成一個切面。請看示例2.15：
示例2.15
<aop:config>
?????<!-- 定義一個可以被多個切面共享的切入點?-->
<aop:pointcut id="p1" expression="execution( void *Phone(int))"/>
?????<!-- 定義一個切面?-->
<aop:aspect id="logAspect" ref="logAspectBean"></aop:aspect>
</aop:config>
如示例2.15所示，切面、切入點等AOP相關內容必須定義在<aop:config>元素內部，且可以配置多個切面、多個切入點。
我們首先使用<aop:pointcut>標簽定義了一個id為p1的切入點，這個切入點的表達式描述了日志管理所關注的連接點——所有返回類型為void，名稱以Phone結尾，參數只有一個且類型為int的方法。
將切入點直接定義在<aop:config>元素內部，而不是<aop:aspect>標簽內部的好處是它可以被多個切面共享。例如該切入點即被日志管理模塊關注，又被事務管理模塊關注。當然，你也可以將關注點定義在某個<aop:aspect>標簽內部，這時該切入點就成為這個切面內部獨享的私有切入點了。
最后，我們用<aop:aspect>標簽，通過ref屬性指定id為 “logAspectBean”的bean為一個切面，并為該切面設置id為“logAspect”。
1.1.5?通知（Advice）
通知（Advice）是在切面的某個特定的連接點上執行的具體操作。按照執行的時機可以分為下面幾種：
l?前置通知（Before）：在某連接點之前執行的通知，它可以阻止連接點的執行。例如檢查權限，決定是否執行連接點。
l?后置通知（AfterReturning）：在某連接點正常完成后執行的通知：例如，一個方法沒有拋出任何異常，正常返回。它可以訪問方法返回值。
l?異常通知（AfterThrowing）：在方法拋出異常退出時執行的通知。它可以訪問拋出的異常。
l?最終通知（After ）：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）。 這是傳統spring AOP中沒有的新的通知類型。它不能訪問返回值或拋出的異常。可以用來執行釋放資源，日志記錄等操作。
l?環繞通知（Around）：也叫方法攔截器。包圍一個連接點的通知。這是最強大的一種通知類型。環繞通知可以在方法調用前后完成自定義的行為。它也會選擇是否繼續執行連接點或直接返回它自己的返回值或拋出異常來結束執行。 可用于實現性能測試，事物管理等。
1.1.6?前置通知（Before）
前置通知是在目標方法被調用之前織入的通知。即當目標方法被調用且執行之前，先執行的系統服務業務邏輯，如執行日志記錄，參數檢查，權限限制等。
示例2.16將展示利用Spring的前置通知實現在手機進貨和銷售手機執行之前記錄操作日志。示例2.1中的業務接口PhoneBiz和實現類PhoneBizImpl的代碼不需要做任何修改，代理對象由Spring自動產生。我們只需要在示例2.13中創建的LogAspect切面類內部定義一個方法實現目標業務方法執行之前要進行的日志記錄操作，如示例2.16所示。
示例2.16?
package s3spring.ch2.log; public class LogAspect { //前置通知 public void before() throws Throwable {System.out.println("業務方法開始執行……"); }[先添加一個簡單的方法,然后再引入JoinPoint] /** * 前置通知 在目標方法執行之前執行日志記錄 */public void before(JoinPoint jp) throws Throwable {Object[] args = jp.getArgs();// 目標方法所有參數String methodName = jp.getSignature().getName();//獲得目標方法名稱if ("buyPhone".equals(methodName)) {System.out.println(currentTime() + "即將執行進貨操作,數量為" + args[0]);}if ("salePhone".equals(methodName)) {System.out.println(currentTime() + "即將執行銷售操作,數量為" + args[0]);}}/*** 輸出當前時間的工具方法*/public String currentTime() {SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");return sdf.format(new Date());} }如示例2.16所示，before方法擁有一個參數叫做jp， 類型為JoinPoint，即連接點。這個參數是可選的。JoinPoint對象提供了如下方法以獲得連接點（在spring中一般是方法的執行）的一些有用信息：
l?Object[] getArgs()：以對象數組的形式返回所有方法參數
l?Signature?getSignature()：返回方法簽名，通過Signature的getName()方法可以得到方法名稱；getModifiers()方法可以得到方法修飾符。
l?String getKind()：返回當前連接點的類型，如：“method-execution”,方法執行。
l?Object getTarget()：返回連接點所在的目標對象。
l?Object getThis()：返回AOP自動創建的代理對象。
此時before方法雖然實現了一個日志管理前置通知的業務邏輯，但是它還是一個普通的方法，我們需要把這個方法定義成一個前置通知，并和示例2.15中定義的切入點p1關聯起來，請看示例2.17中<aop:aspect>標簽內的粗體部分代碼：
示例2.17
<aop:config><!-- 定義一個可以被多個切面共享的切入點 --><aop:pointcut id="p1" expression="execution( void *Phone(int))"/><!-- 定義一個切面 --><aop:aspect id="logAspect" ref="logAspectBean"><!-- 定義一個前置通知 --><aop:before method="before" pointcut-ref="p1" /> </aop:aspect> </aop:config><aop:before>標簽用于定義一個前置通知。method屬性指定實現通知的方法。pointcut-ref屬性指定該通知關聯的切入點。一個切面(<aop:aspect>)內可以包含多個不同類型的通知。
到這里，我們的前置通知的示例就完成了。示例2.18是完整的配置：
示例2.18
?
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns=http://www.springframework.org/schema/beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"><!-- 目標業務對象 --> <bean id="phoneBiz" class="s3spring.ch2.biz.impl.PhoneBizImpl"></bean> <!-- 日志管理切面類 --> <bean id="logAspectBean" class="s3spring.ch2.log.LogAspect"></bean> <!-- Aop配置 --><aop:config><aop:pointcut id="p1" expression="execution( void *Phone(int) )"/> <!-- 配置日志管理切面 --><aop:aspect id="logAspect" ref="logAspectBean"><!-- 配置日志記錄前置通知 --><aop:before method="before" pointcut-ref="p1" /></aop:aspect></aop:config> </beans>?
接下來我們來測試一下使用前置通知實現的日志管理操作的效果，示例2.19是測試代碼：
示例2.19
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); //創建代理對象 PhoneBiz pBiz = (PhoneBiz)ac.getBean("phoneBiz"); //購買100部手機 pBiz.buyPhone(100); //銷售88部手機 pBiz.salePhone(88);示例2.19執行輸出結果：
2012年07月18日?18:02:45 即將執行進貨操作,數量為100
手機進貨，進貨數量?為100部
2012年07月18日?18:02:45 即將執行銷售操作,數量為88
銷售手機，銷售數量為88部
觀察輸出結果我們可以看出，在業務方法執行之前，前置通知成功織入連接點，先進行了日志輸出。實際上，我們通過Spring應用容器獲得的并不是真正的PhoneBizImpl類型的對象，而是Spring自動根據PhoneBizImpl 類實現的PhoneBiz接口創建的代理對象。示例2.20可以證明著一點：
示例2.20
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); //創建代理對象 PhoneBiz pBiz = (PhoneBiz)ac.getBean("phoneBiz"); //輸出bean類型名稱 System.out.println(pBiz.getClass().getName()); //購買100部手機 pBiz.buyPhone(100); //銷售88部手機 pBiz.salePhone(88);示例2.20粗體部分代碼調用了pBiz的getClass()方法返回該對象的類型描述對象（一個Class類型的對象），并進一步調用Class對象的getName方法獲取類名稱。輸出結果是：
$Proxy4
而不是bean對象的類型：
s3spring.ch2.biz.impl.PhoneBizImpl
這足以說明我們獲得的并不是一個 PhoneBizImpl 類的對象，而是一個代理對象，而且該代理對象實現了PhoneBiz接口。所有此時你不能使用PhoneBizImpl類型的變量引用代理對象，請看示例2.21：
示例2.21
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContext.xml");
//創建代理對象
PhoneBizImpl pBiz = (PhoneBizImpl)ac.getBean("phoneBiz");
//輸出bean類型名稱
System.out.println(pBiz.getClass().getName());
示例2.21將引用代理對象的變量類型從PhoneBiz改成PhoneBizImpl，執行時將拋出以下異常信息：
java.lang.ClassCastException: $Proxy4 cannot be cast to s3spring.ch2.biz.impl.PhoneBizImpl
示例2.21拋出的異常信息描述的很清楚：$Proxy4不能被轉換成PhoneBizImpl。那么如果我們的目標對象沒有實現接口怎么辦呢？讓我們修改PhoneBizImpl 類的定義，使其不實現任何接口，請看示例2.22：
示例2.22
public class PhoneBizImpl
此時再次運行示例2.20，程序能夠正常運行，輸出代理對象類型信息如下：
s3spring.ch2.biz.impl.PhoneBizImpl$$EnhancerByCGLIB$$ffeaaf7b
實際上，Spring AOP 創建代理分為兩種情況：
l?如果被代理的目標對象實現了至少一個接口，Spring會使用針對接口產生代理的Java SE動態代理（Java直接提供的動態代理API）。目標對象類型實現的所有接口都將被代理，包括業務接口之外的接口。 注意，Java SE 動態代理只能針對接口產生代理，所以目標對象必須至少實現了一個接口。建議優先使用Java SE 動態代理。
l?對于需要直接代理類而不是代理接口的時候，Spring也可以使用CGLIB（Code Generation Library）代理。如果一個業務對象并沒有實現任何接口，Spring就會使用CGLIB在運行時動態生成目標對象的子類對象來作為代理對象。就算目標對象實現了接口，你也可以強制使用CGLIB代理，例如：希望代理目標對象的所有方法，而不只是實現自接口的方法；或當目標對象沒有實現有用的業務接口，而只是實現了一些輔助工具接口（如果此時針對接口產生代理，則代理對象僅擁有這些輔助工具接口定義的方法，沒有業務方法）。我們只需要將<aop:config>標簽的proxy-target-class屬性置為"true"即可強制使用CGLIB針對類產生代理，請看示例：
示例2.23
<aop:config proxy-target-class="true">
?????????……
</aop:config>
1.1.1?后置通知（AfterReturning）
后置通知是在目標方法調用之后織入通知，即在方法正常退出返回值之后且返回調用地點之前進行織入。
示例2.24是一個后置通知實現，也位于示例2.13的LogAspect切面類中，作用是在業務方法調用結束之后進行日志記錄。
示例2.24
?
public void afterReturning(JoinPoint jp) throws Throwable {String methodName = jp.getSignature().getName();if ("buyPhone".equals(methodName)) {System.out.println(currentTime() + "進貨操作執行完畢...");}if ("salePhone".equals(methodName)) {System.out.println(currentTime() + "銷售操作執行完畢...");}?
在配置文件中<aop:aspect>標簽內增加如示例2.25粗體部分配置內容，將后置通知織入切入點p1。
?
示例2.25
<!-- Aop配置 --> <aop:config ><!-- 配置切入點 --><aop:pointcut id="p1" expression="execution( void *Phone(int) )" /><!-- 配置切面 --><aop:aspect id="logAspect" ref="logAspectBean"><!-- 配置前置通知 --><aop:before method="before" pointcut-ref="p1" /><!-- 配置后置通知 --><aop:after-returning method="afterReturning" pointcut-ref="p1"/></aop:aspect> </aop:config>?
不修改示例2.19測試代碼，測試結果如下所示，粗體部分為后置通知輸出的日志信息：
?
2012年07月20日?15:04:56即將執行進貨操作,數量為100
手機進貨，進貨數量?為100部
2012年07月20日?15:04:56進貨操作執行完畢...
?
2012年07月20日?15:04:56即將執行銷售操作,數量為88
銷售手機，銷售數量為88部
2012年07月20日?15:04:56銷售操作執行完畢...
1.1.1?異常通知（AfterThrowing）
如果連接點拋出異常，異常通知（throws advice）將在連接點異常退出后被調用。示例2.26是一個自定義業務異常，表示缺貨。
示例2.26
package s3spring.ch2.exception;
/** 缺貨異常*/
public class OutOfStockException extends Exception{
?
public OutOfStockException(String msg) {
super(msg);
}
}
修改示例2.1，為 PhoneBizImpl 類添加一個num屬性代表庫存。在salePhone()方法中判斷如果銷售量高于庫存量，則拋出OutOfStockException，請看示例2.27粗體部分代碼：
示例2.27
public class PhoneBizImpl {int num;// 庫存 public void buyPhone(int num) {System.out.println("手機進貨，進貨數量 為" + num + "部");this.num += num;}public void salePhone(int num) throws OutOfStockException {if(this.num<num) throw new OutOfStockException("存貨不足，客戶需要"+num+ "部手機,庫存只有"+this.num+"部");System.out.println("銷售手機，銷售數量為" + num + "部");}…… }?
在LogAspect切面類添加一個實現異常通知的方法，作用是在業務方法異常退出之后進行日志記錄。OutOfStockException類型的參數e用于接收目標方法拋出的OutOfStockException類型異常，以便在通知內處理該異常。如果目標方法拋出的是其它異常，比如空指針異常，則示例2.28中異常通知方法不會被執行：
?
示例2.28
public void afterThrowing(JoinPoint jp,OutOfStockException e) { String methodName = jp.getSignature().getName();System.out.println(currentTime()+methodName+"方法執行，發生缺貨異常"+ e.getMessage()); }在配置文件中<aop:aspect>標簽內增加如示例2.29粗體部分配置內容，將afterThrowing方法作為異常通知織入切入點p1，將throwing屬性的值指定為afterThrowing方法OutOfStockException類型參數的名稱“e”：
示例2.29
<!-- Aop配置 --> <aop:config ><!-- 配置切入點 --><aop:pointcut id="p1" expression="execution( void *Phone(int) )" /><!-- 配置切面 --><aop:aspect id="logAspect" ref="logAspectBean"><!-- 配置前置通知 --><aop:before method="before" pointcut-ref="p1" /><!-- 配置后置通知 --><aop:after-returning method="afterReturning" pointcut-ref="p1"/> <!-- 配置異常通知 --><aop:after-throwing method="afterThrowing" pointcut-ref="p1" throwing="e" /></aop:aspect> </aop:config>?
不修改示例2.19測試代碼，測試結果如下所示，粗體部分為后置通知輸出的日志信息：
?
2012年07月20日?21:19:10即將執行進貨操作,數量為100
手機進貨，進貨數量?為100部
2012年07月20日?21:19:10進貨操作執行完畢...
?
2012年07月20日?21:19:10即將執行銷售操作,數量為120
2012年07月20日?21:19:10salePhone方法執行，發生缺貨異常：貨存不足，客戶需要120部手機,庫存只有100部
觀察執行結果你會發現，當目標方法發生缺貨異常時異常通知正確執行，但是后置通知沒有執行。因為后置通知只在目標方法正常執行結束時執行。如果我們希望能夠在目標方法拋出異常之后，像try、catch、finally結構一樣，除了是用異常通知處理異常外，還可以通過某種通知去完成類似finally的任務，即無論目標方法是否拋出異常，該通知都一定會執行。這就是我們繼續要學習的最終通知。
1.1.1?最終通知（After）
最終通知是無論目標方法異常退出，還是正常退出都一定會執行的通知。在LogAspect切面類中添加如示例2.30所示方法。
示例2.30 最終通知
public void after(JoinPoint jp) throws Throwable {String methodName = jp.getSignature().getName();if ("buyPhone".equals(methodName)) {System.out.println(currentTime() + "進貨操作執行完畢,發生異常也要執行的最終通知...");}if ("salePhone".equals(methodName)) {System.out.println(currentTime() + "銷售操作執行完畢，發生異常也要執行的最終通知...");} }在配置文件中<aop:aspect>標簽內增加如示例2.31粗體部分配置內容，將after方法作為最終通知織入切入點p1。
示例2.31最終通知配置
<!-- Aop配置 --> <aop:config ><!-- 配置切入點 --><aop:pointcut id="p1" expression="execution( void *Phone(int) )" /><!-- 配置切面 --><aop:aspect id="logAspect" ref="logAspectBean"><!-- 配置前置通知 --><aop:before method="before" pointcut-ref="p1" /><!-- 配置后置通知 --><aop:after-returning method="afterReturning" pointcut-ref="p1"/> <!-- 配置異常通知 --><aop:after-throwing method="afterThrowing" pointcut-ref="p1" throwing="e" /> <!--配置最終通知 --><aop:after method="after" pointcut-ref="p1"/></aop:aspect> </aop:config>不修改示例2.19測試代碼，測試結果如下所示，粗體部分為后置通知輸出的日志信息：
2012年07月25日?15:55:32即將執行進貨操作,數量為100
手機進貨，進貨數量?為100部
2012年07月25日?15:55:32進貨操作執行完畢...
2012年07月25日?15:55:32進貨操作執行完畢,發生異常也要執行的最終通知...
2012年07月25日?15:55:32即將執行銷售操作,數量為120
銷售手機，銷售數量為120部
2012年07月25日?15:55:32銷售操作執行完畢...
2012年07月25日?15:55:32銷售操作執行完畢，發生異常也要執行的最終通知...
1.1.1?環繞通知（Around）
環繞 (Around)通知是最強大的通知類型，它能夠代替之前所有通知類型，在連接點的前后執行，獲取方法入參、返回值，捕捉并處理異常。下面我們就以性能測試為需求，針對業務層編寫環繞通知，計算業務方法執行耗費的時間長短。在LogAspect切面類中添加如示例2.32所示性能測試環繞通知方法實現。
示例2.32?
?
public Object aroundTest(ProceedingJoinPoint pjp) throws Throwable {String method = pjp.getSignature().getName();long begin = System.currentTimeMillis();System.out.println(currentTime()+":"+method+"方法開始執行，計時開始！");try {return pjp.proceed();} finally{long end = System.currentTimeMillis();System.out.println(currentTime()+":"+method+"方法執行完畢，耗時"+ (end-begin)+ "毫秒");} }環繞通知的實現方法必須包含一個連接點入參，但是其類型與其它類型的通知不同，為ProceedingJoinPoint。ProceedingJoinPoint對象代表了通知織入的當前連接點，調用其proceed()方法就會執行目標方法，proceed()方法的返回值就是目標方法的返回值，proceed()方法拋出的異常就是目標方法拋出的異常；如果你不想執行目標方法，只要不執行proceed()方法即可。
在配置文件中<aop:aspect>標簽內增加如示例2.33粗體部分配置內容，將aroundTest方法作為環繞通知織入切入點p1。
示例2.33?
?
<!-- Aop配置 --> <aop:config ><!-- 配置切入點 --><aop:pointcut id="p1" expression="execution( void *Phone(int) )" /><!-- 配置切面 --><aop:aspect id="logAspect" ref="logAspectBean"><!-- 配置前置通知 --><aop:before method="before" pointcut-ref="p1" /><!-- 配置后置通知 --><aop:after-returning method="afterReturning" pointcut-ref="p1"/> <!-- 配置異常通知 --><aop:after-throwing method="afterThrowing" pointcut-ref="p1" throwing="e" /> <!--配置最終通知 --><aop:after method="after" pointcut-ref="p1"/> <!--配置環繞通知 --> <aop:around method="aroundTest" pointcut-ref="p1"/></aop:aspect> </aop:config>?
?
?
不修改示例2.19測試代碼，測試結果如下所示，粗體部分為后置通知輸出的日志信息：
……省略部分日志
2012年07月25日?10:58:41:buyPhone方法開始執行，計時開始！
手機進貨，進貨數量?為100部
……省略部分日志
2012年07月25日?10:58:41:buyPhone方法執行完畢執行完畢，耗時31毫秒
?
……省略部分日志
2012年07月25日?10:58:41:salePhone方法開始執行，計時開始！
銷售手機，銷售數量為120部
……省略部分日志
2012年07月25日?10:58:41:salePhone方法執行完畢執行完畢，耗時0毫秒
1.1?Spring AOP 注解方式的實現
我們也可以使用注解來進行AOP編程的配置。兩種方式原理和概念不變，僅僅是配置形式不同罷了。下面我們就在2.3小節示例項目的基礎之上將xml配置方式改為注解配置方式。
1.1.1?用注解方式重構日志管理切面
首先創建一個新包s3spring.ch2.log.annotation，然后將默認包下的applicationContext.xml和s3spring.ch2.log.LogAspect類復制到該包下。
修改s3spring.ch2.log.annotation.applicationContext.xml中代碼為示例2.34所示：
示例2.34
<beans xmlns=http://www.springframework.org/schema/beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> <!-- 啟用注解配置 --> <aop:aspectj-autoproxy /> <!-- 目標業務對象 --> <bean id="phoneBiz" class="s3spring.ch2.biz.impl.PhoneBizImpl"></bean> <!-- 日志管理切面 --> <bean class="s3spring.ch2.log.annotation.LogAspect"></bean> </beans>注解配置方式和XML配置方式相同的是也需要在Spring應用容器的配置文件applicationContext.xml中引入AOP命名空間，不同的是我們采用注解來代替<aop:config >、<aop:pointcut>、<aop:aspect>、<aop:before>等等這些標簽。
另外，我們需要用<aop:aspectj-autoproxy />標簽來告訴spring應用容器啟用AOP注解配置，Spring應用容器就會在初始化時掃描所有的bean，以找出應用AOP注解配置的切面bean。
id為“phoneBiz”的bean是目標業務對象，其實現類是示例2.1中的s3spring.ch2.biz.impl.PhoneBizImpl，代碼和配置無需任何修改。
s3spring.ch2.log.annotation.LogAspect類作為日志管理切面的實現類被配置成bean，在類聲明上方添加@Aspect注解即可將它聲明為切面。請看示例：
示例2.35?
?
package s3spring.ch2.log.annotation;
?
@Aspect
public class LogAspect {……}
spring為我們提供了如下幾個注解來幫助我們配置不同類型的通知：
l?@Before，前置通知
l?@AfterReturning，后置通知
l?@AfterThrowing，異常通知
l?@After，最終通知
l?@Around，環繞通知
在方法聲明上方使用以上注解即可將方法聲明為相應類型的通知，再為注解指定切入點表達式即可將通知織入該切入點。示例2.36演示了@Before、@AfterReturning、 @After和@Around注解的使用，請看示例2.36中粗體部分代碼：
示例2.36
package s3spring.ch2.log.annotation;
@Aspect
public class LogAspect {
?
/** 前置通知?在目標方法執行之前執行日志記錄?*/
@Before("execution( void *Phone(int))")
public void before(JoinPoint jp) throws Throwable { ?…… ?}
?
/** 后置通知?在目標方法正常退出時執行日志記錄?*/
@AfterReturning("execution( void *Phone(int))")
public void afterReturning(JoinPoint jp) throws Throwable { …… }
?
/** 最終通知?無論目標方法正常退出還是異常退出都執行日志記錄?*/
@After("execution( void *Phone(int))")
????public void after(JoinPoint jp) throws Throwable { …… }
?
/** 環繞通知?*/
@Around("execution( void *Phone(int))")
????public void after(JoinPoint jp) throws Throwable { …… }
?
?????……省略異常通知
}
用@AfterThrowing注解配置異常通知除了需要指定切入點外還需要根據方法參數名稱綁定異常對象，請看示例2.37中粗體部分代碼：
示例2.37
package s3spring.ch2.log.annotation;
@Aspect
public class LogAspect {
?????……
/** 異常通知?在目標方法拋出參數指定類型異常時執行?*/
@AfterThrowing(pointcut="execution( void *Phone(int))",throwing="e")
public void afterThrowing(JoinPoint jp,OutOfStockException e) {
……
}
}
@AfterThrowing注解的pointcut配置項用于指定切入點，Throwing配置項用于指定方法中表示異常對象的參數名稱，這樣可以將目標方法拋出的異常對象綁定到同類型叫e的方法參數。
1.1.1?切入點重用
在示例2.36小節中所有通知織入的其實都是同一個切入點，但是卻多次重復編寫相同的切入點表達式。下面讓我們用@Pointcut注解結合切入點表達式在LogAspect類中定義一個切入點，并將before通知織入該切入點，請看示例2.38：
示例2.38
package s3spring.ch2.log.annotation;
@Aspect
public class LogAspect {
/** 切入點?*/
@Pointcut("execution( void *Phone(int))")
public void p1(){}
?
/** 前置通知?在目標方法執行之前執行日志記錄?*/
@Before("s3spring.ch2.log.annotation.LogAspect.p1()")
public void before(JoinPoint jp) throws Throwable { ?…… ?}
?
?????……
}
上例中用一個叫做p1的空方法來表示一個切入點，當我們希望將通知織入該切入點時，在注解中用方法簽名來代替切入點表達式即可。由于切入點的聲明和通知的聲明在同一個類中，可以省略包路徑和類名，示例可以簡寫為示例2.39粗體部分代碼:
示例2.39
package s3spring.ch2.log.annotation;
@Aspect
public class LogAspect {
/** 切入點?*/
@Pointcut("execution( void *Phone(int))")
public void p1(){}
?
/** 前置通知?在目標方法執行之前執行日志記錄?*/
@Before("p1()")
public void before(JoinPoint jp) throws Throwable { ?…… ?}
}
?
1：使用Spring AOP實現商場購物
?
訓練技能點
??Spring AOP前置通知
??AOP的配置
需求說明
某商場進行電冰箱促銷活動，規定每位顧客只能購買一臺特價電冰箱。顧客在購買電冰箱之前輸出歡迎信息，顧客如果購買多臺特價電冰箱，請給出錯誤提示，顧客成功購買電冰箱之后輸出歡送信息。請使用Spring面向切面編程實現該需求的顧客歡迎信息顯示。
實現思路
(1)?定義出售電冰箱的接口和接口實現。
(2)?定義前置通知。
(3)?編寫配置文件。
關鍵代碼
(1)?定義缺貨異常
public class NoThisFrigException extends Exception {
public NoThisFrigException(String msg) {
super(msg);
}
}
(2)?定義顧客只能購買一臺特價電冰箱的異常
public class BuyFrigException extends Exception {
public BuyFrigException(String msg)
{
super(msg);
}
}
(3)? 定義電冰箱業務接口。
public interface FrigBiz {//出售電冰箱接口
public void buyFrig(String customer,String frig) throws NoThisFrigException;
}
(4)?定義電冰箱接口的實現類。
public class FrigBizImpl implements FrigBiz {
public void buyFrig(String customer, String frig) throws NoThisFrigException {
??if ("美的".equals(frig)) {
throw new NoThisFrigException("對不起，沒有" + frig + "的貨了");
????????}
System.out.println("您好，您已經購買了一臺" + frig);
}
}
(5)?定義前置通知，實現歡迎顧客的信息
public class FrigBefore {
public void before(Joinpoint jp) throws Throwable {
// 通過Joinpoint獲得目標方法傳入的參數customer值
???String customer = (String) jp.getArgs()[0];// 取得第一個參數，客戶名稱
???// 顯示歡迎信息，在buyFrig方法前調用
????System.out.println("歡迎光臨！" + customer + "！");
}
}
(6)?編寫配置文件，使用Spring2.x方式配置
?<!-- 配置出售電冰箱的實現類?-->
<bean id="frigBiz" class="bean.FrigBizImpl" />
<!-- 配置前置通知?-->
<bean id="frigBefore" class="utils.FrigBefore" />
<!-- 配置代理對象?-->
<bean id="frigBizProxy" <!-- AOP配置?-->
<aop:config>
?????<!-- 定義一個可以被多個切面共享的切入點?-->
<aop:pointcut id="p1"
expression="execution( void buyFrig(String,String))"/>
?????<!-- 定義一個切面?-->
<aop:aspect id="logAspect" ref="frigBefore">
?????????<!-- 定義一個前置通知?-->
?????????<aop:before method="before" pointcut-ref="p1" />
</aop:aspect>
</aop:config>
?
(7)?編寫測試代碼測試。
public static void main(String[] args) throws NoThisFrigException {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
FrigBiz frigBiz=(FrigBiz)context.getBean("frigBizProxy");
frigBiz.buyFrig("張無忌", "Lg");
}
}
2：完善商場購物實現顧客歡送信息
訓練技能點
??Spring AOP后置通知
需求說明
實訓任務1的基礎上完善系統，當電冰箱賣出之后，顯示“歡迎下次再來”。
實現思路
（1）?編寫后置通知FrigAfter。
（2）?在配置文件中增加對后置通知的配置。
（3）?編寫測試代碼。
3：使用環繞通知重構商場購物
訓練技能點
??Spring AOP環繞通知
??Spring2.x的AOP配置
需求說明
每位顧客只能購買一臺特價電冰箱，已經購買電冰箱的顧客如果重復購買，則給出顧客限購的提示。
實現思路
（1）?定義環繞通知。
（2）?使用Spring2.x方式配置。
（3）?編寫測試代碼。
關鍵代碼
（1）?定義環繞通知FrigAround。
public class FrigAround {
private Set<String> customers = new HashSet<String>();
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();// 目標方法所有參數
String customer = (String)args[0];
String frig = (String) args[1];
?
if (customers.contains(customer)) {
throw new BuyFrigException("對不起，一名顧客只能購買一臺特價電冰箱！您已購買一臺特價" + frig);
}
?
try {
?? ???????return pjp.proceed();
?? ????}?finally{
customers.add(customer);
?? ????}
}
}
（2）?新建配置文件aop.xml，配置環繞通知。
<!-- 配置出售電冰箱的實現類?-->
<bean id="frigBiz" class="bean.FrigBizImpl" />
<!-- 配置環繞通知?-->
<bean id="frigAround" class="utils.FrigAround" />
<aop:config>
?????<!-- 定義一個可以被多個切面共享的切入點?-->
<aop:pointcut id="p1"
expression="execution( void buyFrig(String,String))"/>
?????<!-- 定義一個切面?-->
<aop:aspect id="frigAspect" ref="frigAround">
?????????<!-- 定義一個后置通知?-->
?????????<aop:around method="around" pointcut-ref="p1" />
</aop:aspect>
</aop:config>
4：為商場購物添加庫存驗證
訓練技能點
??Spring AOP異常通知
需求說明
升級商場購物，如果電冰箱庫存不足，給出訂貨提示。
實現思路
（1）?編寫異常通知FrigThrows。
（2）?在aop.xml中增加異常通知的配置。
（3）?編寫測試代碼。
關鍵代碼
（1）?編寫異常通知。
public class FrigThrows{
public void afterThrowing(NoThisFrigException e) throws Throwable {
System.out.println("通知倉庫，趕緊訂貨！");
}
}
（2）?在aop.xml中增加FrigThrows的配置。
<bean id="frigBiz" class="bean.FrigBizImpl" />
<bean id="frigThrows" class="utils.FrigThrows" />
<aop:config>
?????<!-- 定義一個可以被多個切面共享的切入點?-->
<aop:pointcut id="p1"
expression="execution( void buyFrig(String,String))"/>
?????<!-- 定義一個切面?-->
<aop:aspect id="frigAspect" ref="frigThrows">
?????????<!-- 定義一個異常通知?-->
?????????<aop:after-throwing method="afterThrowing" pointcut-ref="p1" />
</aop:aspect>
</aop:config>
?
5：應用注解配置方式將1~4題重新配置
訓練技能點
??Spring AOP注解配置
鞏固練習
?
一．選擇題
1. Spring通知不包括 （）。
????A. 前置通知
????B. 后置通知
????C. 環繞通知
????D. 設置通知
2. 以下對AOP 的說法中，錯誤的是 （）。
????A. AOP將散落在系統中的“方面”代碼集中實現
????B. AOP有助于提高系統的可維護性
????C. AOP可以取代OOP
????D. AOP能大大簡化程序的代碼
3. 下列關于Spring AOP的說法錯誤的是 （）。
????A. 可支持前置通知、后置通知、環繞通知
????B. Spring AOP采用攔截方法調用的方式實現，可以在調用方法前、調用后、拋出異常時攔截
????C. Spring AOP采用代理的方式實現
????D. 采用Spring2.x方式配置的時候，不會產生AOP代理
4. 在 Spring框架中，面向方面編程 (AOP)的目標在于 （）。
????A. 編寫程序時無須關注其依賴組件的實現
????B. 封裝JDBC訪問數據庫的代碼，簡化數據訪問層的重復性代碼
????C. 將程序中涉及的公共問題集中解決
????D. 可以通過Web服務調用
5.下面關于 Spring AOP 錯誤的是 （）。
A. 任何一個通知的實現發那個發都可以以JoinPoint或ProceedingJoinPoint為
參數
B. 只有環繞通知可以使用ProceedingJoinPoint為入參，其它類型通知只能使用
JoinPoint為入參
C. JoinPoint和ProceedingJoinPoint都有proceed()方法，用于執行目標發方
法
D. 僅ProceedingJoinPoint有proceed()方法
6. 以下那一個注腳不是用于定義通知的？ （）。
????A. @After
????B. @Before
????C. @Aspect
????D. @AfterThorwing
?
二．操作題
1.在第一章操作題第1題的基礎上實現以下功能。
現舉行活動，升級指環的話，可以免費將任意指環升級為“紫色夢幻”指環，新的裝備名稱為“紫色夢幻+原指環名”，而且將在原有的基礎上再加6點攻擊，6點防御。
提示：使用前置通知，判斷要升級的裝備類型是否為指環，如果是則按照要求修改傳入參數的名稱以及攻擊增效和防御增效的屬性。
2.在電子商務網站購物時，需要對生成訂單的過程進行日志記錄，以便于查詢交易過程。該系統有一個生成訂單的業務，請使用AOP方式實現在交易方法調用時記錄客戶信息及生成訂單的時間。
3.在銀行管理系統中，轉賬是很重要的操作，如張三向李四的賬戶轉賬1000元，需要經過的步驟是：
（1）修改張三賬戶信息，從賬戶中扣除1000元。
（2）修改李四賬戶信息，在李四賬戶中增加1000元錢。
（3）向交易記錄表中增加一條記錄。
以上三步操作必須運行在同一事務，而且任何一步出現異常，事務必須回滾。請使用SpringAOP實現事務控制。
提示：
在BankBiz中添加一個轉賬方法，該方法實現以上三步操作，然后編寫一個前置通知、后置通知和異常通知。在前置通知中開啟事務，在后置通知中提交事務，在異常通知中進行事務回滾。
開啟事務的方法：
HibernateSessionFactory.getSession().beginTransaction();
提交事務的方法：
HibernateSessionFactory.getSession().beginTransaction().commit();
事務回滾的方法：
HibernateSessionFactory.getSession().beginTransaction().rollback();
4.升級“會員賬戶管理系統”，使用Spring的面向切面編程為會員狀態的更改、會員充值、會員信息的刪除增加日志，日志要求：
（1）會員狀態的更改，需要記錄被更改狀態的會員的編號和更改時間。
（2）會員充值的時候，如果充值失敗，記錄失敗原因及充值操作時間。如果充值成功，記錄被充值會員的編號，充值時間和充值金額。
（3）會員信息的刪除，需要記錄被刪除的會員編號、刪除時間。
（4）日志信息在控制臺輸出。
?
?
?
總結
以上是生活随笔為你收集整理的Spring面向切面编程的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Spring入门 IOC
- 下一篇： SpringSpringMVCMybat