AOP詳解

本文轉載自查看原文 2016-12-20 23:51 3119 Spring

什么是AOP
　　AOP Aspect Oriented Programing 面向切面編程
　　AOP采取橫向抽取機制，取代了傳統縱向繼承體系重復性代碼（性能監視、事務管理、安全檢查、緩存）
　　Spring AOP使用純Java實現，不需要專門的編譯過程和類加載器，在運行期通過代理方式向目標類織入增強代碼
　　AspecJ是一個基於Java語言的AOP框架，Spring2.0開始，Spring AOP引入對Aspect的支持，AspectJ擴展了Java語言，提供了一個專門的編譯器，在編譯時提供橫向代碼的織入
Spring的AOP代理
　　JDK動態代理:對實現了接口的類生成代理
　　CGLib代理機制:對類生成代理
AOP的術語
　　Joinpoint(連接點):所謂連接點是指那些被攔截到的點。在spring中,這些點指的是方法,因為spring只支持方法類型的連接點.
　　Pointcut(切入點):所謂切入點是指我們要對哪些Joinpoint進行攔截的定義.
　　Advice(通知/增強):所謂通知是指攔截到Joinpoint之后所要做的事情就是通知.通知分為前置通知,后置通知,異常通知,最終通知,環繞通知(切面要完成的功能)
　　Introduction(引介):引介是一種特殊的通知在不修改類代碼的前提下, Introduction可以在運行期為類動態地添加一些方法或Field.
　　Target(目標對象):代理的目標對象
　　Weaving(織入):是指把增強應用到目標對象來創建新的代理對象的過程.spring采用動態代理織入，而AspectJ采用編譯期織入和類裝載期織入
　　Proxy（代理）:一個類被AOP織入增強后，就產生一個結果代理類
　　Aspect(切面): 是切入點和通知（引介）的結合

AOP的底層實現

　　JDK動態代理演示

public interface UserDao { public void add(); public void update(); }

UserDao

public class UserDaoImpl implements UserDao { public void add() { System.out.println("添加用戶..."); } public void update() { System.out.println("修改用戶..."); } }

UserDaoImpl

public class JDKProxy implements InvocationHandler{ private UserDao userDao; public JDKProxy(UserDao userDao) { super(); this.userDao = userDao; } public UserDao createProxy() { UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this); return proxy; } // 調用目標對象的任何一個方法 都相當於調用invoke();
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if("add".equals(method.getName())){ // 記錄日志:
            System.out.println("日志記錄================="); Object result = method.invoke(userDao, args); return result; } return method.invoke(userDao, args); } }

@Test public void demo2(){ 　　// 被代理對象
   UserDao userDao = new UserDaoImpl(); // 創建代理對象的時候傳入被代理對象.
   UserDao proxy = new JDKProxy(userDao).createProxy(); proxy.add(); proxy.update(); /** * 輸出: * 日志記錄================= * 添加用戶... * 修改用戶... */ }

　　CGLIB動態代理演示
　　　　CGLIB(Code Generation Library)是一個開源項目！是一個強大的，高性能，高質量的Code生成類庫，它可以在運行期擴展Java類與實現Java接口。 Hibernate支持它來實現PO(Persistent Object 持久化對象)字節碼的動態生成(Hibernate實際使用Javassist生成代理，該代理對象就是持久化類的子類的實例)，現在做cglib的開發,可以不用直接引入cglib的包.因為spring核心中已經集成了cglib
　　　　CGLIB生成代理機制:其實生成了一個真實對象的子類

public class ProductDao { public void add(){ System.out.println("添加商品..."); } public void update(){ System.out.println("修改商品..."); } }

ProductDao

public class CGLibProxy implements MethodInterceptor{ private ProductDao productDao; public CGLibProxy(ProductDao productDao) { super(); this.productDao = productDao; } public ProductDao createProxy(){ // 使用CGLIB生成代理: // 1.創建核心類:
        Enhancer enhancer = new Enhancer(); // 2.為其設置父類:
 enhancer.setSuperclass(productDao.getClass()); // 3.設置回調:
        enhancer.setCallback(this); // 4.創建代理:
        return (ProductDao) enhancer.create(); } public Object intercept(Object proxy, Method method, Object[] args,MethodProxy methodProxy) throws Throwable { if("add".equals(method.getName())){ System.out.println("日志記錄=============="); Object obj = methodProxy.invokeSuper(proxy, args); return obj; } return methodProxy.invokeSuper(proxy, args); } }

