SpringAOP 前置通知、后置通知

AspectJ：Java社区中最完整、最流行的AOP框架。

在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。

在Spring中2启用AspectJ注解支持：

1、要在 Spring应用中使用AspectJ注解，需要添加spring-aspect、aspectj-weaver、aopalliance依赖

2、将aop Schema添加到<beans>根元素

3、要在SpringIOC容器中启用AspectJ注解支持，只要在Bean配置文件中定义一个空的XML元素：<aop:aspectj-autoproxy>

4、在Spring IOC容器侦测到Bean配置文件中的<aop:aspectj-autoproxy>元素时，会自动与AspectJ切面匹配的Bean创建代理。

一、基于注解的方式

1、依赖

2、在配置中加入aop的命名空间

3、基于注解的方式：

①在配置文件中加入：<aop:aspectj-autoproxy>

配置文件：

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置自动扫描的包-->
    <context:component-scan base-package="aopImpl"/>

    <!--使AspectJ注解起作用：自动为匹配的类生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

②把横切关注点的代码抽象到切面的类中

切面首先是一个IOC容器中的Bean，即加入@Component注解

切面还需要加入@AspectJ注解

③在类中声明各种通知：

1、声明一个方法

2、在方法前加入通知

@AspectJ支持的5中通知：

—@Before：前置通知在方法执行前执行

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

—@AfterReturning：返回通知，在方法返回结果之后执行

—@AfterThrowing：异常通知，在方法抛出异常后执行

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

④我们可以在通知方法中声明一个类型为JoinPoint参数，然后就能访问链接细节，如方法名称和参数值

切面类：

package aopImpl;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

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

/**
 * 把这个类声明为一个切面:
 * 1、需要把该类放入到容器中（就是加上@Component注解）
 * 2、再声明为一个切面（加上@AspectJ注解）
 *
 * @author chenpeng
 * @date 2018/6/3 23:20
 */
@Aspect
@Component
public class LoggingAspect {

    //声明该方法为一个前置通知:在目标方法开始之前执行
    //execution中是AspectJ表达式
    @Before(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("beforeMethod "+methodName+" and "+args);
    }
}

在使用的时候报错：因为动态代理不能用接口的实现类来转换Proxy的实现类，它们是同级，应该用共同的接口来转换。

改为这样：

import aopImpl.ArithmeticCalculator;
import aopImpl.ArithmeticCalculatorImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author chenpeng
 * @date 2018/6/3 23:16
 */
public class aopImplTest {
    public static void main(String[] args) {
        //1、创建SpringIOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("aopImpl.xml");
        //2、从IOC容器中国获取Bean的实例
        ArithmeticCalculator arithmeticCalculator = (ArithmeticCalculator) context.getBean("ArithmeticCalculatorImpl");
        //3、使用Bean
        int result = arithmeticCalculator.add(3,6);
        System.out.println(result);
    }
}

其他通知：

package aopImpl;

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

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

/**
 * 把这个类声明为一个切面:
 * 1、需要把该类放入到容器中（就是加上@Component注解）
 * 2、再声明为一个切面（加上@AspectJ注解）
 *
 * @author chenpeng
 * @date 2018/6/3 23:20
 */
@Aspect
@Component
public class LoggingAspect {

    //声明该方法为一个前置通知:在目标方法开始之前执行
    //execution中是AspectJ表达式
    @Before(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("beforeMethod "+methodName+" start with "+args);
    }

    //后置通知，就是在目标方法执行之后（无论是否发生异常）执行的通知
    //后置通知中不能访问目标方法的返回结果
    @After(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterMethod "+methodName+" end with "+args);
    }

    //返回通知，在方法正常结束之后执行的代码
    //返回通知是可以访问到方法的返回值的
    @AfterReturning(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterReturning "+methodName+" end with "+result);
    }

