SpringAOP

一、AOP理解

AOP是一种思想，SpringAOP是一个框架，提供了一种对AOP思想的实现，他们的关系就像MVC和SpringMVC、IOC与DI类似。

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方
式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个
热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
的各个部分进行隔离【对某一类事情的集中处理】，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

二、AOP功能

举个例子，我们在做后台管理系统时，除了登录和注册页面不需要做用户登录验证，其他所有页调用前端控制器都需要验证用户的登陆状态，如果每个前端控制器都写一遍用户登陆验证，当我们的功能越来越多，所需要的验证也就越来越多，而这些方法又是相同的，就会冗余浪费人力。所以我们对于这种功能统一并且使用地方较多的功能，可以考虑使用AOP来统一处理。

AOP能够实现的功能有：

统一日志记录
统一方法执行时间统计
统一返回格式设置
统一异常处理
事务的开启和提交

使用AOP可以扩充多个对象的某个能力，所以说AOP是OOP的补充和完善。

三、AOP组成

1.切面(Aspect)

定义 AOP 是针对哪个统一功能的，这个功能就叫做一个切面，比如用户登录功能或方法的统计日志，他们就各自是一个切面。切面是由切点加通知组成的。

2.连接点(Join Point)

所有可能触发AOP（拦截方法的点）称之为连接点。

3.切点(Pointcut)

定义AOP拦截的规则。

Pointcut 的作⽤就是提供⼀组规则（使⽤ AspectJ pointcut expression language 来描述）来
匹配 Join Point，给满⾜规则的 Join Point 添加 Advice。

切点相当于保存了众多连接点的一个集合（如果把切点看成一个表，而连接点就是表中一条一条的数据）。

4.通知(Advice)

规定AOP执行的时机和执行的方法。

切面的工作被称之为通知。

Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本
⽅法进⾏调⽤：

【1】前置通知 @Before

通知⽅法会在⽬标⽅法调⽤之前执⾏。

【2】后置通知 @After

通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤。

【3】返回数据之后通知 @AfterReturning

通知⽅法会在⽬标⽅法返回后调⽤。

【4】抛出异常之后通知 @AfterThrowing

通知⽅法会在⽬标⽅法抛出异常后调⽤。

【5】环绕通知 @Around

通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执
⾏⾃定义的⾏为。

在这里插入图片描述

四、SpringAOP实现

接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能，完成的⽬标是拦截所有 UserController ⾥⾯的
⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件。
Spring AOP 的实现步骤如下：

（1）添加AOP框架支持

在pom.xml中添加如下配置：

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-bo
ot-starter-aop -->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

（2）定义切面

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * @author SunYuHang
 * @date 2023-02-13 12:43
 * @ClassName : UserAspect  //类名
 */
@Aspect  //表面此类是一个切面
@Component
public class UserAspect {
    
}

（3）定义切点，设置拦截规则

//定义切点，使用AspectJ表达式语法
    @Pointcut("execution(* com.example.springaop.controller.UserController.* (..))")
    public void pointcut(){ }

在这里插入图片描述

*指的是拦截任意方法返回类型

com.example.springaop.controller 拦截包名

com.example.springaop.controller.UserController 拦截类名

com.example.springaop.controller.UserController.* 拦截类下所有方法

com.example.springaop.controller.UserController.* (…) 拦截类下所有方法的所有参数

（4）实现通知方法（在什么时机？执行什么方法？）

package com.example.springaop.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

/**
 * @author SunYuHang
 * @date 2023-02-13 12:43
 * @ClassName : UserAspect  //类名
 */
@Aspect  //表面此类是一个切面
@Component
public class UserAspect {
    
    //定义切点，使用AspectJ表达式语法
    @Pointcut("execution(* com.example.springaop.controller.UserController.* (..))")
    public void pointcut(){ }

    /**
     * 定义 pointcut 切点的前置通知
     * 在执行目标方法之前执行的方法就叫做前置通知
     */
    @Before("pointcut()")
    public void doBefore(){
        System.out.println("前置通知被执行！");
    }

