2. 程式人生 > >spring_AOP前置通知&後置通知&返回通知&環繞通知

spring_AOP前置通知&後置通知&返回通知&環繞通知

阿新 • • 發佈：2018-12-30

Spring AOP

AspectJ：（Java社群裡最完整最流行的AOP框架）

spring自身也有一套AOP框架，但相比較於AspectJ，更推薦AspectJ

在Spring2.0以上版本中，可以使用基於AspectJ註解或基於XML配置的AOP。

基於AspectJ註解：

用AspectJ註解宣告切面
要在Spring中宣告AspectJ切面，只需要在IOC容器中將切面宣告為Bean例項，當在Spring IOC容器中初始化AspectJ切面之後， Spring IOC容器就會為為那些與AspectJ切面相匹配的Bean建立代理。
在AspectJ註解中，切面只是一個帶有@AspectJ註解的Java類
。
通知是標註有某種註解的的簡單的java方法 AspectJ支援5種類型的通知註解： [email protected] 前置通知，在目標方法執行之前執行
[email protected]：後置通知：在目標方法執行之後執行，無論是否發生異常
[email protected]:返回通知，在目標方法返回結果之後執行
[email protected]terThrowing：異常通知，在目標方法丟擲異常之後通知。
[email protected] 環繞通知，圍繞著目標方法執行。

基於AspectJ註解新增前置通知步驟：

1）加入jar包

com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar

commons-logging-1.1.3.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar

2）在配置檔案中加入aop和context的名稱空間

xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"

3）基於註解的方式

   1.在配置檔案里加入如下配置：

	<!-- 配置自動掃描的包  -->
	<context:component-scan base-package="com.wul.spring.aop.impl"></context:component-scan>
	
	<!-- 使AspectJ註解起作用：自動為匹配的類生成代理物件 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
（當Spring IOC 容器偵測到Bean配置檔案中的<aop:aspectj-autoproxy>元素時，會自動與AspectJ切面匹配的Bean建立代理。）

  2.宣告一個切面的類並把橫切關注點程式碼抽象到切面的類中：

I.切面首先是一個IOC中的bean，即加入@Component註釋
II.切面還需要加入@Aspect

  3.在類中宣告各種通知

I.宣告一個方法

II.在方法前加入@Before註解

III.利用方法簽名編寫AspectJ切入點表示式

關於方法簽名編寫的切點表示式：

1.execution (*com.wul.spring.aop.impl.AtithmeticCalculator.*(..))    匹配 ArithmeticCalculator 中宣告的所有方法,    第一個 * 代表任意修飾符及任意返回值. 第二個 * 代表任意方法. .. 匹配任意數量的引數.     若目標類與介面與該切面在同一個包中, 可以省略包名. 2.execution (public * ArithmeticCalculator.*(..))    匹配 ArithmeticCalculator 介面的所有公有方法. 3.execution(* * , *()..)       第一個 *代表匹配任意修飾符及任意返回值, 第二個 * 代表任意類的物件,第三個 *代表任意方法,     引數列表中的.. 匹配任意數量的引數. 4.在 AspectJ 中, 切入點表示式可以通過操作符 &&, ||, ! 結合起來. 
5.可以在通知方法中宣告一個型別為 JoinPoint 的引數. 然後就能訪問連結細節. 如方法名稱和引數值.      public void beforeMethod(JoinPoint joinPoint)

     方法名：String methodName = joinPoint.getSignature().getName();
     引數值：List<Object> args = Arrays.asList(joinPoint.getArgs());

前置通知：

	//宣告該方法是一個前置通知：在目標方法開始之前執行
//	@Before("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.add(int ,int))")
	@Before("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int ,int))")
	public void beforeMethod(JoinPoint joinPoint){
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("The method "+methodName +" begins with "+ args);
	}
後置通知： 
	//後置通知：在目標方法之後(無論是否發生異常)，執行的通知，
	//在後置通知中還不能訪問目標方法執行的結果。執行結果須在返回通知中訪問。
	@After("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int ,int))")
	public void afterMethod(JoinPoint joinPoint){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+" ends");
	
	}

返回通知： 
	//返回通知：在目標方法正常結束執行後的通知
	//返回通知是可以訪問到目標方法的返回值的
	@AfterReturning(value="execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))"
			        , returning = "result")
	public void afterRunningMethod(JoinPoint joinPoint , Object result){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+" ends with the Result "+ result);
	}

異常通知： 
	//在目標方法出現異常時會執行的程式碼，
	//可以訪問到異常物件，且可以指定在出現特定異常時在執行通知程式碼
	//如下面Exception ex，若是指定為NullpointerException ex就不會執行通知程式碼
	@AfterThrowing(value="execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))"
			          , throwing="ex")
	public void afterThrowingMethod(JoinPoint joinPoint,Exception ex){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+"occurs exception:"+ex);
	}