public void demo2(){ 　　ProductDao productDao = new ProductDao(); 　　ProductDao proxy = new CGLibProxy(productDao).createProxy(); 　　proxy.add(); 　　proxy.update(); 　　/** 　　* 輸出: 　　* 日志記錄================= 　　* 添加用戶... 　　* 修改用戶... 　　*/ }

　　結論:Spring框架,如果類實現了接口,就使用JDK的動態代理生成代理對象,如果這個類沒有實現任何接口,使用CGLIB生成代理對象

Spring中的AOP

　　Spring的傳統AOP
　　　　AOP:不是由Spring定義.AOP聯盟的組織定義.
　　　　Spring中的通知(增強代碼)
　　　　　　前置通知 org.springframework.aop.MethodBeforeAdvice:在目標方法執行前實施增強
　　　　　　后置通知 org.springframework.aop.AfterReturningAdvice:在目標方法執行后實施增強
　　　　　　環繞通知 org.aopalliance.intercept.MethodInterceptor:在目標方法執行前后實施增強
　　　　　　異常拋出通知 org.springframework.aop.ThrowsAdvice:在方法拋出異常后實施增強
　　　　　　引介通知 org.springframework.aop.IntroductionInterceptor(不研究):在目標類中添加一些新的方法和屬性
　　Spring中的切面類型

　　　　Advisor（Spring中傳統切面）就是對PointCut應用Advice（通常所說Advisor指只有一個Point和一個Advice,Aspect:多個切點和多個通知組合）
　　　　Advisor : 代表一般切面，Advice本身就是一個切面，對目標類所有方法進行攔截（沒有切點）
　　　　PointcutAdvisor : 代表具有切點的切面，可以指定攔截目標類哪些方法
　　　　IntroductionAdvisor : 代表引介切面，針對引介通知而使用切面（不要求掌握）

Spring的AOP的開發

　　針對所有方法的增強(不帶有切點的切面)
　　　　第一步:導入相應jar包
　　　　　　spring-aop-3.2.0.RELEASE.jar
　　　　　　com.springsource.org.aopalliance-1.0.0.jar

　　　　第二步:編寫被代理對象

public interface CustomerDao {
    public void add();
    public void update();
    public void delete();
    public void find();
}

CustomerDao

public class CustomerDaoImpl implements CustomerDao {
    public void add() {
        System.out.println("添加客戶");
    }
    public void update() {
        System.out.println("修改客戶");
    }
    public void delete() {
        System.out.println("刪除客戶");
    }
    public void find() {
        System.out.println("查詢客戶");
    }
}

CustomerDaoImpl

　　　　第三步:編寫增強的代碼

public class MyBeforeAdvice implements MethodBeforeAdvice{
    /**
     * method:執行的方法
     * args:參數
     * target:目標對象
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置增強...");
    }
}

　　　　第四步:生成代理(配置生成代理)
　　　　　　生成代理Spring基於ProxyFactoryBean類.底層自動選擇使用JDK的動態代理還是CGLIB的代理.
　　　　　　　　屬性:
　　　　　　　　　　target : 代理的目標對象
　　　　　　　　　　proxyInterfaces : 代理要實現的接口
　　　　　　　　　　　　如果多個接口可以使用以下格式賦值
　　　　　　　　　　　　　　<list>
　　　　　　　　　　　　　　　　<value></value>
　　　　　　　　　　　　　　　　....
　　　　　　　　　　　　　　</list>
　　　　　　　　　　proxyTargetClass : 是否對類代理而不是接口，設置為true時，使用CGLib代理
　　　　　　　　　　interceptorNames : 需要織入目標的Advice
　　　　　　　　　　singleton : 返回代理是否為單實例，默認為單例
　　　　　　　　　　optimize : 當設置為true時，強制使用CGLib

<!-- 不帶有切點的切面 -->
<!-- 定義目標對象 -->
<bean id="customerDao" class="cn.yzu.spring3.demo3.CustomerDaoImpl"></bean>   
<!-- 定義增強 -->
<bean id="beforeAdvice" class="cn.yzu.spring3.demo3.MyBeforeAdvice"></bean>
<!-- Spring支持配置生成代理: -->
<bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
　　<!-- 設置目標對象 -->
　　<property name="target" ref="customerDao"/>
　　<!-- 設置實現的接口 ,value中寫接口的全路徑 -->
    <property name="proxyInterfaces" value="cn.yzu.spring3.demo3.CustomerDao"/>
    <!-- 需要使用value:要的名稱 -->
    <property name="interceptorNames" value="beforeAdvice"/>
    <!-- 強制使用CGLIB代理 -->
    <property name="optimize" value="true"></property>
</bean>

　　　　第五步:注入測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest3 {
    @Autowired
    //不可注入@Qualifier("customerDao"),必須注入代理對象.
    @Qualifier("customerDaoProxy")
    private CustomerDao customerDao;  
    @Test
    public void demo1(){
        customerDao.add();
        customerDao.update();
        customerDao.delete();
        customerDao.find();
        /**
         * 輸出:
         *     前置增強...
            　　添加客戶
            　　前置增強...
            　　修改客戶
            　　前置增強...
            　　刪除客戶
            　　前置增強...
            　　查詢客戶
         */
    }
}

