Spring 通過XML配置文件以及通過注解形式來AOP 來實現前置，環繞，異常通知，返回后通知，后通知

本文轉載自查看原文 2015-08-17 18:14 6322 Spring

本節主要內容：

一、Spring 通過XML配置文件形式來AOP 來實現前置，環繞，異常通知

1. Spring AOP 前置通知 XML配置使用案例

2. Spring AOP 環繞通知 XML配置使用案例

3. Spring AOP 拋出異常后通知 XML配置使用案例

4. Spring AOP 返回后通知 XML配置使用案例

5. Spring AOP 后通知 XML配置使用案例

二、Spring 通過注解形式來AOP 來實現前置，環繞，異常通知

1. Spring AOP 前置通知注解使用案例

2. Spring AOP 環繞通知注解使用案例

3. Spring AOP 拋出異常后通知注解使用案例

4. Spring AOP 返回后通知注解使用案例

5. Spring AOP 后通知注解使用案例

本文作者：souvc

本文出處：http://www.cnblogs.com/liuhongfeng/p/4736947.html

AOP是Aspect Oriented Programming的縮寫，意思是面向方面編程，AOP實際是GoF設計模式的延續

關於Spring AOP的一些術語

切面（Aspect）：在Spring AOP中，切面可以使用通用類或者在普通類中以@Aspect 注解（@AspectJ風格）來實現

連接點（Joinpoint）：在Spring AOP中一個連接點代表一個方法的執行

通知（Advice）：在切面的某個特定的連接點（Joinpoint）上執行的動作。通知有各種類型，其中包括"around"、"before”和"after"等通知。許多AOP框架，包括Spring，都是以攔截器做通知模型，並維護一個以連接點為中心的攔截器鏈

切入點（Pointcut）：定義出一個或一組方法，當執行這些方法時可產生通知，Spring缺省使用AspectJ切入點語法。

通知類型

前置通知（@Before）：在某連接點（join point）之前執行的通知，但這個通知不能阻止連接點前的執行（除非它拋出一個異常）

返回后通知（@AfterReturning）：在某連接點（join point）正常完成后執行的通知：例如，一個方法沒有拋出任何異常，正常返回

拋出異常后通知（@AfterThrowing）：方法拋出異常退出時執行的通知

后通知（@After）：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）

環繞通知（@Around）：包圍一個連接點（join point）的通知，如方法調用。這是最強大的一種通知類型，環繞通知可以在方法調用前后完成自定義的行為，它也會選擇是否繼續執行連接點或直接返回它們自己的返回值或拋出異常來結束執行

Spring 實現AOP是依賴JDK動態代理和CGLIB代理實現的。以下是JDK動態代理和CGLIB代理簡單介紹

JDK動態代理：其代理對象必須是某個接口的實現，它是通過在運行期間創建一個接口的實現類來完成對目標對象的代理。
CGLIB代理：實現原理類似於JDK動態代理，只是它在運行期間生成的代理對象是針對目標類擴展的子類。CGLIB是高效的代碼生成包，底層是依靠ASM（開源的java字節碼編輯類庫）操作字節碼實現的，性能比JDK強。

在Spring中，有接口時將采用JDK的方式實現proxy代理對象，當沒有接口時，將采用cglib中的方式實現prixy代理對象。

一、 Spring 通過XML配置文件形式來AOP 來實現前置，環繞，異常通知

1 Spring AOP前置通知案例

1.1 問題

使用Spring AOP前置通知，在訪問Controller中每個方法前，記錄用戶的操作日志。

1.2 方案

Spring AOP使用步驟：

1.3 步驟

實現此案例需要按照如下步驟進行。

步驟一：創建Controller,創建新項目SpringAOP。

導入Spring 環境的jar包：

如果沒有jar包，那么可以上去上面下一個。下載地址：http://yunpan.cn/cdXTcJtZfJqQk 訪問密碼 6c96

創建員工業務控制器EmpController，並實現員工查詢，代碼如下：

package com.souvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * 控制類  
 *
 */
@Controller
@RequestMapping("/emp")
public class EmpController {
    
    /**
    * 方法名：find</br>
    * 詳述： 查詢員工  </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @param userid
    * @param password
    * @return
    * @throws
     */
    @RequestMapping("/findEmp.do")
    public String find(String userid,String password) {
        
        // 模擬查詢員工數據
        System.out.println("執行，find()方法，查詢員工數據，發送至列表頁面.");
        
        return "emp/emp_list.jsp";
    }
}