前置，後置，異常通知在動態代理類中實現的話： 
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				String methodName = method.getName();
				//日誌
				System.out.println("The method "+methodName+" begin with "+Arrays.asList(args));
				//執行方法
				Object result = null;
				
				try{
					//前置通知
					 result = method.invoke(target, args);
					//返回通知,可以訪問到方法的返回通知
				}catch(Exception e){
					e.printStackTrace();
					//異常通知:可以訪問到方法出現的異常
				}
				
				//後置通知：因為方法可能出錯，所以訪問不到方法的返回值。
				
				//日誌
				System.out.println("The method "+methodName + " ends with "+result);
				return result;
			}



環繞通知：（類似於動態代理的過程）

package com.wul.spring.aop.impl;

import java.util.Arrays;
import java.util.List;

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;

//把這個類宣告為一個切面：需要把該類放入到IOC容器中，再宣告為一個切面
@Aspect
@Component
public class LogginAspect {
	
	//宣告該方法是一個前置通知：在目標方法開始之前執行
//	@Before("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.add(int ,int))")
	@Before("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int ,int))")
	public void beforeMethod(JoinPoint joinPoint){
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("The method "+methodName +" begins with "+ args);
	}
	
	//後置通知：在目標方法之後(無論是否發生異常)，執行的通知，
	//在後置通知中還不能訪問目標方法執行的結果。執行結果須在返回通知中訪問。
	@After("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int ,int))")
	public void afterMethod(JoinPoint joinPoint){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+" ends");
	
	}
	//返回通知：在目標方法正常結束執行後的通知
	//返回通知是可以訪問到目標方法的返回值的
	@AfterReturning(value="execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))"
			        , returning = "result")
	public void afterRunningMethod(JoinPoint joinPoint , Object result){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+" ends with the Result "+ result);
	}
	
	
	//在目標方法出現異常時會執行的程式碼，
	//可以訪問到異常物件，且可以指定在出現特定異常時在執行通知程式碼
	//如下面Exception ex，若是指定為NullpointerException ex就不會執行通知程式碼
	@AfterThrowing(value="execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))"
			          , throwing="ex")
	public void afterThrowingMethod(JoinPoint joinPoint,Exception ex){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+"occurs exception:"+ex);
	}
	
	//壞繞通知：需要攜帶ProceedingJoinPoint型別的引數
	//環繞通知類似於動態代理的全過程：ProceedingJoinPoint型別的引數可以決定是否執行目標方法
	//且環繞通知必須有返回值，返回值即目標方法的返回值。
	@Around("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))")
	public Object aroundMethod(ProceedingJoinPoint pjd){
		Object result = null;
		String methodName = pjd.getSignature().getName();
		Object args = Arrays.asList(pjd.getArgs());
		//執行目標方法
		try {
			//前置通知
			System.out.println("Arround:The method "+methodName +" begins with "+ args);			
			result = pjd.proceed();
			//後置通知
			System.out.println("Arround:The method "+ methodName+" ends");
		} catch (Throwable e) {
			e.printStackTrace();
			//異常通知
			System.out.println("Arround:The method "+ methodName+"occurs exception:"+e);
			//throw new RuntimeException(e);
			//不丟擲異常的話，異常就被上面抓住，執行下去，返回result，result值為null，轉換為int
		}
		//返回通知
		System.out.println("Arround:The method "+ methodName+" ends with the Result "+ result);
		
		//return 100;
		return result;
	}
	
}
下面給出示例：



AtithmeticCalculator.java

package com.wul.spring.aop.impl;

public interface AtithmeticCalculator {
	
		int add(int i, int j);
		int sub(int i, int j);
		int mul(int i, int j);
		int div(int i, int j);
		
}

AtithmeticCalculatorImpl.java

package com.wul.spring.aop.impl;

import org.springframework.stereotype.Component;

@Component
public class AtithmeticCalculatorImpl implements AtithmeticCalculator {

	@Override
	public int add(int i, int j) {
		int result = i + j;
		return result;
	}

	@Override
	public int sub(int i, int j) {
		int result = i - j;
		return result;
	}

	@Override
	public int mul(int i, int j) {
		int result = i * j;
		return result;
	}

	@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}

}

LogginAspect.java

package com.wul.spring.aop.impl;

import java.util.Arrays;
import java.util.List;

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;

//把這個類宣告為一個切面：需要把該類放入到IOC容器中，再宣告為一個切面
@Aspect
@Component
public class LogginAspect {
	
