AOP五种通知

最新推荐文章于 2025-02-15 02:04:29 发布
最新推荐文章于 2025-02-15 02:04:29 发布
阅读量265 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring开发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shuizhongyue_/article/details/84794223

五种通知

 使用AspectJ注解声明切面

1）需要在spring IoC容器中将AspectJ切面声明为bean实例。

当Spring IOC容器初始化AspectJ切面后，spring IOC容器会为

AspectJ切面匹配的bean创建代理

2）在AspectJ注解中，切面是一个带有@Aspect注解的java类

3）通知是标识某种注解的简单Java方法

5中类型的通知注解

@Before前置通知，在方法执行之前执行

@After后置通知，在方法执行之后执行

@AfterRunning返回通知，在方法返回结果后执行

@AfterThrowing异常通知，在方法抛出异常之后

@Around环绕通知，围绕方法执行

4）使用@Order标识切面优先级，值越小优先级越高

 

依赖的jar包

  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-aop</artifactId>
  		<version>${org.spring.version}</version>
  	</dependency>
  	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.7.4</version>
	</dependency>
	<dependency>
		<groupId>aopalliance</groupId>
		<artifactId>aopalliance</artifactId>
		<version>1.0</version>
	</dependency>

 

 

LoggingAspect.java

package com.hous.math;

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

import javax.management.RuntimeErrorException;

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;

import com.mchange.v1.util.ArrayUtils;

/**
 * 1.吧该类放到容器中 2.声明为一个切面
 * 3.@Order切面优先级，值越小优先级越高
 */
@Order(2)
@Aspect
@Component
public class LoggingAspect {
	
	/**
	 * 声明前置通知，在方法执行之前执行
	 * @param joinPoint
	 */
	@Before("execution(* com.hous.math.*.*(..))")
	public void beforeMethod(JoinPoint joinPoint) {
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("the method " + methodName + " begin with " + args);
	}
	
	/**
	 * 后置通知，在目标方法执行后执行的通知（无论其是否发生异常）
	 * 后置通知不能访问目标方法执行的结果
	 * @param joinPoint
	 */
	@After("execution(* com.hous.math.*.*(..))")
	public void afterMethod(JoinPoint joinPoint) {
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("the method " + methodName + " end with " + args);
	}
	
	/**
	 * 在方法正常执行结束执行的通知
	 * 可以访问到方法的返回值
	 * @param joinPoint
	 * @param result
	 */
	@AfterReturning(value="execution(* com.hous.math.*.*(..))",
			returning="result")
	public void afterReturning(JoinPoint joinPoint, Object result) {
		String methodName = joinPoint.getSignature().getName();
		System.out.println("the method " + methodName + " end with result " + result);
	}
	
	/**
	 * 在目标方法发生异常执行的代码
	 * 可以访问到异常对象，可以规定在某些特定异常执行
	 * @param joinPoint
	 * @param e
	 */
	@AfterThrowing(value="execution(* com.hous.math.*.*(..))",
			throwing="e")
	public void afterThrowing(JoinPoint joinPoint, ArithmeticException e) {
		String methodName = joinPoint.getSignature().getName();
		System.out.println("the method " + methodName + " occurs exception " + e);
	}
	
	/**
	 * @param pjd
	 * @return
	 */
	@Around("execution(* com.hous.math.*.*(..))")
	public Object aroundMethod(ProceedingJoinPoint pjd) {
		
		Object result = null;
		String methodName = pjd.getSignature().getName();
		
		try {
			//前置通知
			System.out.println("the methods " + methodName + " begins with" + Arrays.asList(pjd.getArgs()));
			//执行目标方法
			result = pjd.proceed();
			//后置通知
			System.out.println("the methods " + methodName + " ends with result " + result);
		} catch (Throwable e) {
			//异常通知
			System.out.println("the methods " + methodName + " occurs exception" + e);
			throw new RuntimeException(e);
		}
		//后置通知
		System.out.println("the methods " + methodName + " ends");
		
		return result;
	}
	
}

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:p="http://www.springframework.org/schema/p"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
	
	<context:component-scan base-package="com.hous.math">
	</context:component-scan>
	
	<!-- 为@Aspect标记，自动为匹配的类生成代理对象 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	