步驟二：創建方面組件

創建方面組件OperateLogger，並在該類中創建記錄用戶操作日志的方法，代碼如下：

package com.souvc.aspect;

/**
 * 用於記錄日志的方面組件，演示Spring AOP的各種通知類型。
 */
public class OperateLogger {
    
    /**
    * 方法名：log1</br>
    * 詳述：測試前置通知 </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @throws
     */
    public void log1() {
        // 記錄日志
        System.out.println("進入log1()方法");
    }
}

步驟三：聲明方面組件

在applicationContext.xml中，聲明該方面組件，關鍵代碼如下：

     <!-- 聲明方面組件 -->  

    <bean id="operateLogger" class="com.souvc.aspect.OperateLogger"/>

步驟四：將方面組件作用到目標組件上

在applicationContext.xml中，將聲明的方面組件作用到com.souvc.controller包下所有類的所有方法上，關鍵代碼如下：

    <!-- 聲明方面組件 -->
    <bean id="operateLogger" class="com.souvc.aspect.OperateLogger"/>
    
    <!-- 配置AOP -->
    <aop:config>
        <aop:aspect ref="operateLogger">
            <aop:before method="log1" pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
    </aop:config>

步驟五：測試

創建Junit測試類TestEmpController，並增加測試查詢員工的方法，代碼如下：

package com.souvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * 控制類  
 *
 */
@Controller
@RequestMapping("/emp")
public class EmpController {
    
    /**
    * 方法名：find</br>
    * 詳述： 查詢員工  </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @param userid
    * @param password
    * @return
    * @throws
     */
    @RequestMapping("/findEmp.do")
    public String find(String userid,String password) {
        
        // 模擬查詢員工數據
        System.out.println("執行，find()方法，查詢員工數據，發送至列表頁面.");
        
        return "emp/emp_list.jsp";
    }
}

執行該測試方法，控制台輸出效果：

進入log1()方法
執行，find()方法，查詢員工數據，發送至列表頁面.

可見，在執行EmpController.find()方法之前，執行了方面組件的記錄日志的方法，由於該方法采用AOP面向對象的思想實現的，因此不需要對Controller類做任何改動。

2 Spring AOP環繞通知案例

2.1 問題

使用Spring AOP環繞通知，在訪問Controller中每個方法前，記錄用戶的操作日志。

2.2 方案

Spring AOP使用步驟：

2.3 步驟

實現此案例需要按照如下步驟進行。

步驟一：創建方面組件

復用方面組件OperateLogger，在該類中創建新的記錄日志的方法log2，代碼如下：

/**
    * 方法名：log2</br>
    * 詳述：環繞通知使用的方法 </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @param p
    * @return
    * @throws Throwable
    * @throws
     */
    public Object log2(ProceedingJoinPoint p) throws Throwable {
        // 目標組件的類名
        String className = p.getTarget().getClass().getName();
        // 調用的方法名
        String method = p.getSignature().getName();
        // 當前系統時間
        String date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss") .format(new Date());
        // 拼日志信息
        String msg = "-->用戶在" + date + "，執行了" + className + "." + method + "()";
        // 記錄日志
        System.out.println(msg);
        // 執行目標組件的方法
        Object obj = p.proceed();
        // 在調用目標組件業務方法后也可以做一些業務處理
        System.out.println("-->調用目標組件業務方法后...");
        return obj;
    }

步驟二：聲明方面組件

由於復用的方面組件已經聲明，因此該步驟可以省略。

步驟三：將方面組件作用到目標組件上

在applicationContext.xml中，聲明方面組件的log2方法，關鍵代碼如下：

<aop:aspect ref="operateLogger">
   <aop:around method="log2" pointcut="within(com.souvc.controller..*)"/>
 </aop:aspect>

步驟四：測試

執行測試方法TestEmpController.test1()，控制台輸出效果如下：

進入log1()方法
-->用戶在2016-04-29 01:06:54，執行了com.souvc.controller.EmpController.find()
執行，find()方法，查詢員工數據，發送至列表頁面.
-->調用目標組件業務方法后..

