3.AOP

1.代理模式

  二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。
  举例:广告商找大明星拍广告需要经过经纪人、合作伙伴找大老板谈合作要约见面时间需要经过秘书

2.静态代理实现

  代理类特点:
(1) 目标类实现什么功能,代理类也能实现
(2) 代理类和目标类是一对一的

public class CalculatorStaticProxy implements Calculator{

    private CalculatorPureImpl target;

    public CalculatorStaticProxy() {
    }

    public CalculatorStaticProxy(CalculatorPureImpl calculatorPure) {
        this.target = calculatorPure;
    }

    @Override
    public int add(int i, int j) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
        // 通过目标对象来实现核心业务逻辑
        int addResult = target.add(i, j);
        System.out.println("[日志] add 方法结束了，结果是：" + addResult);
        return addResult;
    }
}

3.动态代理

  动态代理一般有两种,一种是JDK动态代理,另一种是cglib动态代理.下面是jdk动态代理,它要求必须有接口,最终生成的代理类在com.sun.proxy包下,类名为$proxy数字.cglib动态代理没有什么要求,最终生成的代理类会继承目标类,并且和目标类在相同包下.
  利用JDK提供的API,动态地为每一个目标类创建代理类

  动态代理的具体实现原理是利用反射机制.我们需要创建类ProxyFactory用来创建代理类,在这个类中我们需要有目标类作为属性.

public class ProxyFactory {
    //用于生成代理类

    //任意的目标类
    private Object target;

    public ProxyFactory() {
    }

    public ProxyFactory(Object target) {
        this.target = target;
    }

    /**
     * newProxyInstance()：创建一个代理实例
     * 其中有三个参数：
     * 1、ClassLoader classLoader：加载动态生成的代理类的类加载器
     * 类加载器的三个分类:
     * (1) AppClassLoader应用类加载器,又称为系统类加载器,负责在JVM启动时,加载自己写的类或者第三方jar包的类
     * 应用类加载器可以通过自定义类对象.getClass().getClassLoader()获取
     * (2) ExtClassLoader扩展类加载器,主要负责加载Java的扩展类库,默认加载JAVA_HOME/jre/lib/ext/目录下的所有jar包或者由java.ext.dirs系统属性指定的jar包
     * (3) BootstrapClassLoader称为启动类加载器，是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库，如：rt.jar、resources.jar、charsets.jar等
     * (4) 自定义类加载器
     * 2、Class[] interfaces：目标对象实现的所有接口的class对象所组成的数组(因为目标类和代理类要实现相同的接口)
     * 3、InvocationHandler h：设置代理对象实现目标对象方法的过程，即代理类中如何重写接
     口中的抽象方法
     */
    public Object getProxy(){
        //通过目标对象获取所有实现的接口
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //匿名类
        InvocationHandler h = new InvocationHandler() {
            //invoke代表代理类的实现方法应该如何执行
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //代理类自己在执行前添加的功能
                System.out.println("日志,方法:"+method.getName()+",参数:"+ Arrays.toString(args));
                //proxy代表代理对象 method表示要重写的抽象方法 args表示执行方法的参数列表
                //invoke(执行的对象,执行的参数列表)
                Object invoke = method.invoke(target, args);
                System.out.println("日志,方法:"+method.getName()+",结果:"+ invoke);
                return invoke;
            }
        };
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),interfaces,h);
    }
}

  我们添加操作时,一般有四个时机:执行前、执行后、异常时、最终返回时，异常时可以利用try-catch使用

4.AOP相关概念

4.1 基本概念与相关术语

(1) 概述
  \(AOP（Aspect Oriented Programming）\)是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

(2) 术语

• 横切关注点
    从每个方法中抽取出来的同一类非核心业务(比如计算器的日志功能)。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。
    这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

• 通知
    每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。将横切关注点封装到一个类中,类中的每一个横切关注点都是一个通知。

① 前置通知：在被代理的目标方法前执行
② 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
③ 异常通知：在被代理的目标方法异常结束后执行（死于非命）
④ 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
⑤ 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

• 切面
    封装通知方法的类。

• 目标
    被代理的目标对象。

• 代理
    向目标对象应用通知之后创建的代理对象。

• 连接点
    这也是一个纯逻辑概念，不是语法定义的。
    把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。
  

• 切入点
    定位连接点的方式。
    每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。
    如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。
    Spring 的 AOP 技术可以通过切入点定位到特定的连接点。切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条
  件。

(3) 作用
  简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，
提高内聚性。
  代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

4.2 基于注解的AOP

  AOP两种实现方式:基于注解、基于XML
(1) 技术说明
  动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
  cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
  AspectJ：本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解

(2) 准备工作
① 添加依赖

<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>5.3.1</version>
</dependency>

② 准备被代理的目标资源
  接口:

public interface Calculator {
int add(int i, int j);
int sub(int i, int j);
int mul(int i, int j);
int div(int i, int j);
}

  实现类:

@Component
public class CalculatorPureImpl implements Calculator{
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;

    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;

    } 

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;

    }
}

  准备好后,我们需要将它们交给\(IOC\)容器管理,注意使用注解和扫描,一般使用\(@Component\)注解,切面类必须通过\(@Aspect\)注解标识为一个切面

    <!--
    AOP的注意事项:
    1.切面类和目标类都需要交给IOC容器管理
      采用注解的方式:需要注解和扫描
    2.切面类必须通过@Aspect注解标识为一个切面
	3.在Spring的配置文件中设置aop:aspectj-autoproxy/>开启基于注解的aop功能
    -->
    <context:component-scan base-package="com.hnnd.spring.aop.annotation"/>