　　帶有切點的切面:(針對目標對象的某些方法進行增強)
　　　　PointcutAdvisor 接口
　　　　　　DefaultPointcutAdvisor 最常用的切面類型，它可以通過任意Pointcut和Advice 組合定義切面
　　　　　　RegexpMethodPointcutAdvisor 構造正則表達式切點切面

　　　　第一步:創建被代理對象.

public class OrderDao {
    public void add(){
        System.out.println("添加訂單");
    }
    public void update(){
        System.out.println("修改訂單");
    }
    public void delete(){
        System.out.println("刪除訂單");
    }
    public void find(){
        System.out.println("查詢訂單");
    }
}

OrderDao

　　　　第二步:編寫增強的類

public class MyAroundAdvice implements MethodInterceptor{   
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("環繞前增強...");
        Object result = methodInvocation.proceed();// 執行目標對象的方法
        System.out.println("環繞后增強...");
        return result;
    }
}

　　　　第三步:生成代理

<!-- 帶有切點的切面 -->
<!-- 定義目標對象 -->
<bean id="orderDao" class="cn.yzu.spring3.demo4.OrderDao"></bean> 
<!-- 定義增強 -->
<bean id="aroundAdvice" class="cn.yzu.spring3.demo4.MyAroundAdvice"></bean>
<!-- 定義切點切面: -->
<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
　　<!-- 定義表達式,規定哪些方法執行攔截 -->
　　<!-- . 任意字符  * 任意個 -->
　　<!-- <property name="pattern" value=".*"/> -->
　　<!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> -->
　　<!-- <property name="pattern" value=".*add.*"></property> -->
　　<property name="patterns" value=".*add.*,.*find.*"></property>
　　<!-- 應用增強 -->
　　<property name="advice" ref="aroundAdvice"/>
</bean>
<!-- 定義生成代理對象 -->
<bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
　　<!-- 配置目標 -->
　　<property name="target" ref="orderDao"></property>
　　<!-- 針對類的代理 -->
　　<property name="proxyTargetClass" value="true"></property>
　　<!-- 在目標上應用增強 -->
　　<property name="interceptorNames" value="myPointcutAdvisor"></property>
</bean>

　　　　第四步：注入測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest4 {   
    @Autowired
    @Qualifier("orderDaoProxy")
    private OrderDao orderDao;  
    @Test
    public void demo1(){
        orderDao.add();
        orderDao.delete();
        orderDao.update();
        orderDao.find();
        /**
         * 輸出：
         *      環繞前增強...
                添加訂單
                環繞后增強...
                刪除訂單
                修改訂單
                環繞前增強...
                查詢訂單
                環繞后增強...
         */
    }

}

　　自動代理
　　　　前面的案例中，每個代理都是通過ProxyFactoryBean織入切面代理，在實際開發中，非常多的Bean每個都配置ProxyFactoryBean開發維護量巨大

　　　　自動創建代理(基於后處理Bean.在Bean創建的過程中完成的增強.生成Bean就是代理)
　　　　　　BeanNameAutoProxyCreator 根據Bean名稱創建代理
　　　　　　DefaultAdvisorAutoProxyCreator 根據Advisor本身包含信息創建代理

　　　　BeanNameAutoProxyCreator :按名稱生成代理

<!-- 定義目標對象 -->
<bean id="customerDao" class="cn.yzu.spring3.demo3.CustomerDaoImpl"></bean>
<bean id="orderDao" class="cn.yzu.spring3.demo4.OrderDao"></bean>   
<!-- 定義增強 -->
<bean id="beforeAdvice" class="cn.yzu.spring3.demo3.MyBeforeAdvice"></bean>
<bean id="aroundAdvice" class="cn.yzu.spring3.demo4.MyAroundAdvice"></bean>
<!-- 自動代理:按名稱的代理 基於后處理Bean,后處理Bean不需要配置ID-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
　　<property name="beanNames" value="*Dao"/>
　　<property name="interceptorNames" value="beforeAdvice"/>
</bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest5 {
    @Autowired
    @Qualifier("orderDao")
    private OrderDao orderDao;
    @Autowired
    @Qualifier("customerDao")
    private CustomerDao customerDao;    
    @Test
    public void demo1(){
        orderDao.add();
        orderDao.delete();
        customerDao.update();
        /**
         * 輸出：
         *      前置增強...
                添加訂單
                前置增強...
                刪除訂單
                前置增強...
                修改客戶
         */
    }
}

