AOP-常用的通知

类型；

前置通知，@Before()

最终通知，@After()，无论有异常是否都会执行，方法后执行

后置通知，@AfterReturning（），返回结果之后执行

环绕通知，@Around()，可以在方法前后执行

异常通知，@AfterThrowing(),有异常不执行，也称返回通知,返回结果后执行

@AfterReturning表示方法返回结果之后增强,@AfterThrowing表示异常通知。

使用@AfterReturning和@AfterThrowing注解可指定如下四个属性，一般使用前三个。

pointcut/value:这两个属性的作用是一样的，它们都属于指定切入点对应的切入表达式。一样既可以是已有的切入点，也可直接定义切入点表达式。当指定了pointcut属性值后，value属性值将会被覆盖。
returing:该属性指定一个形参名，用于表示Advice方法中可定义与此同名的形参，该形参可用于访问目标方法的返回值。除此之外，在Advice方法中定义该形参（代表目标方法的返回值）时指定的类型，会限制目标方法必须返回指定类型的值或没有返回值。
argNames:该属性指传入的参数，参数位置可以改变。

throwing：用于@AfterThrowing注解，用法和returing相同。

package com.springaop.demo.annotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class UserProxy {

    /**
     * execution表达式的增强方法
     */
    @Before(value = "execution( * com.springaop.demo.annotation.User.*(..))")
    public void Before() {
        System.out.println("aop--before,,,");
    }

    /**
     * 增强方法
     *
     * @Pointcut,@Before,@After 可以省略value属性简化表达式
     */
    @Pointcut("execution(* com.springaop.demo.annotation.User.*(..))")
    public void logging() {
        System.out.println("实际增强的方法");
    }

    /**
     * @Before,@After 可以定义已有的切入点，也可以是定义新的切入表达式
     */
    @Before(value = "logging()")
    public void addBefore() {
        System.out.println("aop--logging--before,,");
    }


    @After(value = "execution(* com.springaop.demo.annotation.User.*(..))")
    public void after() {
        System.out.println("aop--logging--after,,,");
    }

    /**
     * pointcut  标识一个已有的切入点、
     * value     直接定义切入点        作用是相同的
     *
     * @AfterReturning,@AfterThrowing pointcut, value属性可以省略，若都存在pointcut有效
     * 使用returning="a" 或者arg 将返回值或者参数传到切面增强方法里面
     */
    @AfterReturning(pointcut = "logging()",
            value = "execution(* com.springaop.demo.annotation.User.*(..))",
            returning = "re")
    public void afterReturning(String re) {
        System.out.println("aop--logging-afterReturning---" + re);
    }

    @AfterReturning(pointcut = "logging() && args(a,b)", argNames = "a,b")
    public void afterArgs1(String a, String b) {
        System.out.println("aop--logging-afterReturning---" + a + "--" + b);
    }

    @AfterReturning(pointcut = "logging() && args(a,b)", argNames = "b,a")
    public void afterArgs2(String b, String a) {
        System.out.println("aop--logging-afterReturning---" + b + "--" + a);
    }

    @AfterThrowing(pointcut = "logging()", throwing = "ex")
    public void afterThrowing(RuntimeException ex) {
        System.out.println("aop--logging--afterThrowing" + ex.getMessage());
    }

@Around("logging()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("around 之前,,,");
    Object result = joinPoint.proceed();
    System.out.println("around 之后,,,");
    return result;
}
}

注意；在around方法的返回和被增强方法的返回值一样，设置为Object