先來看看這個spring的配置檔案的配置：

  <!-- 事務管理器 -->
 <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <!-- 配置事務的傳播特性 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
   <tx:method name="get*" propagation="REQUIRED" read-only="true" />
   <tx:method name="del*" propagation="REQUIRED" />
   <tx:method name="save*" propagation="REQUIRED" />
   <tx:method name="update*" propagation="REQUIRED" />
  </tx:attributes>
 </tx:advice>

 <!-- 配置事務攔截器攔截哪些類的哪些方法,一般設定成攔截Service -->
 <aop:config>
  <aop:pointcut expression="execution(* com.xy.service.*.*(..))"
   id="allDaoMethod" />
  <aop:advisor advice-ref="txAdvice" pointcut-ref="allDaoMethod" />
 </aop:config>

表示com.xy.service包下的所有方法為為事務管理。

execution(* com.aptech.jb.epet.dao.hibimpl.*.*(..)) 

這樣寫應該就可以了 這是com.aptech.jb.epet.dao.hibimpl 包下所有的類的所有方法。。

第一個*代表所有的返回值型別 

第二個*代表所有的類

第三個*代表類所有方法 最後一個..代表所有的引數。

下面給出一些常見切入點表示式的例子：

• 任意公共方法的執行：

  execution(public * *(..))
  

• 任何一個以“set”開始的方法的執行：

  execution(* set*(..))
  

• AccountService 介面的任意方法的執行：

  execution(* com.xyz.service.AccountService.*(..))
  

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

  execution(* com.xyz.service.*.*(..))
  

• 定義在service包或者子包裡的任意類的任意方法的執行：

  execution(* com.xyz.service..*.*(..))
  

AOP的理解 

         1、AOP的概述 
                   AOP是一種不同於OOP（面向物件程式設計）的程式設計模式，它不是OOP的替代，而是對OOP的一種有益補充。 
         2、spring AOP的原理 
         3、spring AOP的實現 
                   在spring2.5中，常用的AOP實現方式有兩種。第一種是基於xml配置檔案方式的實現，第二種是基於註解方式的實現。 
                   接下來，以具體的是理智講解這兩種方式的使用。 

Java程式碼   
package com.zxf.service;   
    
 /**  
 * 業務邏輯介面  
* @author z_xiaofei168  
 */   
 public interface AccountService {   
     public void save(String loginname, String password);   
 }   
    
它的實現類   
    
package com.zxf.service;   
 import com.zxf.dao.AccountDao;   
    
 /**  
 * AccountService的實現類  
* @author z_xiaofei168  
 */   
 public class AccountServiceImpl implements AccountService {   
     private  AccountDao accountDao;   
        
     public AccountServiceImpl() {}   
        
     /** 帶引數的構造方法 */   
     public AccountServiceImpl(AccountDao accountDao){   
         this.accountDao = accountDao;   
     }   
        
     public void save(String loginname, String password) {   
         accountDao.save(loginname, password);   
         throw new RuntimeException("故意丟擲一個異常。。。。");   
     }   
        
     /** set方法 */   
     public void setAccountDao(AccountDao accountDao) {   
         this.accountDao = accountDao;   
     }   
 }   
     
      對於業務系統來說，AccountServiceImpl類就是目標實現類，它的業務方法，如save()方法的前後或程式碼會出現異常的地方都是AOP的連線點。 

 下面是日誌服務類的程式碼： 


Java程式碼   
package com.zxf.aspect;   
    
 import org.aspectj.lang.JoinPoint;   
 import org.aspectj.lang.ProceedingJoinPoint;   
    
 /**  
 * 日誌切面類  
* @author z_xiaofei168  
 */   
 public class LogAspect {   
    
     //任何通知方法都可以將第一個引數定義為 org.aspectj.lang.JoinPoint型別    
     public void before(JoinPoint call) {   
         //獲取目標物件對應的類名   
         String className = call.getTarget().getClass().getName();   
         //獲取目標物件上正在執行的方法名   
         String methodName = call.getSignature().getName();   
            
         System.out.println("前置通知:" + className + "類的" + methodName + "方法開始了");   
     }   
        
     public void afterReturn() {   
         System.out.println("後置通知:方法正常結束了");   
     }   
        
     public void after(){   
         System.out.println("最終通知:不管方法有沒有正常執行完成，一定會返回的");   
     }   
        
     public void afterThrowing() {   
         System.out.println("異常丟擲後通知:方法執行時出異常了");   
     }   
        
     //用來做環繞通知的方法可以第一個引數定義為org.aspectj.lang.ProceedingJoinPoint型別   
     public Object doAround(ProceedingJoinPoint call) throws Throwable {   
         Object result = null;   
         this.before(call);//相當於前置通知   
         try {   
             result = call.proceed();   
             this.afterReturn(); //相當於後置通知   
         } catch (Throwable e) {   
    
             this.afterThrowing();  //相當於異常丟擲後通知   
             throw e;   
         }finally{   
             this.after();  //相當於最終通知   
         }   
            
         return result;   
     }   
 }   

      這個類屬於業務服務類，如果用AOP的術語來說，它就是一個切面類，它定義了許多通知。Before()、afterReturn()、after()和afterThrowing()這些方法都是通知。 

<1>.基於xml配置檔案的AOP實現 

         這種方式在實現AOP時，有4個步驟。 