　　　　DefaultAdvisorAutoProxyCreator :根據切面中定義的信息生成代理

<!-- 定義目標對象 -->
<bean id="customerDao" class="cn.yzu.spring3.demo3.CustomerDaoImpl"></bean>
<bean id="orderDao" class="cn.yzu.spring3.demo4.OrderDao"></bean> 
<!-- 定義增強 -->
<bean id="beforeAdvice" class="cn.yzu.spring3.demo3.MyBeforeAdvice"></bean>
<bean id="aroundAdvice" class="cn.yzu.spring3.demo4.MyAroundAdvice"></bean>
<!-- 定義一個帶有切點的切面 -->
<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
　　<property name="pattern" value=".*add.*"/>
　　<property name="advice" ref="aroundAdvice"/>
</bean>  
<!-- 自動生成代理 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

　　　　區分基於ProxyFattoryBean的代理與自動代理區別?
　　　　　　ProxyFactoryBean:先有被代理對象,將被代理對象傳入到代理類中生成代理
　　　　　　自動代理基於后處理Bean.在Bean的生成過程中,就產生了代理對象,把代理對象返回.生成Bean已經是代理對象

Spring的AspectJ的AOP(重要！！！！！)
　　AspectJ是一個面向切面的框架，它擴展了Java語言。AspectJ定義了AOP語法所以它有一個專門的編譯器用來生成遵守Java字節編碼規范的Class文件。
　　Spring2.0以后新增了對AspectJ切點表達式支持,@AspectJ 是AspectJ1.5新增功能，通過JDK5注解技術，允許直接在Bean類中定義切面
　　新版本Spring框架，建議使用AspectJ方式來開發AOP

　　AspectJ表達式:
　　　　語法:execution(表達式)
　　　　　　execution(<訪問修飾符>?<返回類型><方法名>(<參數>)<異常>)

　　　　　　execution(“* cn.itcast.spring3.demo1.dao.*(..)”) ---只檢索當前包
　　　　　　execution(“* cn.itcast.spring3.demo1.dao..*(..)”) ---檢索包及當前包的子包.
　　　　　　execution(* cn.itcast.dao.GenericDAO+.*(..)) ---檢索GenericDAO及子類

　　AspectJ增強
　　　　@Before 前置通知，相當於BeforeAdvice
　　　　@AfterReturning 后置通知，相當於AfterReturningAdvice
　　　　@Around 環繞通知，相當於MethodInterceptor
　　　　@AfterThrowing拋出通知，相當於ThrowAdvice
　　　　@After 最終final通知，不管是否異常，該通知都會執行
　　　　@DeclareParents 引介通知，相當於IntroductionInterceptor (不要求掌握)

　　基於注解開發
　　　　第一步:引入相應jar包
　　　　　　aspectj依賴aop環境
　　　　　　spring-aspects-3.2.0.RELEASE.jar
　　　　　　com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

　　　　第二步:編寫被增強的類:

public class UserDao {
    public void add(){
        System.out.println("添加用戶");
    }
    public int update(){
        System.out.println("修改用戶");
        return 1;
    }
    public void delete(){
        System.out.println("刪除用戶");
    }
    public void find(){
        System.out.println("查詢用戶");
        //int d = 1/ 0;
    }
}

UserDao

　　　　第三步:使用AspectJ注解形式

@Aspect
public class MyAspect {   
    @Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置增強...."+joinPoint);
    }   
    @AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.update(..))",returning="returnVal")
    public void afterReturin(Object returnVal){
        System.out.println("后置增強....方法的返回值:"+returnVal);
    }  
    @Around(value="MyAspect.myPointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("環繞前增強....");
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("環繞后增強....");
        return obj;
    }  
    @AfterThrowing(value="MyAspect.myPointcut()",throwing="e")
    public void afterThrowing(Throwable e){
        System.out.println("不好了 出異常了!!!"+e.getMessage());
    } 
    @After("MyAspect.myPointcut()")
    public void after(){
        System.out.println("最終通知...");
    } 
    @Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")//切點的定義
    private void myPointcut(){}
}

