Spring AOP中5大通知注解的使用

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(){
    
    }
}