</beans>

 重用切入点表达式

定义一个方法，声明切入点表达式。该方法不需要添加其他代码

在不同包下的引用需要加上包路径com.hous.LoggingAspect.declareJoinPointExpression()就这样

 

 

package com.hous.math;

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

import javax.management.RuntimeErrorException;

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.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import com.mchange.v1.util.ArrayUtils;

/**
 * 1.吧该类放到容器中 2.声明为一个切面
 * @Order切面优先级，值越小优先级越高
 */
@Order(2)
@Aspect
@Component
public class LoggingAspect {
	
	/**
	 * 定义一个方法，声明切入点表达式。该方法不需要添加其他代码
	 */
	@Pointcut("execution(* com.hous.math.*.*(..))")
	public void declareJoinPointExpression() {}
	
	/**
	 * 声明前置通知，在方法执行之前执行
	 * @param joinPoint
	 */
	@Before("declareJoinPointExpression()")
	public void beforeMethod(JoinPoint joinPoint) {
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("the method " + methodName + " begin with " + args);
	}
	
	/**
	 * 后置通知，在目标方法执行后执行的通知（无论其是否发生异常）
	 * 后置通知不能访问目标方法执行的结果
	 * @param joinPoint
	 */
	@After("declareJoinPointExpression()")
	public void afterMethod(JoinPoint joinPoint) {
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		System.out.println("the method " + methodName + " end with " + args);
	}
	
	/**
	 * 在方法正常执行结束执行的通知
	 * 可以访问到方法的返回值
	 * @param joinPoint
	 * @param result
	 */
	@AfterReturning(value="declareJoinPointExpression()",
			returning="result")
	public void afterReturning(JoinPoint joinPoint, Object result) {
		String methodName = joinPoint.getSignature().getName();
		System.out.println("the method " + methodName + " end with result " + result);
	}
	
	/**
	 * 在目标方法发生异常执行的代码
	 * 可以访问到异常对象，可以规定在某些特定异常执行
	 * @param joinPoint
	 * @param e
	 */
	@AfterThrowing(value="declareJoinPointExpression()",
			throwing="e")
	public void afterThrowing(JoinPoint joinPoint, ArithmeticException e) {
		String methodName = joinPoint.getSignature().getName();
		System.out.println("the method " + methodName + " occurs exception " + e);
	}
	
	/**
	 * @param pjd
	 * @return
	 */
	@Around("declareJoinPointExpression()")
	public Object aroundMethod(ProceedingJoinPoint pjd) {
		
		Object result = null;
		String methodName = pjd.getSignature().getName();
		
		try {
			//前置通知
			System.out.println("the methods " + methodName + " begins with" + Arrays.asList(pjd.getArgs()));
			//执行目标方法
			result = pjd.proceed();
			//后置通知
			System.out.println("the methods " + methodName + " ends with result " + result);
		} catch (Throwable e) {
			//异常通知
			System.out.println("the methods " + methodName + " occurs exception" + e);
			throw new RuntimeException(e);
		}
		//后置通知
		System.out.println("the methods " + methodName + " ends");
		
		return result;
	}
	
}
 使用配置文件方式配置AOP
<?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:p="http://www.springframework.org/schema/p"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
	
	<context:component-scan base-package="com.hous.math">
	</context:component-scan>
	
	<!-- 配置AOP -->
	<aop:config>
		<!-- 配置切点表达式 -->
		<aop:pointcut expression="execution(* com.hous.math.*.*(..))" 
			id="loggingPointcut"/>
		<!-- 配置切面及通知 -->
		<aop:aspect ref="loggingAspect2" order="1">
			<!-- 
			<aop:before method="beforeMethod" pointcut-ref="loggingPointcut" />
			<aop:after method="afterMethod" pointcut-ref="loggingPointcut"/>
			<aop:after-throwing method="afterThrowing" pointcut-ref="loggingPointcut" throwing="e"/>
			<aop:after-returning method="afterReturning" pointcut-ref="loggingPointcut" returning="result"/>
		 	-->
			<aop:around method="aroundMethod" pointcut-ref="loggingPointcut"/>
		</aop:aspect>
	</aop:config>
	