　　　　第四步:創建applicationContext.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.xsd
　　　　　　http://www.springframework.org/schema/aop 
　　　　　　http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 自動生成代理  底層就是AnnotationAwareAspectJAutoProxyCreator -->
    <aop:aspectj-autoproxy />
    <bean id="userDao" class="cn.yzu.spring3.demo1.UserDao"></bean>
    <bean id="myAspect" class="cn.yzu.spring3.demo1.MyAspect"></bean>
</beans>

　　　　第五步：測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao; 
    @Test
    public void demo1(){
        userDao.add();
        userDao.delete();
        userDao.update();
        userDao.find();
        /**
         * 輸出：
             *  前置增強....execution(void cn.itcast.spring3.demo1.UserDao.add())
                添加用戶
                刪除用戶
                修改用戶
                后置增強....方法的返回值:1
                環繞前增強....
                查詢用戶
                環繞后增強....
                最終通知...
         */
    }
}

　　　　AspectJ的通知類型
　　　　　　@Before 前置通知，相當於BeforeAdvice:就在方法之前執行.沒有辦法阻止目標方法執行的
　　　　　　@AfterReturning 后置通知，相當於AfterReturningAdvice:后置通知,獲得方法返回值
　　　　　　@Around 環繞通知，相當於MethodInterceptor:在可以方法之前和之后來執行的,而且可以阻止目標方法的執行
　　　　　　@AfterThrowing拋出通知，相當於ThrowAdvice
　　　　　　@After 最終final通知，不管是否異常，該通知都會執行
　　　　　　@DeclareParents 引介通知，相當於IntroductionInterceptor (不要求掌握)

　　　　面試
　　　　　　Advisor和Aspect的區別?
　　　　　　　　Advisor:Spring傳統意義上的切面:支持一個切點和一個通知的組合.
　　　　　　　　Aspect:可以支持多個切點和多個通知的組合.
　　基於XML開發
　　　　第一步:編寫被增強的類:

public class ProductDao {
    public int add(){
        System.out.println("添加商品...");
        //int d = 10/0;
        return 100;
    }
    public void update(){
        System.out.println("修改商品...");
    }
    public void delete(){
        System.out.println("刪除商品...");
    }
    public void find(){
        System.out.println("查詢商品...");
    }
}

ProductDao

　　　　第二步:定義切面

public class MyAspectXML {
    public void before(){
        System.out.println("前置通知...");
    }
    public void afterReturing(Object returnVal){
        System.out.println("后置通知...返回值:"+returnVal);
    }
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("環繞前增強....");
        Object result = proceedingJoinPoint.proceed();
        System.out.println("環繞后增強....");
        return result;
    }
    public void afterThrowing(Throwable e){
        System.out.println("異常通知..."+e.getMessage());
    }
    public void after(){
        System.out.println("最終通知....");
    }
}

　　　　第三步:配置applicationContext.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.xsd
　　　　　　http://www.springframework.org/schema/aop 
　　　　　　http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 定義被增強的類 -->
    <bean id="productDao" class="cn.yzu.spring3.demo2.ProductDao"></bean>
    <!-- 定義切面 -->
    <bean id="myAspectXML" class="cn.yzu.spring3.demo2.MyAspectXML"></bean> 
    <!-- 定義aop配置 -->
    <aop:config>
        <!-- 定義切點: -->
        <aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
        <aop:aspect ref="myAspectXML">
            <!-- 前置通知 -->
            <!-- <aop:before method="before" pointcut-ref="mypointcut"/> -->
            <!-- 后置通知 -->
            <!-- <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> -->
            <!-- 環繞通知 -->
            <!-- <aop:around method="around" pointcut-ref="mypointcut"/> -->
            <!-- 異常通知 -->
            <!-- <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/> -->
            <!-- 最終通知 -->
            <aop:after method="after" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

　　　　第四步：測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {
    @Autowired
    @Qualifier("productDao")
    private ProductDao productDao;    
    @Test
    public void demo1(){
        productDao.add();
        productDao.find();
        productDao.update();
        productDao.delete();
        /**
         * 輸出：
         *  添加商品...
            最終通知....
            查詢商品...
            修改商品...
            刪除商品...
         */
    }
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 AOP詳解 AOP切面詳解 Aop JoinPoint方法詳解 Spring AOP詳解 3、Spring的AOP詳解和案例 Spring4 AOP詳解 aop 概念詳解 Spring之AOP詳解 spring中AOP詳解 Spring詳解（五）------AOP