    /**
     * 定义 pointcut 切点的后置通知
     * 通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤。
     */
    @After("pointcut()")
    public void doAfter(){
        System.out.println("后置通知被执行！");
    }

    /**
     * 定义 pointcut 切点的返回数据之后通知
     * 通知⽅法会在⽬标⽅法返回后调⽤。
     */
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        System.out.println("返回数据之后通知被执行！");
    }


    //抛出异常之前通知
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        System.out.println("抛出异常之后通知被执行！");
    }

    //环绕通知
//    @Around("pointcut()")
//    public Object doAround(ProceedingJoinPoint joinPoint){
//        Object obj = null;
//        long start = System.currentTimeMillis();
//        long end = 0;
//        System.out.println("Around ⽅法开始执⾏");
//        try {
//            // 执⾏拦截⽅法
//            obj = joinPoint.proceed();
//        } catch (Throwable throwable) {
//            throwable.printStackTrace();
//        }finally {
//            end =System.currentTimeMillis();
//        }
//        System.out.println("Around ⽅法执行时间"+(end-start)+"ms");
//        System.out.println("Around ⽅法结束执⾏");
//        return obj;
//    }

    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        //spring 中的时间统计对象
        StopWatch stopWatch = new StopWatch();
        Object obj = null;
        System.out.println("Around ⽅法开始执⾏");
        try {
            stopWatch.start();//统计方法的执行时间，开始计时
            // 执⾏拦截⽅法
            obj = joinPoint.proceed();
            stopWatch.stop();//统计方法的执行时间，停止计时
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("Around ⽅法执行时间, "+joinPoint.getSignature().getName()+","+stopWatch.getTotalTimeMillis()+"ms");
        System.out.println("Around ⽅法结束执⾏");
        return obj;
    }

}

五、SpringAOP实现原理

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截。

Spring AOP 动态代理实现：

JDK Proxy （JDK动态代理）
CGLIB Proxy ：默认情况下 Spring AOP 都会采用 CGLIB 来实现动态代理。【效率高】
- CGLIB Proxy 实现原理：通过继承代理对象来实现动态代理（子类拥有父类的所有功能）

织入（Weaving）：代理的生成时机

动态代理的实现

JDK动态代理实现

JDK 实现时，先通过实现 InvocationHandler 接⼝创建⽅法调⽤处理器，再通过 Proxy 来创建代
理类。

import org.example.demo.service.AliPayService;
        import org.example.demo.service.PayService;
        import java.lang.reflect.InvocationHandler;
        import java.lang.reflect.Method;
        import java.lang.reflect.Proxy;
//动态代理：使⽤JDK提供的api（InvocationHandler、Proxy实现），此种⽅式实现，要求被
        代理类必须实现接⼝
public class PayServiceJDKInvocationHandler implements InvocationHandler {

    //⽬标对象即就是被代理对象
    private Object target;

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

    //proxy代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }
    public static void main(String[] args) {
        PayService target= new AliPayService();
        //⽅法调⽤处理器
        InvocationHandler handler =
                new PayServiceJDKInvocationHandler(target);
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                handler
        );
        proxy.pay();
    }
}

CGLIB动态代理实现

import org.springframework.cglib.proxy.Enhancer;
        import org.springframework.cglib.proxy.MethodInterceptor;
        import org.springframework.cglib.proxy.MethodProxy;
        import org.example.demo.service.AliPayService;
        import org.example.demo.service.PayService;
        import java.lang.reflect.Method;
public class PayServiceCGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;

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

    @Override
    public Object intercept(Object o, Method method, Object[] args, Method Proxy methodProxy) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过cglib的代理⽅法调⽤
        Object retVal = methodProxy.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target= new AliPayService();
        PayService proxy= (PayService) Enhancer.create(target.getClass(),n ew PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}

JDK 和 CGLIB 实现的区别

JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏
时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代
理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完
成。
CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的⽣成代理类
对象。