③ 创建切面类并配置
  切面类中有大量通知,主要是以下五类

• 前置通知：使用@Before注解标识，在被代理的目标方法前执行
• 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
• 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）,即在目标方法的catch子句中执行
• 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）类似finally
• 环绕通知：使用@Around注解标识，使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
    在切面中,我们需要通过注解将方法标识为切面方法
  切面类:

@Component
@Aspect//标注切面组件
public class LoggerAspect {
    //这个注解是切入表达式,用于找到目标类的目标方法
    //格式 exection(修饰词 返回值 全类名.方法名(参数类型))
    @Before("execution(public int com.hnnd.spring.aop.annotation.CalculatorPureImpl.add(int,int))")
    public void beforeAdviceMethod(){
        System.out.println("LoggerAspect,前置通知");
    }
}

测试类:

//当使用aop时,我们不能获取目标对象(这里是CalculatorPureImpl),只能获取代理对象
        //因为代理对象和目标对象实现的是相同的接口,因此获取代理对象可以通过接口获取
        ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.add(10,2);
//LoggerAspect,前置通知
//方法内部 result = 12

(3) 切入点表达式的语法
  上面说的切入点表达式语法只能具体作用的一个方法中,但实际我们可能需要多个方法都需要方法前(或者其他)的注解
  下面是切入点表达式的语法:

1. 用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
2. 在包名的部分，一个“”号只能代表包的层次结构中的一层，表示这一层是任意的。
   例如：.Hello匹配com.Hello，不匹配com.atguigu.Hello
3. 在包名的部分，使用“*..”表示包名任意、包的层次深度任意
4. 在类名的部分，类名部分整体用*号代替，表示类名任意
5. 在类名的部分，可以使用号代替类名的一部分
   例如：Service匹配所有名称以Service结尾的类或接口
6. 在方法名部分，可以使用*号表示方法名任意
7. 在方法名部分，可以使用号代替方法名的一部分
   例如：Operation匹配所有方法名以Operation结尾的方法
8. 在方法参数列表部分，使用(..)表示参数列表任意
9. 在方法参数列表部分，使用(int,..)表示参数列表以一个int类型的参数开头
10. 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的
11. 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
12. 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符
    例如：execution(public int ..Service.(.., int)) 正确
    例如：execution( int ..Service.*(.., int)) 错误

(4) 获取切入点信息
  在切面的横切关注点中,我们有时需要目标方法的信息,此时我们的横切关注点不能是空参,比如

• 获取方法名和参数列表

Before("execution(* com.hnnd.spring.aop.annotation.CalculatorPureImpl.*(..))")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //joinPoint帮助获取连接点信息(定位的方法信息)
		//Signature签名是方法的声明信息(包括修饰符、返回值、方法名、参数类型)
        Signature signature = joinPoint.getSignature();
        //signature.getName获取方法名
        //joinPoint.getArgs获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
    }

• 获取返回值

//returning 属性设置接受目标方法返回值的参数名,只需要在参数列表中配置同名参数即可
    @AfterReturning(value = "poinCut()",returning = "result")
    public void afterReturningAdviceMethod(JoinPoint joinPoint,Object result){
        //在目标方法返回值之后执行的通知,如果有异常是不会返回的
        System.out.println("LoggerAspect,方法:"+joinPoint.getSignature().getName()+",结果:"+result.toString());
    }

• 获取异常

@AfterThrowing(value = "poinCut()",throwing = "ex")
//参数也可以是Throwable ex
    public void afterThrowingAdviceMethod(JoinPoint joinPoint,Exception ex){
        System.out.println("LoggerAspect,方法:"+joinPoint.getSignature().getName()+",异常:"+ex);
    }

(5) 切入点表达式的重用
  我们可以通过声明一个公共的切入点表达式来简化代码内容
① 声明

//@Pointcut用来声明公共的切入点表达式
@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))")
public void pointCut(){}

② 在同切面里面使用

@Before("pointCut()")
public void beforeMethod(JoinPoint joinPoint){
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

③ 在不同的切面中使用

@Before("com.atguigu.aop.CommonPointCut.pointCut()")
public void beforeMethod(JoinPoint joinPoint){
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

(5) 通知的顺序
各种通知的执行顺序：

• Spring版本5.3.x以前：
  前置通知
  目标操作
  后置通知
  返回通知或异常通知
• Spring版本5.3.x以后：
  前置通知
  目标操作
  返回通知或异常通知
  后置通知

(6) 环绕通知的使用
  环绕通知很类似动态代理

@Around("poinCut()")
    //环绕通知方法的返回值必须是目标对象方法的返回值
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
        Object result = null;
        try {
            System.out.println("环绕通知--->前置通知");
            //因为这个是上面四个杂糅,因此我们需要通过一行代码标识目标方法的执行
            //因为是环绕通知,要求一定要将目标方法的返回值返回
            result = joinPoint.proceed();
            System.out.println("环绕通知--->返回通知");

        } catch (Throwable throwable) {
            System.out.println("环绕通知--->异常通知");
            throwable.printStackTrace();
        } finally {
            System.out.println("环绕通知--->后置通知");
        }
        return result;
    }

4.3 切面的优先级

  相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

• 优先级高的切面：外面
• 优先级低的切面：里面
    使用@Order注解可以控制切面的优先级：
  默认值为2147483647
• @Order(较小的数)：优先级高
• @Order(较大的数)：优先级低
  

@Component
@Aspect
@Order(3)
public class ValidateAspect {
}