SpringAOP 通知(advice)

@Aspect
@Order(1)
public class AopOne {

    /**
     * 目标方法执行之前
     * @param joinPoint
     */
    @Before("execution(* com.gary.operation.*.*(..))")
    public void befor(JoinPoint joinPoint) {
　　　　  MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();  
        System.out.println("AopOne.befor()");
    }

    /**
     * 目标方法执行以后 无论是否出现异常 相当于finally语句块
     * 该方法优先于@AfterReturning
     * @param joinPoint
     */
    @After("execution(* com.gary.operation.*.*(..))")
    public void after(JoinPoint joinPoint) {
        System.out.println("AopOne.after()");
    }

    /**
     * 方法返回以后 没有出现异常的情况
     */
    @AfterReturning(pointcut="execution(* com.gary.operation.*.*(..))", returning="returnVal")
    public void afterReturning(JoinPoint joinPoint,Student returnVal) {
        System.out.println("AopOne.afterReturning()" + returnVal.getName());
    }

    /**
     * 方法抛出异常时执行
     * @param joinPoint
     */
    @AfterThrowing(pointcut="execution(* com.gary.operation.*.*(..))", throwing="throwable")
    public void afterThrowing(JoinPoint joinPoint, Throwable throwable) {
        System.out.println("AopOne.afterThrowing()" + throwable.getMessage());
    }

    /**
     * 环绕执行 可以自由控制目标方法
     * @param proceedingJoinPoint
     * @return
     */
    //@Around("execution(* com.gary.operation.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) {
        Object result = null;
        try {
            System.out.println("AopOne.around()-begin");
            result = proceedingJoinPoint.proceed();
            System.out.println("AopOne.around()-end");
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return result;
    }

}

1、概念术语　　

　　  在开始之前，需要理解Spring aop 的一些基本的概念术语(总结的个人理解，并非Spring官方定义)：

　　切面(aspect)：用来切插业务方法的类。

　　连接点(joinpoint)：是切面类和业务类的连接点，其实就是封装了业务方法的一些基本属性，作为通知的参数来解析。

　　通知(advice)：在切面类中，声明对业务方法做额外处理的方法。

　　切入点(pointcut)：业务类中指定的方法，作为切面切入的点。其实就是指定某个方法作为切面切的地方。

　　目标对象(target object)：被代理对象。

　　AOP代理(aop proxy)：代理对象。

　　通知：

　　前置通知(before advice)：在切入点之前执行。

　　后置通知(after advice): 相当于finally语句块,无论是否出现异常都执行

　　后置通知(after returning advice)：在切入点执行完成后，执行通知。(出现异常不执行)

　　环绕通知(around advice)：包围切入点，调用方法前后完成自定义行为。

　　异常通知(after throwing advice)：在切入点抛出异常后，执行通知。

2、常用表达式总结

1、任何一个目标对象声明的类型有一个 @Transactional 注解的连接点

@Pointcut("@within(org.springframework.transaction.annotation.Transactional)")

2、任何一个执行的方法有一个 @Transactional 注解的连接点

@Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")

3、任何一个只接受一个参数，并且运行时所传入的参数是java.lang.String接口的连接点

@Pointcut("args(java.lang.String)")

4、任何一个在名为'tradeService'的Spring bean之上的连接点

@Pointcut("bean(UserDao)")

任何一个在名字匹配通配符表达式'*Service'的Spring bean之上的连接点

@Pointcut("bean(*Dao)")

5、组合使用 && 并且的意思。 即俩个条件都需要满足。

@Before("aPointcut() && args(java.lang.String)")

6、组合使用并且接收参数

    @Before("aPointcut() && args(s)")
    public void beforeAdvice(String s) {
        System.out.println("before advice is executed!" + s);
    }

7、组合使用接收参数和注解

     @Before("aPointcut() && args(s) && @annotation(tx)")
     public void beforeAdvice(String s, Transactional tx) {
         System.out.println("before advice is executed!" + tx);
     }

8、组合使用接收注解

 　　 @Before(value="execution(* com.gary.operation.demo.proxy.*.*(..)) && @annotation(tx)")
     public void beforeAdvice(Transactional tx) {
         System.out.println("before advice is executed!" + tx);
     }