SpringAop中的五种常见的通知的注解
AOP五大通知注解:
@Before 前置通知,在方法执行之前执行
@After 后置通知,在方法执行之后执行(无论是否发生异常)还不能访问目标方法执行的结果
@AfterRunning 返回通知,在方法正常结束后 返回结果之后执行 可以访问方法的返回值
@AfterThrowing 异常通知,在方法抛出异常之后
@Around 环绕通知,围绕着方法执行
前言
如果要使用SpringAOP的功能,必须要添加一个@EnableAspectJAutoProxy注解,有了这个注解才能支持@Aspect等相关的一系列AOP注解的功能,这个注解就相当于在传统的xml配置文件中添加 aop:aspectj-autoproxy一样
@ComponentScan("com.buba")
@Configuration
@EnableAspectJAutoProxy
public class CoreConfig {
}
@Before: 前置通知注解
在方法执行之前执行
定义方法,方法是实现切面功能的。
方法的定义要求:
1.公共方法 public
2.方法没有返回值
3.方法名称自定义
4.方法可以有参数,也可以没有参数。
如果有参数,参数不是自定义的,有几个参数类型可以使用。
属性:value ,是切入点表达式,表示切面的功能执行的位置。
位置:在方法的上面
特点:
1.在目标方法之前先执行的
2.不会改变目标方法的执行结果
3.不会影响目标方法的执行。
- 指定通知方法中的参数 : JoinPoint
- JoinPoint:业务方法,要加入切面功能的业务方法
- 作用是:可以在通知方法中获取方法执行时的信息, 例如方法名称, 方法的实参。
- 如果你的切面功能中需要用到方法的信息,就加入JoinPoint.
- 这个JoinPoint参数的值是由框架赋予, 必须是第一个位置的参数
@Before("execution(* com.buba.*.*.*(..))")
public void beforeMethod(JoinPoint joinpoint){
String methodName = joinpoint.getSignature().getName();
List<Object> list = Arrays.asList(joinpoint.getArgs());
System.out.println("方法:"+methodName+" 参数是"+list);
}
@AfterReturning:返回通知
在方法正常结束后 返回结果之后执行 可以访问方法的返回值
后置通知定义方法,方法是实现切面功能的。
方法的定义要求:
1.公共方法 public
2.方法没有返回值
3.方法名称自定义
4.方法有参数的,推荐是Object ,参数名自定义
属性:
位置:在方法定义的上面
1.value 切入点表达式
2.returning 自定义的变量,表示目标方法的返回值的。
自定义变量名必须和通知方法的形参名一样。
特点:
1.在目标方法之后执行的。
2. 能够获取到目标方法的返回值,可以根据这个返回值做不同的处理功能
Object res = doOther();
3. 可以修改这个返回值
后置通知的执行
Object res = doOther();
参数传递: 传值, 传引用
myAfterReturing(res);
System.out.println(“res=”+res)
@AfterReturning("execution(* com.buba.*.*.*(..))",
returning = "res")
public void myAfterReturing( JoinPoint jp ,Object res ){
// Object res:是目标方法执行后的返回值,根据返回值做你的切面的功能处理
System.out.println("后置通知:方法的定义"+ jp.getSignature());
System.out.println("后置通知:在目标方法之后执行的,获取的返回值是:"+res);
if(res.equals("abcd")){
//做一些功能
} else{
//做其它功能
}
}
@Around: 环绕通知
围绕着方法执行
环绕通知方法的定义格式
1.public
2.必须有一个返回值,推荐使用Object
3.方法名称自定义
4.方法有参数,固定的参数 ProceedingJoinPoint *
属性:value 切入点表达式
位置:在方法的定义什么
特点:
1.它是功能最强的通知
2.在目标方法的前和后都能增强功能。
3.控制目标方法是否被调用执行
4.修改原来的目标方法的执行结果。 影响最后的调用结果
环绕通知,等同于jdk动态代理的,InvocationHandler接口
参数: ProceedingJoinPoint 就等同于 Method
作用:执行目标方法的
返回值: 就是目标方法的执行结果,可以被修改。
环绕通知: 经常做事务, 在目标方法之前开启事务,执行目标方法, 在目标方法之后提交事务
@Around("execution(* com.buba.*.*.*(..))")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
String name = "";
//获取第一个参数值
Object args [] = pjp.getArgs();
if( args!= null && args.length > 1){
Object arg= args[0];
name =(String)arg;
}
//实现环绕通知
Object result = null;
System.out.println("环绕通知:在目标方法之前,输出时间:"+ new Date());
//1.目标方法调用
if( "zhangsan".equals(name)){
//符合条件,调用目标方法
result = pjp.proceed(); //method.invoke(); Object result = doFirst();
}
System.out.println("环绕通知:在目标方法之后,提交事务");
//2.在目标方法的前或者后加入功能
//修改目标方法的执行结果, 影响方法最后的调用结果
if( result != null){
result = "Hello AspectJ AOP";
}
//返回目标方法的执行结果
return result;
}
@AfterThrowing:异常通知
在方法抛出异常之后执行
异常通知方法的定义格式
1.public
2.没有返回值
3.方法名称自定义
4.方法有个一个Exception, 如果还有是JoinPoint,
属性:
1. value 切入点表达式
2. throwinng 自定义的变量,表示目标方法抛出的异常对象。
变量名必须和方法的参数名一样
特点:
1. 在目标方法抛出异常时执行的
2. 可以做异常的监控程序, 监控目标方法执行时是不是有异常。
如果有异常,可以发送邮件,短信进行通知
执行就是:
try{
SomeServiceImpl.doSecond(..)
}catch(Exception e){
myAfterThrowing(e);
}
@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",
throwing = "ex")
public void myAfterThrowing(Exception ex) {
System.out.println("异常通知:方法发生异常时,执行:"+ex.getMessage());
//发送邮件,短信,通知开发人员
}
@After :后置通知
在方法执行之后执行(无论是否发生异常)还不能访问目标方法执行的结果:
最终通知方法的定义格式
1.public
2.没有返回值
3.方法名称自定义
4.方法没有参数, 如果还有是JoinPoint
属性: value 切入点表达式
位置: 在方法的上面
特点:
1.总是会执行
2.在目标方法之后执行的
try{
SomeServiceImpl.doThird(..)
}catch(Exception e){
}finally{
myAfter()
}
@After("execution(* com.buba.*.*.*(..))")
public void myAfter(){
System.out.println("执行最终通知,总是会被执行的代码");
//一般做资源清除工作的。
}
依赖包:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.19</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.19</version>
</dependency>
@Aspect
@Component
public class MyAspect {
@Before("execution(* com.buba.*.*.*(..))")
public void beforeMethod(JoinPoint joinpoint){
}
@AfterReturning("execution(* com.buba.*.*.*(..))",returning = "res")
public void myAfterReturing( JoinPoint jp ,Object res ){
}
@Around("execution(* com.buba.*.*.*(..))")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
}
@AfterThrowing(value = "execution(* com.buba.*.*.*(..))",throwing = "ex")
public void myAfterThrowing(Exception ex) {
}
@After("execution(* com.buba.*.*.*(..))")
public void myAfter(){
}
}