    //返回异常通知，返回抛出异常的时候执行的通知，可以获得返回的异常
    //可以访问到异常对象，且可以指定在出现特定异常的时候再执行通知代码
    @AfterThrowing(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))",throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint,Exception ex){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterThrowing "+methodName+" end with "+ ex );
    }

    //环绕通知需要携带ProceedingJoinPoint类型的参数
    //环绕通知类似于动态代理的全过程，这个类型ProceedingJoinPoint的参数可以决定是否执行目标方法
    //且环绕通知必须有返回值，返回值即为目标方法返回值
    @Around(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))")
    public  void around(ProceedingJoinPoint proceedingJoinPoint){
        Object result = null;
        String methodName = proceedingJoinPoint.getSignature().getName();
        Object[] args = proceedingJoinPoint.getArgs();

        //执行目标方法
        try {
            //前置通知
            System.out.println("beforeMethod "+methodName+" start with "+args);

            result = proceedingJoinPoint.proceed();

            //返回通知
            System.out.println("afterMethod "+methodName+" end with "+result);
        } catch (Throwable throwable) {
            //异常通知
            System.out.println("afterThrowing "+methodName+" exception with "+ throwable );
            throwable.printStackTrace();
        }

        //后置通知
        System.out.println("afterMethod "+methodName+" end with "+args);
        //System.out.println("around "+proceedingJoinPoint);
        return;
    }

}

对于切面的优先级

可以在类上使用注解@Order（1），括号中的数字越小，优先级越高

@Order(1)

重用切面的切点表达式：使用@Pointcut 

/**
 * 定义一个方法，用于声明切入点表达式
 *一般的，该方法中不需要添加其他的代码
 * 使用@Pointcut来声明切入点表达式
 * 后面的其他通知直接使用方法名来引用切入点表达式
 */
@Pointcut(value = "execution(* aopImpl.ArithmeticCalculatorImpl.*(int ,int ))")
public void declareJoinPointExpress(){ }

//声明该方法为一个前置通知:在目标方法开始之前执行
//execution中是AspectJ表达式
@Before(value = "declareJoinPointExpress()")
public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    List<Object> args = Arrays.asList(joinPoint.getArgs());
    System.out.println("beforeMethod "+methodName+" start with "+args);
}

其他切面类中使用：

package aopImpl;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @author chenpeng
 * @date 2018/6/4 8:09
 */
//可以使用@Order指定切面的优先级，值越小优先级越高
@Order(1)
@Component
@Aspect
public class ValidationAspect {

    @Before(value = "LoggingAspect.declareJoinPointExpress()")
    public void validateArgs(JoinPoint joinPoint){
        System.out.println("validateArgs"+ Arrays.asList(joinPoint.getArgs()));
    }
}

二、基于XML配置文件的方式

除了使用@AspectJ注解声明切面，Spring还支持在Bean的配置文件中声明切面，这种声明是通过aop Schema中的XML元素完成的。

正常情况下，基于注解的声明要优于基于XML的声明，通过@AspectJ注解，可以与Aspect切面相兼容，而基于XML配置则是Spring专有的。优于@AspectJ得到越来越多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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置bean-->
    <bean id="arithmeticCalculatorImpl" class="XML.ArithmeticCalculatorImpl"/>

    <!--配置切面的bean-->
    <bean id="LoggingAspect" class="XML.LoggingAspect"/>
    <bean id="ValidationAspect" class="XML.ValidationAspect"/>

    <!--配置AOP-->
    <aop:config>
        <!--配置切点表达式-->
        <aop:pointcut id="pointcut" expression="execution(* XML.ArithmeticCalculatorImpl.*(..))"/>

        <!--配置切面及通知-->
        <aop:aspect ref="LoggingAspect" order="2">
            <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
            <aop:after method="afterMethod" pointcut-ref="pointcut"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>

        </aop:aspect>

        <aop:aspect ref="ValidationAspect" order="1">
            <aop:before method="validateArgs" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

</beans>