SpringAOP03_2

最新推荐文章于 2022-07-08 19:10:28 发布
原创 最新推荐文章于 2022-07-08 19:10:28 发布 · 623 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Spring AOP中的环绕通知，强调其功能强大并能完全控制连接点，包括何时及是否执行。环绕通知必须使用ProceedingJoinPoint作为参数，并通过调用proceed()执行原方法，否则会导致目标方法未执行。还讨论了环绕通知与其他通知的执行顺序，以及如何通过Order调整切面优先级。最后，列举了AOP的常见应用场景，如日志记录、权限验证、安全检查和事务控制。

一、环绕通知

1、环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。
2、对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口，允许控制何时执行，是否执行连接点。
3、在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。
4、注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed();的返回值，否则会出现空指针异常。

环绕通知

@Aspect
@Component
public class LogUtils {
	/**
	 * @throws Throwable 
	 * @Around：环绕	:是Spring中强大的通知；顺序正常
	 * @Around：环绕:动态代理；
	 * 	try{
	 * 			//前置通知
	 * 			method.invoke(obj,args);
	 * 			//返回通知
	 * 	}catch(e){
	 * 			//异常通知
	 *  }finally{
	 * 			//后置通知
	 * 	}
	 * 		
	 * 	四合一通知就是环绕通知；
	 * 	环绕通知中有一个参数：	ProceedingJoinPoint pjp
	 * 
	 *环绕通知：是优先于普通通知执行，执行顺序；
	 */
	@Around("hahaMyPoint()")
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		
		Object[] args = pjp.getArgs();
		String name = pjp.getSignature().getName();
		//args[0] = 100;
		Object proceed = null;
		try {
			//@Before
			System.out.println("【环绕前置通知】【"+name+"方法开始】");
			//就是利用反射调用目标方法即可，就是method.invoke(obj,args)
			proceed = pjp.proceed(args);
			//@AfterReturing
			System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
		} catch (Exception e) {
			//@AfterThrowing
			System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
			//为了让外界能知道这个异常，这个异常一定抛出去
			throw new RuntimeException(e);
		} finally{
			//@After
			System.out.println("【环绕后置通知】【"+name+"】方法结束");
		}
		
		//反射调用后的返回值也一定返回出去，若这里写死了，那么上面的try没有用了，很明显@Around是一个动态代理
		return proceed;
	}
}

二、 环绕通知加上普通通知执行顺序

/**
 * 如何将这个类（切面类）中的这些方法（通知方法）动态的在目标方法运行的各个位置切入
 * @author lfy
 *
 */
@Aspect
@Component
public class LogUtils {
	

	@Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
	public void hahaMyPoint(){};
	


	
	//想在执行目标方法之前运行；写切入点表达式
	//execution(访问权限符  返回值类型  方法签名)
	@Before("hahaMyPoint()")
	public static void logStart(JoinPoint joinPoint){
		//获取到目标方法运行是使用的参数
		Object[] args = joinPoint.getArgs();
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
	

	//想在目标方法正常执行完成之后执行
	@AfterReturning(value="hahaMyPoint()",returning="result")
	public static void logReturn(JoinPoint joinPoint,Object result){
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
	}


	//想在目标方法出现异常的时候执行
	@AfterThrowing(value="hahaMyPoint()",throwing="exception")
	public static void logException(JoinPoint joinPoint,Exception exception) {
		System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
	}

	//想在目标方法结束的时候执行
	@After("hahaMyPoint()")
	private int logEnd(JoinPoint joinPoint) {
		System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
		return 0;
	}
	
	/**
	 * @throws Throwable 
	 * @Around：环绕	:是Spring中强大的通知；
	 * @Around：环绕:动态代理；
	 * 	try{
	 * 			//前置通知
	 * 			method.invoke(obj,args);
	 * 			//返回通知
	 * 	}catch(e){
	 * 			//异常通知
	 *  }finally{
	 * 			//后置通知
	 * 	}
	 * 		
	 * 	四合一通知就是环绕通知；
	 * 	环绕通知中有一个参数：	ProceedingJoinPoint pjp
	 * 
	 *环绕通知：是优先于普通通知执行，执行顺序；
	 *
	 *[普通前置]
	 *{
	 *	try{
	 *		环绕前置
	 *		环绕执行：目标方法执行
	 *		环绕返回
	 *	}catch(){
	 *		环绕出现异常
	 *	}finally{
	 *		环绕后置
	 *	}
	 *}
	 *
	 *
	 *[普通后置]
	 *[普通方法返回/方法异常]
	 *新的顺序：
	 *		（环绕前置---普通前置【这两个没有固定的前后顺序】）----目标方法执行----环绕正常返回/出现异常-----环绕后置----普通后置---普通返回或者异常
	 *注意：	为了让外界能知道这个异常，这个异常一定抛出去
     *      throw new RuntimeException(e);
	 */
	
	@Around("hahaMyPoint()")
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		
		Object[] args = pjp.getArgs();
		String name = pjp.getSignature().getName();
		//args[0] = 100;
		Object proceed = null;
		try {
			//@Before
			System.out.println("【环绕前置通知】【"+name+"方法开始】");
			//就是利用反射调用目标方法即可，就是method.invoke(obj,args)
			proceed = pjp.proceed(args);
			//@AfterReturing
			System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
		} catch (Exception e) {
			//@AfterThrowing
			System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
			//为了让外界能知道这个异常，这个异常一定抛出去
			throw new RuntimeException(e);
		} finally{
			//@After
			System.out.println("【环绕后置通知】【"+name+"】方法结束");
		}
		
		//反射调用后的返回值也一定返回出去
		return proceed;
	}
}