</beans>
 

 

Spring AOP的5种通知类型
流楚丶格念的博客
07-24 6272
AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。编写通知类，我们使用5种通知类型分别配置update与save方法上。接下来我们将save中的除0操作取消注释。编写配置类，开启切面编程配置。再运行，发现运行异常通知。.........
AOP-简介五种通知
qq_41341288的博客
07-05 242
首先随便写个方法，index静态变量的作用是便于验证抛异常情况。 @RestController public class indexController { private static int index =1; @RequestMapping("/index") public String index(String name,String age) throw...
五种通知方式来实现aop
weixin_46009736的博客
02-28 317
标题 1.前置通知，在业务方法之前执行 [Before advice]。 2.后置通知，在业务防止后执行 3.环绕通知，同时在业务方法的前后执行 [Around advice] 4.最终通知，可以拿到业务的返回值 5.异常通知，可以捕获业务方法中的异常对象 [After throwing advice] **加粗样式**注意：如果同时配置来所有的通知方式，则执行顺序依次为: befor...
AOP的五大通知
m0_60870773的博客
08-20 1351
@Before称为前置通知，在目标方法执行之前执行，可以有参数也可以没有参数 可以指定连接点的参数，通过该参数可以获取目标对象和目标方法等相关信息，如果通知有多个参数时连接点参数必须放到第一个 2.@AfterReturning后置通知，在目标方法结束之后执行 3.环绕通知 被@Around修饰的通知就是环绕通知 //在被增i强的方法前后执行 //专门用于调用目标方法 ...
AOP的5种类通知类型
weixin_44249746的博客
03-18 644
(5)环绕通知,环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。(3)返回后通知,追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加。(4)抛出异常后通知,追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加。(1)前置通知，追加功能到方法执行前,类似于在代码1或者代码2添加内容。
Spring AOP（5种通知类型）
kimi
03-08 4882
Spring AOP（5种通知类型）
Spring AOP的五种通知方式代码实例
08-25
Spring AOP五种通知方式代码实例详解 Spring AOP是一种非常强大的面向切面编程技术，它可以将横切关注点从业务逻辑中分离出来，从而提高系统的灵活性和可维护性。在Spring AOP中，有五种通知方式：前置通知、后置...
Spring aop 五种通知类型
最新发布
m0_67392010的博客
02-15 615
其他通知，只能做记录工作，不能做处理，所以执行顺序其实对整个程序影响不大，没有必要太深究。五大通知类型中，环绕通知功能最为强大，因为环绕通知，可以控制目标方法是否执行。Spring 版本不一样，通知执行顺序可能也会存在差异。如果需要记录异常信息，使用异常通知。
Spring AOP五种通知类型详解及实战应用
本文将深入浅出地探讨Spring AOP（面向切面编程）中的五种核心通知类型，这些通知在程序执行的不同阶段发挥着关键作用，以提高代码的可维护性和模块化。首先，让我们了解这五种通知类型： 1. **前置通知（Before ...
Spring AOP的五种通知
Fighting_mjtao的博客
10-31 319
package cn.sdut.aop; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; i...
Aop advice五种通知方式：
qingcyb的博客
07-18 887
@Before：前置通知，在调用目标方法之前执行通知定义的任务 @After：后置通知，在目标方法执行结束后，无论执行结果如何，都要执行通知定义的任务。 @AfterReturning：返回通知，在目标方法执行结束后，如果执行成功，则执行通知定义的任务。 @AfterThrowing：异常通知，如果目标方法执行过程中抛出异常，则执行通知定义的任务。 @Around：环绕通知，在目标方法执行前和执行后，都需要执行通知定义的任务。 ...
spring-aop五种通知
xiaosuanmiao123的博客
09-11 237
@Before() 前置通知：声明该方法为方法执行之前的通知 //声明该方法是一个前置通知 @Before("execution(public int com.spring.spring.impl.AitihmeticCalculator.add(int,int))") public void beforeMethod(JoinPoint joinPoint){ ...
SpringAop配置版 - 五种通知
stone的博客
02-02 387
前面记录了基于注解版的aop配置，现在记录一下基于xml配置的aop （注解版aop链接地址） 基于xml版的aop配置步骤 导入jar包 或者maven依赖 将目标对象和切面类加入到ioc容器当中 告诉spring那个是切面类 在切面类中配置五种通知，并且配置五种通知的运行时机（切入点表达式） 项目架构 Operation 类 （业务类） public interface Operati...
AOP五大通知注解详解
wwwwwww31311的博客
02-03 5899
1.前置通知 在目标方法执行之前执行执行的通知。 前置通知方法，可以没有参数，也可以额外接收一个JoinPoint，Spring会自动将该对象传入，代表当前的连接点，通过该对象可以获取目标对象 和 目标方法相关的信息。 注意，如果接收JoinPoint，必须保证其为方法的第一个参数，否则报错。 2.后置通知 在目标方法执行之后执行的通知。 在后置通知中也可以选择性的接收一个JoinPoint来获取连接点的额外信息，但是这个参数必须处在参数列表的第一个。 在后置通知中，还可以通过配置获取返回值 3.异常通知
通知的5种类型
weixin_43750327的博客
12-25 3623
前通知：方法执行之前，method：增强执行的方法 后通知：方法执行之后，又称最终通知，无论如何都执行 返回后通知：成功返回后，有异常时不执行 异常通知：发生异常后，只有异常抛出时才执行，不能try…catch异常 环绕通知：在方法的执行前后进行一些增强，在方法的执行前后进行一些增强 =前通知+返回后通知 ...
2021-12-28 Spring day4（动态代理，Aop五种通知）
kkzzjx
12-28 366
一、Aop Aspect Oriented Programming ，面向切面编程，这是对面向对象思想的一种补充。 面向切面编程，就是在程序运行时，不改变程序源码的情况下，动态的增强方法的功能，常见的使用场景非常多： 日志 事务 --公共代码抽取出来 数据库操作 … 以上操作有很多模板化的代码 AOP常见概念 切点：要添加代码的地方，称作切点 通知（增强）：通知就是向切点动态添加的代码 切面：切点+通知 连接点：切点的定义 AOP实现 Aop实际上是基于Java的动态代理来实现的 Java中的动态代理有
什么是通知？有哪五种类型的通知？
qqyang_的博客
09-25 1301
通知是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码段。 Spring切面可以应用五种类型的通知： a、before：前置通知，在一个方法执行前被调用。 b、after: 在方法执行之后调用的通知，无论方法执行是否成功。 c、after-returning: 仅当方法成功完成后执行的通知。 d、after-throwing: 在方法抛出异常退出时执行的通知。 e、around: 在方法执行之前和之后调用的通知。 ...
【Spring框架】Aop的六个常用术语+五种通知类型的解析+实例测试
Zhou_LC的博客
01-23 1706
文章目录一、AOP常用术语连接点（Joinpoint）切点（Pointcut）通知（Advice)切面（Aspect）引入（Introduction）织入（Weaving）二、解析五种通知类型【前言】前置通知后置通知返回通知异常通知环绕通知三、实例测试1.项目结构2.测试用的部分核心代码3.运行结果附：XML配置方式 一、AOP常用术语 （术语中部分内容参考自《Spring实战》（第四版） 连接点（Joinpoint） 简述：所有可以定义切点的“地方”，或者说是所有可以去添加增强代码的“地方”。 详述：是在
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值