	//宣告該方法是一個前置通知：在目標方法開始之前執行
//	@Before("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.add(int ,int))")
	@Before("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int ,int))")
	public void beforeMethod(JoinPoint joinPoint){
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("The method "+methodName +" begins with "+ args);
	}
	
	//後置通知：在目標方法之後(無論是否發生異常)，執行的通知，
	//在後置通知中還不能訪問目標方法執行的結果。執行結果須在返回通知中訪問。
	@After("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int ,int))")
	public void afterMethod(JoinPoint joinPoint){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+" ends");
	
	}
	//返回通知：在目標方法正常結束執行後的通知
	//返回通知是可以訪問到目標方法的返回值的
	@AfterReturning(value="execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))"
			        , returning = "result")
	public void afterRunningMethod(JoinPoint joinPoint , Object result){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+" ends with the Result "+ result);
	}
	
	
	//在目標方法出現異常時會執行的程式碼，
	//可以訪問到異常物件，且可以指定在出現特定異常時在執行通知程式碼
	//如下面Exception ex，若是指定為NullpointerException ex就不會執行通知程式碼
	@AfterThrowing(value="execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))"
			          , throwing="ex")
	public void afterThrowingMethod(JoinPoint joinPoint,Exception ex){
		String methodName = joinPoint.getSignature().getName();
		System.out.println("The method "+ methodName+"occurs exception:"+ex);
	}
	
	//壞繞通知：需要攜帶ProceedingJoinPoint型別的引數
	//環繞通知類似於動態代理的全過程：ProceedingJoinPoint型別的引數可以決定是否執行目標方法
	//且環繞通知必須有返回值，返回值即目標方法的返回值。
	@Around("execution(public int com.wul.spring.aop.impl.AtithmeticCalculator.*(int,int))")
	public Object aroundMethod(ProceedingJoinPoint pjd){
		Object result = null;
		String methodName = pjd.getSignature().getName();
		Object args = Arrays.asList(pjd.getArgs());
		//執行目標方法
		try {
			//前置通知
			System.out.println("Arround:The method "+methodName +" begins with "+ args);			
			result = pjd.proceed();
			//後置通知
			System.out.println("Arround:The method "+ methodName+" ends");
		} catch (Throwable e) {
			e.printStackTrace();
			//異常通知
			System.out.println("Arround:The method "+ methodName+"occurs exception:"+e);
			//throw new RuntimeException(e);
			//不丟擲異常的話，異常就被上面抓住，執行下去，返回result，result值為null，轉換為int
		}
		//返回通知
		System.out.println("Arround:The method "+ methodName+" ends with the Result "+ result);
		
		//return 100;
		return result;
	}
	
}

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"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!-- 配置自動掃描的包  -->
	<context:component-scan base-package="com.wul.spring.aop.impl"></context:component-scan>
	
	<!-- 使AspectJ註解起作用：自動為匹配的類生成代理物件 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

Main.java

package com.wul.spring.aop.impl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
	
	public static void main(String[] args) {
		
		//1.建立Spring的IOC容器
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//2.從IOC容器中獲取bean的例項
		AtithmeticCalculator arithmeticCalculator = ctx.getBean(AtithmeticCalculator.class);
		
		//3.使用bean
		int result = arithmeticCalculator.add(3,6);
		System.out.println("result: "+result);
		
	    result = arithmeticCalculator.div(10,5);
		System.out.println("result: "+result);
		
		result = arithmeticCalculator.div(10,0);
	}	
	
}


相關推薦

Spring AOP如何用註解實現前置、後置、返回後通知

首先新建一個Java Project工程，導包、建Package包，建立三個類分別為學生Student、教師Teacher、測試Test類。再建立一個bean.xml的配置檔案。在學生類Student中建立兩個分別為String型別和Integer型別的屬性na

spring_AOP前置通知&後置通知&返回通知&環繞通知

Spring AOP AspectJ：（Java社群裡最完整最流行的AOP框架） spring自身也有一套AOP框架，但相比較於AspectJ，更推薦AspectJ 在Spring2.0以上版本中，可以使用基於AspectJ註解或基於XML配置的AOP。 基於Aspect

AOP的一些東西（事務的傳播特性，前置，後置，環繞，異常 等各種通知）

1、事務的配置 基本的六種事務傳播： 1. PROPAGATION_REQUIRED: 如果存在一個事務，則支援當前事務。如果沒有事務則開啟（常用的配置）2. PROPAGATION_SUPPORTS

9、前置、後置、環繞通知

前置通知 使用@Before 第一種方法：先定義pointcut @Pointcut("execution(* com..*.sleep(..))") public void callSlee

Spring框架——AOP前置、後置、環繞、異常通知

