AOP面向切面
1.什么是Spring的AOP?
AOP又叫"面向切面编程",是对传统的面向对象编程的一个补充,主要的操作对象就是"切面
",可以简单的理解它是贯穿于方法之中,在方法执行前、执行时、执行后、返回值后、异常后要执行的操作。
相当于将我们原本一条线执行的程序在中间切开加入一些其他操作。
在应用AOP编程时，任然需要定义公共功能，但可以明确定义这个功能应用在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的类里——这样的类我们通常称为“切面”。如图：AOP切面模型图。
| 术语 | 含义 |
|---|---|
| 横切关注点 | 从每个方法中抽取出来的同一类非核心业务 |
| 切面（Aspect） | 封装横切关注点信息的类，每个关注点体现为一个通知方法 |
| 通知（Advice） | 切面必须要完成的各个具体工作 |
| 目标（Target） | 被通知的对象 |
| 代理（proxy） | 向目标对象应用通知之后创建的代理对象 |
| 连接点（Joinpoint） | 横切关注点在程序代码中的具体体现，对应程序执行的某个特定位置 |
| 切入点（pointcut） | 执行或找到连接点的方式 |
2.AOP的五种通知注解
1.@Before：前置通知，在方法执行前执行
2.@After：后置通知，在方法执行后执行
3.@AfterRunning：返回通知，在方法返回结果后执行
4.@AfterThrowing：异常通知，在方法抛出异常后执行
5.@Around：环绕通知，围绕着方法执行
3.切入点表达式
五种通知注解后面还可以跟特定的参数，用来指定哪一个切面方法在哪一个方法执行时触发。
切入点表达式：通过在注解中加入表达式参数，我们就可以通过表达式的方式定位一个或者多个具体的连接点
切点表达式的语法格式规范：
execution([权限修饰符] [返回值类型] [简单类名、全类名] [方法名] ([参数列表]))
例子：
execution(* com.atguigu.spring.ArithmeticCalculator.*(…))
含义：ArithmeticCalculator接口中声明的所有方法。第一个“星号”代表任意修饰符及任意返回值。第二个“星号”代表任意方法。“…”匹配任意数量、任意类型的参数。若目标类、接口与该切面类在同一个包中可以省略包名。
execution(public * ArithmeticCalculator.*(…))
含义：ArithmeticCalculator接口的所有公有方法
execution(public double ArithmeticCalculator.*(…))
含义：ArithmeticCalculator接口中返回double类型数值的方法
execution(public double ArithmeticCalculator.*(double, …))
含义：第一个参数为double类型的方法。“…” 匹配任意数量、任意类型的参数。
execution(public double ArithmeticCalculator.*(double, double))
含义：参数类型为double，double类型的方法
execution("* *(…)")
表示任意包下任意类的任意方法，但是这个表达式千万别写，哈哈，不然你每一个执行的方法都会有通知方法执行的！在AspectJ中，切入点表达式可以通过 “&&”、“||”、“!”等操作符结合起来
如：execution (* .add(int,…)) || execution( *.sub(int,…))
表示任意类中第一个参数为int类型的add方法或sub方法
4.注解实践
对于切入点表达式，我们可以直接在注解中使用“”写在其中，还可以在@AfterReturning注解和@AfterThrowing注解中将切入点赋值给pointcut属性，但是在其他的注解中没有pointcut这个参数。
将切入点表达式应用到实际的切面类中如下：
@Aspect //切面注解
@Component //其他业务层
public class LogUtli {
// 方法执行开始，表示目标方法是com.spring.inpl包下的任意类的任意以两个int为参数，返回int类型参数的方法
@Before("execution(public int com.spring.inpl.*.*(int, int))")
public static void LogStart(JoinPoint joinPoint) {
System.out.println("通知记录开始...");
}
// 方法正常执行完之后
/**
* 在程序正常执行完之后如果有返回值，我们可以对这个返回值进行接收
* returning用来接收方法的返回值
* */
@AfterReturning(pointcut="public int com.spring.inpl.*.*(int, int)",returning="result")
public static void LogReturn(JoinPoint joinPoint,Object result) {
System.out.println("【" + joinPoint.getSignature().getName() + "】程序方法执行完毕了...结果是：" + result);
}
}
以上只是一个最简单的通知方法，但是在实际的使用过程中我们可能会将多个通知方法切入到同一个目标方法上去，比如同一个目标方法上既有前置通知、又有异常通知和后置通知。
但是这样我们也只是在目标方法执行时切入了一些通知方法，那么我们能不能在通知方法中获取到执行的目标方法的一些信息呢？当然是可以的。
5.JoinPoint获取方法信息
在这里我们就可以使用JoinPoint接口来获取到目标方法的信息，如方法的返回值、方法名、参数类型等。
如我们在方法执行开始前，获取到该目标方法的方法名和输入的参数并输出。
// 方法执行开始
@Before("execution(public int com.spring.inpl.*.*(int, int))")
public static void LogStart(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs(); //获取到参数信息
Signature signature = joinPoint.getSignature(); //获取到方法签名
String name = signature.getName(); //获取到方法名
System.out.println("【" + name + "】记录开始...执行参数：" + Arrays.asList(args));
}
6.接收方法的返回值和异常信息
对于有些目标方法在执行完之后可能会有返回值，或者方法中途异常抛出，那么对于这些情况，我们应该如何获取到这些信息呢？
1.首先我们来获取当方法执行完之后获取返回值
2.在这里我们可以使用@AfterReturning注解，该注解表示的通知方法是在目标方法正常执行完之后执行的。
3.在返回通知中，只要将returning属性添加到@AfterReturning注解中，就可以访问连接点的返回值。
4.该属性的值即为用来传入返回值的参数名称，但是注意必须在通知方法的签名中添加一个同名参数。
5.在运行时Spring AOP会通过这个参数传递返回值，由于我们可能不知道返回值的类型，所以一般将返回值的类型设置为Object型。
6.与此同时，原始的切点表达式需要出现在pointcut属性中
// 方法正常执行完之后
/**
* 在程序正常执行完之后如果有返回值，我们可以对这个返回值进行接收
* returning用来接收方法的返回值
* */
@AfterReturning(pointcut="public int com.spring.inpl.*.*(int, int)",returning="result")
public static void LogReturn(JoinPoint joinPoint,Object result) {
System.out.println("【" + joinPoint.getSignature().getName() + "】程序方法执行完毕了...结果是：" + result);
}
接收异常信息时 ，方法一样
我们需要将throwing属性添加到@AfterThrowing注解中，也可以访问连接点抛出的异常。Throwable是所有错误和异常类的顶级父类，所以在异常通知方法可以捕获到任何错误和异常。
如果只对某种特殊的异常类型感兴趣，可以将参数声明为其他异常的参数类型。然后通知就只在抛出这个类型及其子类的异常时才被执行。
// 异常抛出时
/**
* 在执行方法想要抛出异常的时候，可以使用throwing在注解中进行接收，
* 其中value指明执行的全方法名
* throwing指明返回的错误信息
* */
@AfterThrowing(pointcut="public int com.spring.inpl.*.*(int, int)",throwing="e")
public static void LogThowing(JoinPoint joinPoint,Object e) {
System.out.println("【" + joinPoint.getSignature().getName() +"】发现异常信息...,异常信息是：" + e);
}
7.环绕通知
环绕通知是所有通知类型中功能最强大的，能够全面的控制连接点，甚至可以控制是否执行连接点。对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是JoinPoint的子接口，允许控制何时执行，是否执行连接点。
在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。着就意味着我们需要在方法中传入参数ProceedingJoinPoint来接收方法的各种信息。注意：环绕通知的方法需要返回目标方法执行之后的结果，及调用joinPoint.proceed()；的返回值，否则会出现空指针异常。
/**
* 环绕通知方法
* 使用注解@Around()
* 需要在方法中传入参数proceedingJoinPoint 来接收方法的各种信息
* 使用环绕通知时需要使用proceed方法来执行方法
* 同时需要将值进行返回,环绕方法会将需要执行的方法进行放行
* *********************************************
* @throws Throwable
* */
@Around("public int com.spring.inpl.*.*(int, int)")
public Object MyAround(ProceedingJoinPoint pjp) throws Throwable {
// 获取到目标方法内部的参数
Object[] args = pjp.getArgs();
System.out.println("【方法执行前】");
// 获取到目标方法的签名
Signature signature = pjp.getSignature();
String name = signature.getName();
Object proceed = null;
try {
// 进行方法的执行
proceed = pjp.proceed();
System.out.println("方法返回时");
} catch (Exception e) {
System.out.println("方法异常时" + e);
}finally{
System.out.println("后置方法");
}
//将方法执行的返回值返回
return proceed;
}
8.通知注解的执行顺序
在正常情况下执行：
@Before(前置通知)—>@After(后置通知)---->@AfterReturning(返回通知)在异常情况下执行：
@Before(前置通知)—>@After(后置通知)---->@AfterThrowing(异常通知)当普通通知和环绕通知同时执行时：
执行顺序是：
环绕前置----普通前置----环绕返回/异常----环绕后置----普通后置----普通返回/异常
9.重用切入点定义
对于上面的通知注解，我们都是在每一个通知注解上都定义了一遍切入点表达式。但如果我们不想给这个方法设置通知方法了，或者我们想要将这些通知方法切入到另一个目标方法，那么我们岂不是要一个一个的更改注解中的切入点表达式吗？这样也太麻烦了吧？
所以spring就想到了一个办法，重用切入点表达式。
也就是说将这些会重复使用的切入点表达式用一个方法来表示，那么我们的通知注解只需要调用这个使用了该切入点表达式的方法即可实现和之前一样的效果，这样的话，我们即使想要更改切入点表达式的接入方法，也不用一个一个的去通知注解上修改了。获取可重用的切入点表达式的方法是：
1.随便定义一个void的无实现的方法
2.为方法添加注解@Pointcut()
3.在注解中加入抽取出来的可重用的切入点表达式
4.使用value属性将方法加入到对应的切面函数的注解中
@Aspect //切面注解
@Component //其他业务层
public class LogUtli {
/**
* 定义切入点表达式的可重用方法
* */
@Pointcut("execution(public int com.spring.inpl.MyMathCalculator.*(int, int))")
public void MyCanChongYong() {}
// 方法执行开始
@Before("MyCanChongYong()")
public static void LogStart(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs(); //获取到参数信息
Signature signature = joinPoint.getSignature(); //获取到方法签名
String name = signature.getName(); //获取到方法名
System.out.println("【" + name + "】记录开始...执行参数：" + Arrays.asList(args));
}
// 方法正常执行完之后
/**
* 在程序正常执行完之后如果有返回值，我们可以对这个返回值进行接收
* returning用来接收方法的返回值
* */
@AfterReturning(value="MyCanChongYong()",returning="result")
public static void LogReturn(JoinPoint joinPoint,Object result) {
System.out.println("【" + joinPoint.getSignature().getName() + "】程序方法执行完毕了...结果是：" + result);
}
// 异常抛出时
/**
* 在执行方法想要抛出异常的时候，可以使用throwing在注解中进行接收，
* 其中value指明执行的全方法名
* throwing指明返回的错误信息
* */
@AfterThrowing(value="MyCanChongYong()",throwing="e")
public static void LogThowing(JoinPoint joinPoint,Object e) {
System.out.println("【" + joinPoint.getSignature().getName() +"】发现异常信息...,异常信息是：" + e);
}
// 结束得出结果
@After(value = "execution(public int com.spring.inpl.MyMathCalculator.add(int, int))")
public static void LogEnd(JoinPoint joinPoint) {
System.out.println("【" + joinPoint.getSignature().getName() +"】执行结束");
}
/**
* 环绕通知方法
* @throws Throwable
* */
@Around("MyCanChongYong()")
public Object MyAround(ProceedingJoinPoint pjp) throws Throwable {
// 获取到目标方法内部的参数
Object[] args = pjp.getArgs();
System.out.println("【方法执行前】");
// 获取到目标方法的签名
Signature signature = pjp.getSignature();
String name = signature.getName();
Object proceed = null;
try {
// 进行方法的执行
proceed = pjp.proceed();
System.out.println("方法返回时");
} catch (Exception e) {
System.out.println("方法异常时" + e);
}finally{
System.out.println("后置方法");
}
//将方法执行的返回值返回
return proceed;
}
}
特别注意：当定义多个切面时，切面的执行顺序是按照类名的首字符先后来执行的（不区分大小写）
10.基于XML配置的AOP实现
基于XML配置的AOP切面顾名思义就是摒弃了注解的使用，转而在IOC容器中配置切面类，这种声明是基于aop名称空间中的XML元素来完成的，
在bean配置文件中，所有的Spring AOP配置都必须定义在< aop:config>元素内部。对于每个切面而言，都要创建一个<
aop:aspect>元素来为具体的切面实现引用后端bean实例。切面bean必须有一个标识符，供< aop:aspect>元素引用。
所以我们在bean的配置文件中首先应该先将所需切面类加入到IOC容器中去，之后在aop的元素标签中进行配置。我们在使用注解进行开发的时候，五种通知注解以及切入点表达式这些在xml文件中同样是可以配置出来的。
10.1声明切入点
切入点使用
< aop:pointcut>元素声明。 切入点必须定义在< aop:aspect>元素下，或者直接定义在< aop:config>元素下。
定义在< aop:aspect>元素下：只对当前切面有效
定义在< aop:config>元素下：对所有切面都有效
基于XML的AOP配置不允许在切入点表达式中用名称引用其他切入点。
10.2声明通知
在aop名称空间中，每种通知类型都对应一个特定的XML元素。
通知元素需要使用< pointcut-ref>来引用切入点，或用< pointcut>直接嵌入切入点表达式。
method属性指定切面类中通知方法的名称具体使用可以看下面这里实例：
<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
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-4.0.xsd">
<!-- 通过配置文件实现切面
1、将目标类和切面类加入到容器中 @component
2、声明哪个类是切面类，@Aspect
3、在配置文件中配置五个通知方法，告诉切面类中的方法都何时运行
4、开启基于注解的AOP功能
-->
<!-- 将所需类加入到容器中 -->
<bean id="myCalculator" class="com.spring.inpl.MyMathCalculator"></bean>
<bean id="logUtil" class="com.spring.utils.LogUtli"></bean>
<bean id="SecondUtli" class="com.spring.utils.SecondUtli"></bean>
<!-- 进行基于AOP的配置 -->
<!-- 当有两个切面类和一个环绕方法时，方法的执行是按照配置文件中配置的先后顺序执行的
配置在前的就会先执行，配置在后的就会后执行，但同时环绕方法进入之后就会先执行环绕方法
-->
<aop:config>
<!-- 配置一个通用类 -->
<aop:pointcut expression="execution(public int com.spring.inpl.MyMathCalculator.*(int, int)))" id="myPoint"/>
<!-- 配置某一个指定的切面类 -->
<aop:aspect id="logUtil_Aspect" ref="logUtil">
<!-- 为具体的方法进行指定
method指定具体的方法名
pointcut指定具体要对应的方法
-->
<aop:before method="LogStart" pointcut="execution(public int com.spring.inpl.MyMathCalculator.add(int, int))"/>
<aop:after-throwing method="LogThowing" pointcut="execution(public int com.spring.inpl.MyMathCalculator.*(int, int)))" throwing="e"/>
<aop:after-returning method="LogReturn" pointcut-ref="myPoint" returning="result"/>
<aop:after method="LogEnd" pointcut-ref="myPoint"/>
<!-- 定义一个环绕方法 -->
<aop:around method="MyAround" pointcut-ref="myPoint"/>
</aop:aspect>
<!-- 定义第二个切面类 -->
<aop:aspect ref="SecondUtli">
<aop:before method="LogStart" pointcut="execution(public int com.spring.inpl.MyMathCalculator.*(..))"/>
<aop:after-throwing method="LogThowing" pointcut-ref="myPoint" throwing="e"/>
<aop:after method="LogEnd" pointcut-ref="myPoint"/>
</aop:aspect>
</aop:config>
</beans>
XML实现AOP切面编程的总结：
通过配置文件实现切面1.将目标类和切面类加入到容器中 相当于注解@component
2.声明哪个类是切面类，相当于注解@Aspect
3.在配置文件中配置五个通知方法，告诉切面类中的方法都何时运行
4.开启基于注解的AOP功能这里有一点还需要注意：
当有两个切面类和一个环绕方法时，方法的执行是按照配置文件中配置的先后顺序执行的，配置在前的就会先执行，配置在后的就会后执行，但同时环绕方法进入之后就会先执行环绕方法。