Xml程式碼   
< ?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:aop="http://www.springframework.org/schema/aop"   
         xsi:schemaLocation="   
             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>   
    
     <bean id="accountDaoImpl" class="com.zxf.dao.AccountDaoImpl"/>   
        
     <bean id="accountService" class="com.zxf.service.AccountServiceImpl">   
         <property name=" accountDaoImpl " ref=" accountDaoImpl "/>   
     </bean>   
    
     <!-- 日誌切面類 -->   
     <bean id="logAspectBean" class="com.zxf.aspect.LogAspect"/>   
        
     <!-- 第1步： AOP的配置 -->   
     <aop:config>   
         <!-- 第2步：配置一個切面 -->   
         <aop:aspect id="logAspect" ref="logAspectBean">   
             <!-- 第3步：定義切入點,指定切入點表示式 -->   
             <aop:pointcut id="allMethod"    
                 expression="execution(* com.zxf.service.*.*(..))"/>   
                    
             <!-- 第4步：應用前置通知 -->   
             <aop:before method="before" pointcut-ref="allMethod" />   
             <!-- 第4步：應用後置通知 -->   
             <aop:after-returning method="afterReturn" pointcut-ref="allMethod"/>   
             <!-- 第4步：應用最終通知 -->   
             <aop:after method="after" pointcut-ref="allMethod"/>   
             <!-- 第4步：應用丟擲異常後通知 -->   
             <aop:after-throwing method="afterThrowing" pointcut-ref="allMethod"/>   
                
             <!-- 第4步：應用環繞通知 -->   
             <!--   
             <aop:around method="doAround" pointcut-ref="allMethod" />  
              -->   
         </aop:aspect>   
     </aop:config>   
< /beans>   


     上述配置針對切入點應用了前置、後置、最終，以及丟擲異常後通知。這樣在測試執行AccountServiceImpl類的save()方法時，控制檯會有如下結果輸出。 

 前置通知：com.zxf.service.AccountServiceImpl類的save方法開始了。 
 針對MySQL的AccountDao實現中的save()方法。 
 後置通知:方法正常結束了。 
 最終通知:不管方法有沒有正常執行完成，一定會返回的。 
   <2>基於註解的AOP的實現 

    首先建立一個用來作為切面的類LogAnnotationAspect，同時把這個類配置在spring的配置檔案中。 
        在spring2.0以後引入了JDK5.0的註解Annotation的支援，提供了對AspectJ基於註解的切面的支援，從而 更進一步地簡化AOP的配置。具體的步驟有兩步。 

Spring的配置檔案是如下的配置： 


Xml程式碼   
< ?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:aop="http://www.springframework.org/schema/aop"   
         xsi:schemaLocation="   
             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>   
    
     <bean id="accountDao" class="com.zxf.dao.AccountDaoImpl"/>   
     <bean id="accountService" class="com.zxf.service.AccountServiceImpl">   
         <property name="accountDao" ref="accountDao"/>   
     </bean>   
     <!-- 把切面類交由Spring容器來管理 -->   
     <bean id="logAspectBean" class="com.zxf.aspect.LogAnnotationAspect"/>   
     <!-- 啟用spring對AspectJ註解的支援 -->   
     <aop:aspectj-autoproxy/>   
< /beans>   

這是那個切面的類LogAnnotationAspect 
 Java程式碼   
package com.zxf.aspect;   
    
 import org.aspectj.lang.JoinPoint;   
 import org.aspectj.lang.ProceedingJoinPoint;   
 import org.aspectj.lang.annotation.After;   
 import org.aspectj.lang.annotation.AfterReturning;   
 import org.aspectj.lang.annotation.AfterThrowing;   
 import org.aspectj.lang.annotation.Aspect;   
 import org.aspectj.lang.annotation.Before;   
 import org.aspectj.lang.annotation.Pointcut;   
    
 /**  
 * 日誌切面類  
*/   
 @Aspect  //定義切面類   
public class LogAnnotationAspect {   
     @SuppressWarnings("unused")   
     //定義切入點   
     @Pointcut("execution(* com.zxf.service.*.*(..))")   
     private void allMethod(){}   
        
     //針對指定的切入點表示式選擇的切入點應用前置通知   
     @Before("execution(* com. zxf.service.*.*(..))")   
     public void before(JoinPoint call) {   
            
         String className = call.getTarget().getClass().getName();   
         String methodName = call.getSignature().getName();   
            
         System.out.println("【註解-前置通知】:" + className + "類的"    
                 + methodName + "方法開始了");   
     }   
     //訪問命名切入點來應用後置通知   
     @AfterReturning("allMethod()")   
     public void afterReturn() {   
         System.out.println("【註解-後置通知】:方法正常結束了");   
     }   
        
     //應用最終通知   
     @After("allMethod()")   
     public void after(){   
         System.out.println("【註解-最終通知】:不管方法有沒有正常執行完成,"    
                 + "一定會返回的");   
     }   
        
     //應用異常丟擲後通知   
     @AfterThrowing("allMethod()")   
     public void afterThrowing() {   
         System.out.println("【註解-異常丟擲後通知】:方法執行時出異常了");   
     }   
        
     //應用周圍通知   
     //@Around("allMethod()")   
     public Object doAround(ProceedingJoinPoint call) throws Throwable{   
         Object result = null;   
         this.before(call);//相當於前置通知   
         try {   
             result = call.proceed();   
             this.afterReturn(); //相當於後置通知   
         } catch (Throwable e) {   
             this.afterThrowing();  //相當於異常丟擲後通知   
             throw e;   
         }finally{   
             this.after();  //相當於最終通知   
         }   
            
         return result;   
     }   
 }