項目詳細代碼：

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:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
            http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">

    <!-- 開啟注解掃描 -->
    <context:component-scan base-package="com.souvc" />

    <!-- 支持@RequestMapping請求和Controller映射 -->
    <mvc:annotation-driven />
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 聲明方面組件--> 
    <bean id="operateLogger" class="com.souvc.aspect.OperateLogger" />

      <!-- 配置AOP -->
    <aop:config>
    
         <!-- 測試前置通知 -->
        <aop:aspect ref="operateLogger">
            <aop:before method="log1"  pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        
        <!-- 測試環繞通知 -->
        <aop:aspect ref="operateLogger">
            <aop:around method="log2" pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        
        
    </aop:config> 
    
    
   
    
</beans>

OperateLogger.java

package com.souvc.aspect;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 用於記錄日志的方面組件，演示Spring AOP的各種通知類型。
 */
public class OperateLogger {
    
    /**
    * 方法名：log1</br>
    * 詳述：測試前置通知 </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @throws
     */
    public void log1() {
        // 記錄日志
        System.out.println("進入log1()方法");
    }
    
    
    
    /**
    * 方法名：log2</br>
    * 詳述：環繞通知使用的方法 </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @param p
    * @return
    * @throws Throwable
    * @throws
     */
    public Object log2(ProceedingJoinPoint p) throws Throwable {
        // 目標組件的類名
        String className = p.getTarget().getClass().getName();
        // 調用的方法名
        String method = p.getSignature().getName();
        // 當前系統時間
        String date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss") .format(new Date());
        // 拼日志信息
        String msg = "-->用戶在" + date + "，執行了" + className + "." + method + "()";
        // 記錄日志
        System.out.println(msg);
        // 執行目標組件的方法
        Object obj = p.proceed();
        // 在調用目標組件業務方法后也可以做一些業務處理
        System.out.println("-->調用目標組件業務方法后...");
        return obj;
    }

}

3 Spring AOP異常通知案例

3.1 問題

使用Spring AOP異常通知，在每個Controller的方法發生異常時，記錄異常日志。

3.2 方案

Spring AOP使用步驟：

3.3 步驟

實現此案例需要按照如下步驟進行。

步驟一：創建方面組件

復用方面組件OperateLogger，在該類中創建新的記錄日志的方法log3，代碼如下：

 /**
   * 方法名：log3</br>
   * 詳述：測試異常通知使用的方法</br>
   * 開發人員：http://www.cnblogs.com/liuhongfeng/  </br>
   * 創建時間：2016年4月29日  </br>
   * @param e
   * @throws
    */
    public void log3(Exception e) {
        StackTraceElement[] elems = e.getStackTrace();
        // 將異常信息記錄
        System.out.println("-->" + elems[0].toString());
    }

步驟二：聲明方面組件

由於復用的方面組件已經聲明，因此該步驟可以省略。

步驟三：將方面組件作用到目標組件上

在applicationContext.xml中，聲明方面組件的log3方法，關鍵代碼如下：

 <aop:aspect ref="operateLogger">
            <aop:after-throwing method="log3" throwing="e" pointcut="within(com.souvc.controller..*)"/>
 </aop:aspect>

關鍵配置代碼：

<!-- 開啟注解掃描 -->
    <context:component-scan base-package="com.souvc" />

    <!-- 支持@RequestMapping請求和Controller映射 -->
    <mvc:annotation-driven />
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 聲明方面組件--> 
    <bean id="operateLogger" class="com.souvc.aspect.OperateLogger" />

      <!-- 配置AOP -->
    <aop:config>
    
         <!-- 測試前置通知 -->
        <aop:aspect ref="operateLogger">
            <aop:before method="log1"  pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        
        <!-- 測試環繞通知 -->
        <aop:aspect ref="operateLogger">
            <aop:around method="log2" pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        
        <!-- 測試異常通知 -->
         <aop:aspect ref="operateLogger">
            <aop:after-throwing method="log3" throwing="e" pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        
    </aop:config>

步驟四：測試

為了便於測試，在EmpController.find()方法中制造一個異常，代碼如下：

主要代碼：

 // 制造一個異常，便於測試異常通知
        //Integer.valueOf("abc");

五、測試效果

進入log1()方法
-->用戶在2016-04-29 01:12:07，執行了com.souvc.controller.EmpController.find()
執行，find()方法，查詢員工數據，發送至列表頁面.
-->java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)

4 Spring AOP 后返回通知案例

4.1 問題

使用Spring AOP后返回通知類型。

4.2 方案

Spring AOP使用步驟：

4.3 步驟

實現此案例需要按照如下步驟進行。

5 Spring AOP 執行后案例

5.1 問題

使用Spring AOP 執行后通知類型。

5.2 方案

Spring AOP使用步驟：

5.3 步驟

