Spring_AOP

1. 提出问题

• 情景: 数学计算器
• 要求:
  ①: 执行加减乘除运算
  ②日志：在程序执行期间追踪正在发生的活动
  ③验证：希望计算器只能处理正数的运算

常规实现

• 问题:
  ○代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。
  ○代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。

2. 动态代理

代理是一种常用的设计模式，其目的就是为真实对象提供一个代理对象以控制对真实对象的访问。代理类负责为委托类（被代理类、真实类）预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。
代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

动态代理的实现步骤

1. 创建一个接口, 代理类和被代理类都需要实现的接口
   目标对象必须实现接口.

package com.lz.proxy;

public interface Calculator {
    int add(int i, int j);

    int sub(int i, int j);
}

2. 定义被代理类, 实现接口

package com.lz.proxy;

/**
 * @ClassName CalculatorImpl
 * @Description: TODO
 * @Author MAlone
 * @Date 2020/5/30
 * @Version V1.0
 **/
public class CalculatorImpl implements Calculator {
    public int add(int i, int j) {
        return i + j;
    }

    public int sub(int i, int j) {
        return i - j;
    }
}

3. 创建被代理类的代理类, 实现InvocationHandler 接口, 实现invoke方法

package com.lz.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @ClassName CalculatorProxy
 * @Description: calculator 的代理类
 * @Author MAlone
 * @Date 2020/5/30
 * @Version V1.0
 **/
public class CalculatorProxy implements InvocationHandler {

    private Calculator calculator; // 被代理类

    public CalculatorProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("begin");
        Object invoke = method.invoke(calculator, args);
        System.out.println("end");
        return invoke;

    }
}

4. 利用Proxy类创建代理对象, 使用代理对象调用被代理类的方法。

package com.lz.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * @ClassName Client
 * @Description: 代理类的实际调用
 * @Author MAlone
 * @Date 2020/5/30
 * @Version V1.0
 **/
public class Client {
    public static void main(String[] args) {
        Calculator calculator = new CalculatorImpl();
        InvocationHandler calculatorProxy = new CalculatorProxy(calculator);
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
                calculatorProxy.getClass().getClassLoader(), // 代理类的类加载器
                calculator.getClass().getInterfaces(), 		// 被代理类实现的所有接口
                calculatorProxy							   // 代理类
        );
        System.out.println(Arrays.asList(proxy.getClass().getInterfaces()));
        proxy.add(1, 3);
    }
}

3. 解决问题

1. 日志处理器
   

2. 验证处理器
   

3. 客户端测试代码
   

4. AOP 概述

在程序运行期间, 将某段代码动态的切入到指定方法的指定位置进行运行的这种编程方式.

• AOP的好处：
  每个事物逻辑位于一个位置，代码不分散，便于维护和升级
  业务模块更简洁，只包含核心业务代码

5. AOP 专业术语

6. AOP 的使用步骤

1. 将目标类和切面类加入到IOC容器中 (@Component)

目标类

切面类

2. 告诉Spring 哪个是切面类 (@Aspect)

3. 告诉Spring,切面类的每个方法, 都是何时(通知注解)何地(切入点表达式)运行的

4. 配置文件中开启基于注解的AOP模式

7. AOP 详解

7.1 切入点表达式

1. 作用

通过表达式的方式定位一个或多个具体的连接点

2. 语法格式:

execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))

3. 举例说明:

execution(* com.lz.spring.ArithmeticCalculator.*(..))

ArithmeticCalculator接口中声明的所有方法。
第一个“*”代表任意修饰符及任意返回值。
第二个“*”代表任意方法。
“..”匹配任意数量、任意类型的参数。
若目标类、接口与该切面类在同一个包中可以省略包名。

4. 切入点表达式应用到实际的切面类中

7.2 当前连接点细节

需要获取当前连接点所在方法的方法名, 当前传入的参数值等等. 这些信息都封装在JoinPoint接口的实例对象中.

7.3 通知

7.3.0 概述

• 在具体的连接点上要执行的操作。
• 一个切面可以包括一个或者多个通知。
• 通知所使用的注解的值往往是切入点表达式。

7.3.1 前置通知

• 前置通知：在方法执行之前执行的通知
• 使用@Before注解

7.3.2 后置通知

• 后置通知：后置通知是在连接点完成之后执行的，即连接点返回结果或者抛出异常的时候
• 使用@After注解

7.3.3 返回通知

• 返回通知：无论连接点是正常返回还是抛出异常，后置通知都会执行。如果只想在连接点返回的时候记录日志，应使用返回通知代替后置通知。
• 使用@AfterReturning注解
• 在返回通知中访问连接点的返回值

1. 在返回通知中，只要将returning属性添加到@AfterReturning注解中，就可以访问连接点的返回值。该属性的值即为用来传入返回值的参数名称
2. 必须在通知方法的签名中添加一个同名参数。在运行时Spring AOP会通过这个参数传递返回值
3. 原始的切点表达式需要出现在pointcut属性中
   

7.3.4 异常通知

• 异常通知：只在连接点抛出异常时才执行异常通知
• 将throwing属性添加到@AfterThrowing注解中，也可以访问连接点抛出的异常。Throwable是所有错误和异常类的顶级父类，所以在异常通知方法可以捕获到任何错误和异常。
• 如果只对某种特殊的异常类型感兴趣，可以将参数声明为其他异常的参数类型。然后通知就只在抛出这个类型及其子类的异常时才被执行
  

7.3.5 环绕通知

• 环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。
• 对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是JoinPoint的子接口，允许控制何时执行，是否执行连接点。
• 在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。
• 注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed();的返回值，否则会出现空指针异常。
  

7.3.6 重用切入点定义

7.3.7 指定切面的优先级

8. 以XML方式配置切面

1. 切面类加入到容器中< bean >

<bean id="calculatorLoggingAspect" class="com.lz.aop.LogUtils"></bean>

2. 告诉Spring 切面类是哪个 < aop:config><aop: aspect>
   使用< aop:config > 进行配置, 每个切面都要创建一个< aop: aspect> 元素来为具体的切面实现引用后端bean实例.

<aop:config>
	<aop:aspect id="loggingAspect" ref="calculatorLoggingAspect"></aop:aspect>
</aop:config>

3. 声明切入点 < aop: pointcut >
切入点必须定义在< aop:aspect>元素下，或者直接定义在< aop:config>元素下。
① 定义在< aop:aspect>元素下：只对当前切面有效
② 定义在< aop:config >元素下：对所有切面都有效

    <aop:config>
        <aop:pointcut id="testOperation" expression="execution(public int com.lz.aop.CalculatorImpl.*(..))"/>
        <aop:aspect id="loggingAspect" ref="calculatorLoggingAspect"></aop:aspect>
    </aop:config>

4. 声明通知
    在aop名称空间中，每种通知类型都对应一个特定的XML元素。
    通知元素需要使用来引用切入点，或用直接嵌入切入点表达式。
    method属性指定切面类中通知方法的名称