spring---面向切面(AOP @Pointcut 表达式篇)

AOP（面向切面编程），可以说是OOP（面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。

当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。

例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。

这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为横切技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为Aspect，即切面。

所谓切面，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息，然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

AOP的基本概念

1. Aspect（切面）：Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的
   Advice。

2. Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它joint point。

3. Pointcut（切点）：表示一组 joint point，这些 joint point
   或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

4. Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

5. Target（目标对象）：织入 Advice 的目标对象.。

6. Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建
   Adviced object 的过程

通知方法:

1. 前置通知:在我们执行目标方法之前运行(@Before)

2. 后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)

3. 返回通知:在我们的目标方法正常返回值后运行(@AfterReturning)

4. 异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)

5. 环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知,执行之后就相当于我们后置通知(@Around)

AOP代码示范

下面以一个AOP日志功能的例子进行代码的演示，具体的代码如下所示：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/**
 * @Description:切面日志类
 * @author: 张重虎
 * @Date: 2022/2/8 14:58
 * @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
 * @Version 1.0
 */
@Aspect
public class LogAspect {
    @Pointcut("execution(* com.example.zhangchonghu.demo.controller.aop.Calculator .*(..))")
    public void pointCut(){};

    /**
     * 前置通知:在我们执行目标方法之前运行(@Before)
     */
    @Before("pointCut()")
    public void logStart(){
        System.out.println("除法运行....参数列表是:{}");
    }

    /**
     * 后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)
     */
    @After("pointCut()")
    public void logEnd(){
        System.out.println("除法结束......");
    }

    /**
     * 返回通知:在我们的目标方法正常返回值后运行(@AfterReturning)
     */
    @AfterReturning("pointCut()")
    public void logReturn(){
        System.out.println("除法正常返回......运行结果是:{}");
    }

    /**
     * 异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)
     */
    @AfterThrowing("pointCut()")
    public void logException(){
        System.out.println("异常通知");
    }

    /**
     * 环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知,执行之后就相当于我们后置通知(@Around)
     * @param proceedingJoinPoint 切点
     * @return
     * @throws Throwable
     */
    @Around("pointCut()")
    public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("执行目标方法之前");
        //调用方法
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("@Arount:执行目标方法之后...");
        return obj;
    }
}

@Pointcut("execution(* com.savage.aop.Calculator .*(..))")，括号中各个pattern分别表示：

• 第一个*表示返回值匹配，可以为*表示任何返回值, 全路径的类名等

• com.savage.aop表示类路径匹配

• 第二个*表示方法名匹配，可以指定方法名 或者*代表所有, set* 代表以set开头的所有方法

• (..)表示参数匹配：可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用""来表示匹配任意类型的参数，".."表示零个或多个任意参数。如(String)表示匹配一个String参数的方法；(,String)表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型。异常类型匹配（throws-pattern?）

目标方法：

/**
 * @Description: 切面目标
 * @author: 张重虎
 * @Date: 2022/2/8 15:04
 * @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
 * @Version 1.0
 */
public class Calculator {
    public int div(int i, int j){
        System.out.println("--------");
        return i/j;
    }
}

配置类：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @Description: 切面配置类
 * @author: 张重虎
 * @Date: 2022/2/8 15:05
 * @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
 * @Version 1.0
 */
@Configuration
@EnableAspectJAutoProxy
public class MyAspectConfig {
    @Bean
    public Calculator calculator(){
        return new Calculator();
    }

    @Bean
    public LogAspect logAspects(){
        return new LogAspect ();
    }
}

测试类：

import com.example.zhangchonghu.demo.controller.aop.Calculator;
import com.example.zhangchonghu.demo.controller.aop.MyAspectConfig;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Description:
 * @author: 张重虎
 * @Date: 2022/2/8 15:05
 * @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
 * @Version 1.0
 */
public class TestLogAop {
    @Test
    public void test(){
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyAspectConfig.class);
        Calculator c = app.getBean(Calculator.class);
        int result = c.div(4, 3);
        System.out.println(result);
        app.close();
    }
}

运行结果：