四、多切面运行顺序

切面一

@Aspect
@Component
@Order(2)//使用Order改变切面顺序；数值越小优先级越高,若存在多个切面，先入后出，后入先出 
public class BValidateApsect {
	
	
	@Before("com.czl.utils.LogUtils.hahaMyPoint()")
	public void logStart(JoinPoint joinPoint){
		Object[] args = joinPoint.getArgs();
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[VaApsect-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
	
	@AfterReturning(value="com.czl.utils.LogUtils.hahaMyPoint()",returning="result")
	public void logReturn(JoinPoint joinPoint,Object result){
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[VaApsect-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
	}
	
	@AfterThrowing(value="com.czl.utils.LogUtils.hahaMyPoint()",throwing="exception")
	public void logException(JoinPoint joinPoint,Exception exception) {
		System.out.println("[VaApsect-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
	}

	@After("com.czl.utils.LogUtils.hahaMyPoint()")
	private int logEnd(JoinPoint joinPoint) {
		System.out.println("[VaApsect-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
		return 0;
	}
}

切面二

@Order(1)//使用Order改变切面顺序；数值越小优先级越高,若存在多个切面，先入后出，后入先出 
@Aspect
@Component
public class LogUtils {
	/**
	 * 告诉Spring每个方法都什么时候运行；
	 * try{
	 * 		@Before
	 * 		method.invoke(obj,args);
	 * 		@AfterReturning
	 * }catch(e){
	 * 		@AfterThrowing
	 * }finally{
	 * 		@After
	 * }
	 * 	
	 * 5个通知注解
	 * @Before：在目标方法之前运行；  					 前置通知
	 * @After：在目标方法结束之后						后置通知
	 * @AfterReturning：在目标方法正常返回之后			返回通知
	 * @AfterThrowing：在目标方法抛出异常之后运行			异常通知
	 * @Around：环绕								环绕通知
	 * 
	 * 
	 * 抽取可重用的切入点表达式；
	 * 1、随便声明一个没有实现的返回void的空方法
	 * 2、给方法上标注@Pointcut注解
	 */
	@Pointcut("execution(public int com.czl.impl.MyMathCalculator.*(..))")
	public void hahaMyPoint(){};
	


	
	//想在执行目标方法之前运行；写切入点表达式
	//execution(访问权限符  返回值类型  方法签名)
	@Before("hahaMyPoint()")
	public static void logStart(JoinPoint joinPoint){
		//获取到目标方法运行是使用的参数
		Object[] args = joinPoint.getArgs();
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}

	//想在目标方法正常执行完成之后执行
	@AfterReturning(value="hahaMyPoint()",returning="result")
	public static void logReturn(JoinPoint joinPoint,Object result){
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
	}


	//想在目标方法出现异常的时候执行
	@AfterThrowing(value="hahaMyPoint()",throwing="exception")
	public static void logException(JoinPoint joinPoint,Exception exception) {
		System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
	}

	//想在目标方法结束的时候执行
	@After("hahaMyPoint()")
	private int logEnd(JoinPoint joinPoint) {
		System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
		return 0;
	}
}

执行结果：看类首字母的大小写决定谁先执行，L在前面，所以LogUtils先执行。
使用Order改变切面顺序；数值越小优先级越高,若存在多个切面，先入后出，后入先出

在这里插入图片描述

切面二：加环绕

>切面二
```java
@Order(1)//使用Order改变切面顺序；数值越小优先级越高,若存在多个切面，先入后出，后入先出 
@Aspect
@Component
public class LogUtils {

	@Pointcut("execution(public int com.czl.impl.MyMathCalculator.*(..))")
	public void hahaMyPoint(){};
		
	//想在执行目标方法之前运行；写切入点表达式
	//execution(访问权限符  返回值类型  方法签名)
	@Before("hahaMyPoint()")
	public static void logStart(JoinPoint joinPoint){
		//获取到目标方法运行是使用的参数
		Object[] args = joinPoint.getArgs();
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-前置]【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}

	//想在目标方法正常执行完成之后执行
	@AfterReturning(value="hahaMyPoint()",returning="result")
	public static void logReturn(JoinPoint joinPoint,Object result){
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("[LogUtils-返回]【"+name+"】方法正常执行完成，计算结果是："+result);
	}


	//想在目标方法出现异常的时候执行
	@AfterThrowing(value="hahaMyPoint()",throwing="exception")
	public static void logException(JoinPoint joinPoint,Exception exception) {
		System.out.println("[LogUtils-异常]【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
	}

	//想在目标方法结束的时候执行
	@After("hahaMyPoint()")
	private int logEnd(JoinPoint joinPoint) {
		System.out.println("[LogUtils-后置]【"+joinPoint.getSignature().getName()+"】方法最终结束了");
		return 0;
	}



 	//环绕方法
	@Around("hahaMyPoint()")
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		
		Object[] args = pjp.getArgs();
		String name = pjp.getSignature().getName();
		//args[0] = 100;
		Object proceed = null;
		try {
			//@Before
			System.out.println("【环绕前置通知】【"+name+"方法开始】");
			//就是利用反射调用目标方法即可，就是method.invoke(obj,args)
			proceed = pjp.proceed(args);
			//@AfterReturing
			System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
		} catch (Exception e) {
			//@AfterThrowing
			System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
			//为了让外界能知道这个异常，这个异常一定抛出去
			throw new RuntimeException(e);
		} finally{
			//@After
			System.out.println("【环绕后置通知】【"+name+"】方法结束");
		}
		
		//反射调用后的返回值也一定返回出去
		return proceed;
	}
}

执行结果

在这里插入图片描述

五、AOP使用场景：

1、AOP加日志保存到数据库；
2、AOP做权限验证；
3、AOP做安全检查；
4、AOP做事务控制；

23-使用AOP通知获取原始操作数据
记录java学习日常~
06-21 984
具体来说，JoinPoint 包含了连接点的静态信息，例如方法签名和参数列表，而 ProceedingJoinPoint 则包含了连接点的动态信息，例如方法执行的前后状态和返回值。在上面的代码中，我们在环绕通知中调用 proceed() 方法执行目标方法，并获取其返回值。然后输出返回值到控制台中，并将其返回给调用方。使用 AOP 通知获取原始操作返回值数据，需要使用环绕通知，并在相应的通知中获取目标方法的返回值。使用 AOP 通知获取原始操作异常数据，需要使用异常通知，并在相应的通知中获取抛出的异常信息。
Spring AOP（AOP概念、组成、Spring AOP实现及实现原理）
芯轴的博客
01-12 999
AOP ( Aspect-Oriented Programming :同调用的逻辑（例如事务处理、日志管理、权限控制等）封装抽取成一个可重用的模块，这个模块被命名为"切面"(Aspect)，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性；.Spring AOP 基于动态代理实现, JDK 动态代理是 Java 自带的动态代理实现方式。CGLIB 代理是一个基于字节码操作的代理方式.
aop 踩坑记录
王胖泽的博客
08-19 365
使用环绕通知, 代码上线发现之前409的接口报200了 经排查发现是因为 try { response = joinPoint.proceed(); } catch (Throwable e){ response = handleException(joinPoint, e); } 异常被catch住了, 但是没有用之前的handler处理, 故返回了200 总结: 尽量使用@Before
Spring零散知识
weixin_45931856的博客
07-08 1442
对于一些积累的问题总结
Aop中java.lang.reflect.UndeclaredThrowableException
qq_31564573的博客
12-01 817
在Aop中抛出自定义的异常失败，直接抛出了500， 这种情况下，请检查自定义异常的继承方式，在Aop中只能抛出的异常必须继承RunTimeException或其子类； Exception的测试： 代码： @Around("cut()") public Object FilterUser(ProceedingJoinPoint joinPoint)throws Throwable {...
[转]彻底征服 Spring AOP 之 实战篇
weixin_30315723的博客
11-14 286
Spring AOP 实战 看了上面这么多的理论知识, 不知道大家有没有觉得枯燥哈. 不过不要急, 俗话说理论是实践的基础, 对 Spring AOP 有了基本的理论认识后, 我们来看一下下面几个具体的例子吧.下面的几个例子是我在工作中所遇见的比较常用的 Spring AOP 的使用场景, 我精简了很多有干扰我们学习的注意力的细枝末节, 以力求整个例子的简洁性. 下面几个 Demo 的源码都可...
spring_day03_aop.zip_Who_spring
09-20
标题中的"spring_day03_aop.zip_Who_spring"暗示了本次讨论的主题是关于Spring框架的AOP（面向切面编程）模块。在Spring框架中，AOP是一种强大的工具，用于实现关注点分离，它允许程序员定义横切关注点，如日志记录...
航空公司_公司_考试Spring_数据_03_april_2020
03-02
2. **面向切面编程 (AOP)**：AOP 是 Spring 提供的一种编程范式，用于处理系统中的横切关注点，如日志、事务管理和权限检查等。它允许开发者将这些通用功能抽取出来，作为独立的“切面”进行处理，提高代码的复用性...
03Spring AOP.md
08-16
03Spring AOP.md
03-深入解析SpringAOP原理及源码-146914326.md
最新发布
05-07
在深入探索SpringAOP的原理和源码之前，我们首先要明确AOP究竟是什么。AOP，即面向切面编程（Aspect-Oriented Programming），是一种编程范式，旨在将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，以...
spring 源码解析之 AOP（八）
nandao158的博客
05-01 753
上一篇分享了，spring 中bean实例的循环依赖，今天开始分享解析AOP 源码。 1、首先从源码中AOP 的入口方法开始
切面方法成功执行完之后出现NullPointException-记今天的实现一小时,DeBug一下午
LitRad
11-17 2564
今天,继续写登陆次数验证.本来想切面里面去切登录方法,拿到session,通过session判断用户是否已登录.还是有点图样图森破.Session的获取与创建在response之后就不可以了,会抛出异常.算了,就直接写在doLogin的Controller里面了.的确,只切一个方法,直接在方法里面写逻辑更优.噼里啪啦写完实现之后开始运行项目.点击登录.啪唧.啥反应都没.response里面已经跳到...
AOP环绕通知引起的java.lang.ClassCastException
奋斗吧010
09-14 1053
原来报错的代码： @Aspect @Component public class MyLog { //创建日志对象 Logger logger=Logger.getLogger(MyLog.class); @Pointcut("execution(* *.*.service.Impl.*.*(..))") public void method(){} @Aro...
SpringAOP中的JointPoint和ProceedingJoinPoint使用总结
huluwa10526的博客
12-09 5017
一、Joint Point JointPoint是程序运行过程中可识别的点，这个点可以用来作为AOP切入点。JointPoint对象则包含了和切入相关的很多信息。比如切入点的对象，方法，属性等。我们可以通过反射的方式获取这些点的状态和信息，用于追踪tracing和记录logging应用信息。 二、Pointcut pointcut 是一种程序结构和规则，它用于选取join point并收集这些point的上下文信息。 pointcut通常包含了一系列的Joint Point，我们可以通过pointcut来同
spring总结6——springAOP
诗人密语
12-05 385
springAOP AOP 简介 ​ AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充. ​ AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点. ​ 在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能...
spring学习-3-AOP
liaohong940908的博客
03-01 298
前置通知：在目标方法开始之前执行 @Component @Aspect public class LoginAspect { @Before("execution(public int spring.aop.impl.AtithmeticCaculator.*(..))") public void beforeMethod(JoinPoint joinPoint){
java spring 环绕通知 ProceedingJoinPoint 执行proceed方法的作用是什么
热门推荐
ITCBL
01-26 4万+
java spring 环绕通知 ProceedingJoinPoint 执行proceed方法的作用是什么 ? 环绕通知 ProceedingJoinPoint执行proceed方法的作用是让目标方法执行，这也是环绕通知和前置、后置通知方法的一个最大区别。 简单理解，环绕通知=前置+目标方法执行+后置通知，proceed方法就是用于启动目标方法执行的. ...
Spring：AOP（四）注解方式实现AOP
熊诗言的博客
12-08 514
配置文件中     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:ao
掌握SpringAOP：动态代理与配置示例解析
学习者在查看day_03.rar文件时，可以对照着Spring AOP的官方文档，对示例代码进行逐步分析，掌握如何通过不同方式实现AOP编程。此外，还可以进一步学习AOP的高级特性，例如使用切点表达式来精确定义切点，以及自定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值