通知型別： 步驟: 1. 定義介面 2. 編寫物件(被代理物件=目標物件) 3. 編寫通知（前置通知目標方法呼叫前呼叫） 4. 在beans.xml檔案配置 4.1 配置 被代理物件=目標物件 4.2 配置通知 4.3 配置代理物件 是 ProxyFac

C++中的前置和後置++

增量 後置 內置 因此 效率 要求 來講 註意 對象 在C++中進行操作符重載的時候，前置++返回的是一個引用。 這就設計到了對於基本變量進行前置操作時候的理解了。 例如，對於int類型變量，在進行前置++的時候，是會將i進行加1，然後返回i的引用。而i++是先創建一個i的

C++過載++ 如何區分“++”過載的前置與後置

來源：http://blog.csdn.net/hemingliang1987/article/details/9204815 在C++中過載單目運算子時，會出現前置還是後置的問題，如++，–等 例如 i++與 ++i 這個時候如何讓編譯器知道是前置還是後置呢？ 其實很簡單，只要在過載操作符的引數中加上

運算子前置++和後置++過載為時鐘類的成員函式

源程式： #include<iostream.h> class Clock //時鐘類宣告 { public: //外部介面 Clock(int NewH=0, int NewM

c++ 前置++與後置++的區別

　　用C++程式設計的都知道，C++提供了一個非常強大的操作符過載機制，利用操作符過載，我們可以為我們自定義的類增加更多非常有用的功能。不過，C++也有限制，就是當我們為自定義的類過載操作符時，過載操作符的含義應該跟內建型別一樣，比如，你不能通過過載+號操作符來實現兩個數相乘的運算，實現需要是兩個數相加的運算

C語言中前置++和後置++的區別

直接上程式碼 #include <stdio.h> int main(int argc, char* argv[]) { int a = 6; printf("%d\n",a++); //輸出為6，返回的是暫存器的值，而不是加後的

C/C++中自增自減的前置和後置區別

       自增自減操作符在程式設計中很常用，都分為分為前置和後置兩種操作符，對於兩者的區別，C++ primer中有著如下說明：        1. 前置操作返回的結果為左值，後置操作返回的是右值，也就是說執行如下的程式碼都會編譯不通過： int i = 0, j

C++回顧之前置++、後置++、不等號!及賦值運算子過載

        運算子過載的主要目的是為了讓類物件能像普通資料型別一樣能夠進行加減乘除，自加自減等操作，非常直觀方便。現在來回顧C++的自加減(分前置與後置)以及不等號非運算子，賦值運算子的過載。         1 ++過載         (1)前置++運算子的過載方式

android Camera 如何判斷當前使用的攝像頭是前置還是後置

轉載自：http://blog.csdn.net/fulinwsuafcie/article/details/8862836 現在 Android 平臺的智慧手機一般都標配有兩顆攝像頭。在 Camera 中都存在攝像頭切換的功能。 並且有一些功能前後置攝像頭上會有所

Spring aop 前置通知、後置通知、返回通知、 異常通知 、後置通知

  Spring AOP定義切面 Ⅰ 首先介紹一下寫Spring Aop思路  一、首先在專案中加入aop所需要的jar aopalliance-1.0.jar aspectjweaver-1.6.11.jar commons-logging-1.1.1.jar sprin

Spring通知（前置通知，後置通知，返回通知，異常通知，環繞通知）

一、前置通知--前置通知:在方法執行之前執行的通知--前置通知使用 @Before 註解, 並將切入點表示式的值作為註解值。/** * 宣告該方法是一個前置通知：在目標方法開始之前執行 */@Before("execution(public int aop.Atithmeti

spring學習 十 schema-based 前置後後置通知

point utf-8 後置 實現接口 測試 運行 jar 需要 圖片 spring 提供了 2 種 AOP 實現方式：（1）Schema-based ，（2）AspectJ Schema-based：每個通知都需要實現接口或類，配置 spring 配置文件時在<a

spring_(17)Spring_後置通知與前置通知

後置通知 後置通知是在連線點完成之後執行的，即連線點返回結果或者丟擲異常的時候，下面的後置通知記錄了方法的終止。 一個切面可以包括一個或者多個通知 例子程式 基本結構 ArithmeticCalculator.java package com.s

Spring 學習（十六）——Spring AOP之前置通知和後置通知

spring aop 1）加入jar包 com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.R

Spring AOP中的前置通知和後置通知詳解

不同版本的spring對AOP的支援有所不同，spring2.0之前，它主要針對不同型別的攔截器使用XML配置檔案通過代理來實現。而spring2.0之後，它可以使用JDK5的註解來完成AOP的實現，

後置通知，返回通知，異常通知，環繞通知

@Aspect @Component public class LoggingAspect { //該方法是一個前置通知：在目標方法開始前執行 @Before("excution(public 返回型別.包名.類名.方法名(int,int))") public voi