實現此案例需要按照如下步驟進行。

步驟一：

在 OperateLogger.java 添加以下代碼：

 /**
     * 方法名：log5</br>
     * 詳述：測試 執行后使用的方法</br>
     * 開發人員：http://www.cnblogs.com/liuhongfeng/  </br>
     * 創建時間：2016年4月29日  </br>
     * @param result
     * @return
     * @throws
      */
    public void log5() {
        // 記錄日志
        System.out.println("進入log5()方法");
    }

步驟二：

在 applicationContext.xml 添加以下代碼：

<!-- 測試后通知 -->
  <aop:aspect ref="operateLogger">
       <aop:after method="log5"  pointcut="within(com.souvc.controller..*)"/>
  </aop:aspect>

步驟三：

運行測試類

步驟四：

效果如下：

進入log1()方法
-->用戶在2016-04-29 01:53:10，執行了com.souvc.controller.EmpController.find()
執行，find()方法，查詢員工數據，發送至列表頁面.
進入log5()方法
-->java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)

二、 Spring 通過注解形式形式來AOP 來實現前置，環繞，異常通知

Spring AOP相關注解及含義如下：

@Aspect：用於聲明方面組件

@Before：用於聲明前置通知

@AfterReturning：用於聲明后置通知

@After：用於聲明最終通知

@Around：用於聲明環繞通知

@AfterThrowing：用於聲明異常通知

1 Spring AOP注解使用案例

1.1 問題

使用Spring AOP注解替代XML配置，重構上面的3個案例。

1.2 方案

分別在對應的方法上面加上注解。

1.3 步驟

實現此案例需要按照如下步驟進行。

步驟一：開啟AOP注解掃描

在applicationContext.xml中，去掉方面組件聲明及作用的XML配置，並開啟AOP注解掃描，關鍵代碼如下：

<!-- 聲明方面組件 -->
    <!-- <bean id="operateLogger" class="com.souvc.aspect.OperateLogger" />-->

    <!-- 配置AOP -->
    
    <!--  <aop:config>
        <aop:aspect ref="operateLogger">
            <aop:before method="log1" pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        <aop:aspect ref="operateLogger">
            <aop:around method="log2"  pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
        <aop:aspect ref="operateLogger">
            <aop:after-throwing method="log3" throwing="e" pointcut="within(com.souvc.controller..*)"/>
        </aop:aspect>
     </aop:config>    -->

<!-- 開啟AOP注解掃描 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

或者：

<!-- 啟用spring對AspectJ注解的支持 -->  
    <aop:aspectj-autoproxy/>

步驟二：使用注解聲明方面組件

在OperateLogger中，使用@Aspect注解聲明方面組件，並分別用@Before、@Around、@AfterThrowing注解聲明log1、log2、log3方法，將方面組件作用到目標組件上，代碼如下：

package com.souvc.aspect;

import java.text.SimpleDateFormat;
import java.util.Date;

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.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 用於記錄日志的方面組件，演示Spring AOP的各種通知類型。
 */
@Component
@Aspect
public class OperateLogger {
    
    /**
    * 方法名：log1</br>
    * 詳述：測試前置通知 </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @throws
     */
     @Before("within(com.souvc.controller..*)")
    public void log1() {
        // 記錄日志
        System.out.println("進入log1()方法");
    }
    
    
    
