Spring切面编程

AOP：(Aspect Oriented Programming)是一种面向切面的编程思想。面向切面编程是将程序抽象成各个切面，即解剖对象的内部，将那些影响了多个类的公共行为抽取到一个可重用模块里，减少系统的重复代码，降低模块间的耦合度，增强代码的可操作性和可维护性。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理、增强处理。

1、导入maven依赖

starter-web和starter-aop两个任选一个，一般添加web依赖，里面已经引用了aop的依赖

 <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.5.4</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2、切面实现

2.1、切面@Aspect

定义切面类，常常配合@Component和@Order()使用

@Component：将切面类注入到spring容器中。
@Order()：设置注解执行的顺序

@Aspect
@Component
//设置注解执行的顺序
@Order(2)
public class AnnotationAspectTest {
    .....
}

2.2、切点@PointCut

切点由表示式(expression)和签名(signature)组成，用来指明定切面位置，可以是多个路径，也可以一个切面指定多个切点，常与execution()、@annotation等配合使用。

Pointcut表示式由下列方式来定义或者通过 &&、 ||、 !、 的方式进行组合

execution：用于匹配方法执行的连接点；
within：用于匹配指定类型内的方法执行；
this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；        
target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；
args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；
@within：用于匹配所以持有指定注解类型内的方法；
@target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；
@args：用于匹配当前执行的方法传入的参数持有指定注解的执行；
@annotation：用于匹配当前执行方法持有指定注解的方法；

一个切面单切点单路径

    /**
     * 定义切点,切点为对应controller
     */
	//Pointcut表示式
    @Pointcut("execution(public * com.example.zcs.Aop.controller.*.*(..))")
	//Poin签名
    public void log(){
 
    }

注：execution表达式第一个*表示匹配任意的方法返回值，第二个*表示所有controller包下的类，第三个*表示所有方法,第一个..表示任意参数个数。

一个切面多个切点

    /**
     * 切点一
     */
	@Pointcut("execution(public * com.hippo.provider.controller..*Controller.*(..))")
    public void pointCut1(){}
	/**
	 * 切点二
	 */
    @Pointcut("execution(public * com.hippo.provider.controller..*Service.*(..))")
    public void pointCut2(){}
	/**
	 * 切点三：切点一和切点二执行
	 */
    @Pointcut("pointCut1() ||  pointCut2()")
    public void pointCut3(){}

注意：多个切点在执行增强造作时，需要指明具体是那个切点，例如@Before(pointCut1())

2.2.1、execution表达式语法

表达式格式：execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)

参数	说明
modifiers-pattern	修饰匹配
ret-type-pattern	返回值匹配：可以为*表示任何返回值,全路径的类名等
declaring-type-pattern	类路径匹配
name-pattern	方法名匹配：以指定方法名 或者 代表所有, set 代表以set开头的所有方法
param-pattern	参数匹配：可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(…)表示零个或多个任意参数
throws-pattern	异常类型匹配

execution( * com.hippo.provider.controller.TestController.*(..));
// 第一个* 代表任意修饰符及任意返回值下的TestController类下的所有方法。
// 第二个* 代表TestController类下的所有方法。
// (..) 代表任意参数

// 匹配TestController类下面的所有共有方法。
@Pointcut("execution( public * com.hippo.provider.controller.TestController.*(..))")
// 第一个* 代表任意返回值
// 第二个* 当表任意方法
//(..) 代表任意参数

// 返回 String 类型数值的方法
@Pointcut("execution(  public String com.hippo.provider.controller.TestController.*(..))")

// 匹配第一个参数为 String 的方法。
@Pointcut("execution(  public * com.hippo.provider.controller.TestController.*(String,..))")

// 匹配第一个参数为 double 类型，第二个为 String 类型的方法。
@Pointcut("execution(  public Double com.atguigu.gulimall.product.controller.CouponController.*(Double,String))")

//任何一个以“set”开始的方法的执行：execution(* set*(..))
//实现了Intf接口的所有类,如果Intf不是接口,限定Intf单个类：this(com.test.spring.aop.pointcutexp.Intf),当一个实现了接口的类被AOP的时候,用getBean方法必须cast为接口类型,不能为该类的类型

2.3、切面增强处理Advice声明

包含以下五个注解

@before: 前置通知，在方法执行之前执行。
@After：后置通知，在方法执行后执行。
@AfterReturning: 返回通知，在方法返回结果之后执行。
@AfterThrowing：异常通知，在方法抛出异常之后执行。
@Around：环绕通知，围绕着方法执行。

执行顺序

方法正常执行：AOP=>@Around=>@Before=>Method执行=>@Around=>@After=>@AfterReturning

方法执行异常：AOP=>@Around=>@Before=>Method执行=>@Around=>@After=>@AfterThrowing

2.3.1、@Before

@Before(“切点方法”)：在方法执行前执行该方法，并且可以通过（JoinPoint类或者他的子类）获取请求参数和方法。

@Component
@Aspect
public class TestAspect {
    
    @Pointcut("execution(  * com.hippo.provider.controller.TestController.*(..))")
    private void log(){

    }
    @Before("log()")
    public void TestBefore(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(Arrays.asList(args).toString() +"  "+ name);
    }
}

2.3.2、@After

@After：后置通知，在方法执行后执行。可以通过（JoinPoint类）获取请求参数和方法。

注：当方法抛出异常的时候也不会影响执行切点方法，也就是说不管如何都是会执行切面方法的。

@Component
@Aspect
public class TestAspect {

    @Pointcut("execution(  * com.hippo.provider.controller.TestController.*(..))")
    private void log(){

    }
    @After("log()")
    public void TestBefore(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(Arrays.asList(args).toString() +"  "+ name);
    }
}

2.3.3、@AfterReturning

@AfterReturning 当方法正常执行返回后才执行次方法，如果抛出异常就不会执行此方法。

注：方法异常后，将不会执行此方法，异常不会执行此方法，异常也要执行使用 @After

@Component
@Aspect
public class TestAspect {
    
    @Pointcut("execution(  * com.hippo.provider.controller.TestController.*(..))")
    private void log(){

    }
    @AfterReturning("log()")
    public void TestBefore(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(Arrays.asList(args).toString() +"  "+ name);
    }
}

2.3.4、@AfterThrowing

@AfterThrowing(“log()”) 只有在抛出异常的时候才会调用切点方法。如果不抛出异常就不会调用切点方法。

@Component
@Aspect
public class TestAspect {
    
    @Pointcut("execution(  * com.hippo.provider.controller.TestController.*(..))")
    private void log(){

    }
    @AfterThrowing("log()")
    public void TestBefore(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(Arrays.asList(args).toString() +"  "+ name);
    }
}

2.3.5、@Arount

1. 使用 ProceedingJoinPoint 获取参数信息
2. 使用joinPoint.proceed()方法调用方法。
3. 只有调用上面的方法才能够执行方法

@Component
@Aspect
public class TestAspect {


    @Pointcut("execution(  * com.hippo.provider.controller.TestController.*(..))")
    private void log(){

    }
    @Around("log()")
    public R TestBefore(ProceedingJoinPoint joinPoint) throws Throwable {
        Object[] args = joinPoint.getArgs();
        Object o = args[0];
        HashMap<String, String> stringStringHashMap = null;
        if (o instanceof Map){
            stringStringHashMap = (HashMap<String, String>) o;
        }
        if(stringStringHashMap.get("name").equals("xiaobai")){
            // 当满足参数中name值xiaobai的时候，才会调用下面的方法。
            R proceed = (R) joinPoint.proceed();
            return proceed;
        }else {
            return BaseResult.ok().put("name","小周");
        }
    }
}

2.3.6、JoinPoint类

常用的方法：

• Object[] getArgs：返回目标方法的参数
• Signature getSignature：返回目标方法的签名
• Object getTarget：返回被织入增强处理的目标对象
• Object getThis：返回AOP框架为目标对象生成的代理对象

注意：当使用@Around处理时，需要将第一个参数定义为ProceedingJoinPoint类型，该类是JoinPoint的子类。

2.4、切面自定义注解实现

2.4.1、自定义切面

package com.hippo.core.annotation;

import java.lang.annotation.*;

/**
 * @Description: 操作日志注解
 * @Auther: tangxl
 * @Date: 2021/5/17 11:04
 */
@Documented
@Target(ElementType.METHOD) // 作用在方法上
@Retention(RetentionPolicy.RUNTIME) // 运行时有效
public @interface Operation {
    /**
     * 操作模块
     */
    String module() default "";

    /**
     * 操作类型
     */
    String type() default "";

    /**
     * 操作说明
     */
    String desc() default "";
}

2.4.2、切面操作

package com.hippo.core.aspect;

import com.hippo.core.annotation.Operation;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @ClassName OpenrationAspect
 * @Description TODO 操作日志
 * @Author tangxl
 * @create 2023-05-08 17:59
 **/
@Component
@Aspect
@Order(1)
@Slf4j
public class OpenrationAspect {
    /**
     * 定义切点，切点添加了@Operation注解的方法
     */
    @Pointcut("@annotation(com.hippo.core.annotation.Operation)")
    public void operationLog() {
    }

    @After("operationLog()")
    public void doAfter(ProceedingJoinPoint joinPoint) {
        // 获取注解
        Operation operation = getOperation(joinPoint);
        // 获取注解属性值
        if(operation == null){
            return;
        }
        String module = operation.module();
        String type = operation.type();
        String desc = operation.desc();
        log.info("获取到的Operation注解属性值为：module={},type={},desc={}", module, type, desc);
    }

    //获取注解
    public Operation getOperation(ProceedingJoinPoint point) {
        Signature signature = point.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null){
            return method.getAnnotation(Operation.class);
        }
        return null;
    }
}