    /**
    * 方法名：log2</br>
    * 詳述：環繞通知使用的方法 </br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/ </br>
    * 創建時間：2016年4月29日  </br>
    * @param p
    * @return
    * @throws Throwable
    * @throws
     */
     @Around("within(com.souvc.controller..*)")
    public Object log2(ProceedingJoinPoint p) throws Throwable {
        // 目標組件的類名
        String className = p.getTarget().getClass().getName();
        // 調用的方法名
        String method = p.getSignature().getName();
        // 當前系統時間
        String date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss") .format(new Date());
        // 拼日志信息
        String msg = "-->用戶在" + date + "，執行了" + className + "." + method + "()";
        // 記錄日志
        System.out.println(msg);
        // 執行目標組件的方法
        Object obj = p.proceed();
        // 在調用目標組件業務方法后也可以做一些業務處理
        System.out.println("-->調用目標組件業務方法后...");
        return obj;
    }

    
    
    
   /**
   * 方法名：log3</br>
   * 詳述：測試異常通知使用的方法</br>
   * 開發人員：http://www.cnblogs.com/liuhongfeng/  </br>
   * 創建時間：2016年4月29日  </br>
   * @param e
   * @throws
    */
     @AfterThrowing(pointcut = "within(com.souvc.controller..*)", throwing = "e")
    public void log3(Exception e) {
        StackTraceElement[] elems = e.getStackTrace();
        // 將異常信息記錄
        System.out.println("-->" + elems[0].toString());
    }
    
    
    /**
    * 方法名：log4</br>
    * 詳述：測試 返回后通知使用的方法</br>
    * 開發人員：http://www.cnblogs.com/liuhongfeng/  </br>
    * 創建時間：2016年4月29日  </br>
    * @param result
    * @return
    * @throws
     */
     @AfterReturning(value="execution(* com.souvc.controller.*.*(..))",returning="result")
    public void log4(JoinPoint joinPoint,Object result ){
        Object object = joinPoint.getSignature();//方法返回值
       
        System.out.println("joinPoint.getKind():"+ joinPoint.getKind());
        System.out.println("joinPoint.getTarget():"+joinPoint.getTarget());
        System.out.println("joinPoint.getThis():"+joinPoint.getThis());
        System.out.println("joinPoint.getArgs():"+joinPoint.getArgs().length);
        Object [] args=joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            System.out.println("參數："+args[i]);
        }
        System.out.println("joinPoint.getSignature():"+joinPoint.getSignature());
        System.out.println("joinPoint.getSourceLocation():"+joinPoint.getSourceLocation());
        System.out.println("joinPoint.getStaticPart():"+joinPoint.getStaticPart());
      
        String rightnow=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date());
        System.out.println(rightnow+"執行了【"+object+"方法正常執行結束......】"+"【返回結果:"+result+"】"); 
    }
    
    
    
    /**
     * 方法名：log5</br>
     * 詳述：測試 執行后使用的方法</br>
     * 開發人員：http://www.cnblogs.com/liuhongfeng/  </br>
     * 創建時間：2016年4月29日  </br>
     * @param result
     * @return
     * @throws
      */
//    @After(value="execution(com.souvc.controller.*.*(..))")
//    public void log5() {
//        // 記錄日志
//        System.out.println("進入log5()方法");
//    }
    
    
    
}

步驟三：測試

執行測試方法TestEmpController.test1()，結果如下：

無異常的時候:

-->用戶在2016-04-27 11:30:22，執行了com.souvc.controller.EmpController.find()
-->記錄用戶操作信息
查詢員工數據，發送至列表頁面.
-->調用目標組件業務方法后...

有異常的時候：

-->用戶在2016-04-27 11:32:27，執行了com.souvc.controller.EmpController.find()
-->記錄用戶操作信息
查詢員工數據，發送至列表頁面.
-->java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)

1)JoinPoint

java.lang.Object[] getArgs()：獲取連接點方法運行時的入參列表；
Signature getSignature() ：獲取連接點的方法簽名對象；
java.lang.Object getTarget() ：獲取連接點所在的目標對象；
java.lang.Object getThis() ：獲取代理對象本身；

2)ProceedingJoinPoint

ProceedingJoinPoint繼承JoinPoint子接口，它新增了兩個用於執行連接點方法的方法：
java.lang.Object proceed() throws java.lang.Throwable：通過反射執行目標對象的連接點處的方法；
java.lang.Object proceed(java.lang.Object[] args) throws java.lang.Throwable：通過反射執行目標對象連接點處的方法，不過使用新的入參替換原來的入參。

本文作者：souvc

本文出處：http://www.cnblogs.com/liuhongfeng/p/4736947.html

其他的博文可以參考：

3幅圖讓你了解Spring AOP

Spring Aop實例之xml配置

Spring Aop實例之AspectJ注解配置

免責聲明！

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

猜您在找 AOP基礎：注解方式實現前置通知、后置通知、環繞通知、異常通知、最終通知（demo） [原創]java WEB學習筆記106：Spring學習---AOP的通知：前置通知，后置通知，返回通知，異常通知，環繞通知 Spring AOP--返回通知，異常通知和環繞通知 Spring初學之annotation實現AOP前置通知、后置通知、返回通知、異常通知。 AOP基礎：繼承接口方式實現：前置通知、后置通知、異常通知、環繞通知（demo）返回通知、異常通知、環繞通知 spring aop環繞通知 spring aop 環繞通知around和其他通知的區別【Spring實戰】—— 9 AOP環繞通知 spring的幾個通知（前置、后置、環繞、異常、最終）