Spring AOP

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

2.2 定义切面和切面

package com.example.demo.common;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect //定义切面
@Component
public class UserAspect {

    //定义切点
    @Pointcut("Execution(* com.example.demo.controller.UserController.*(..))") //拦截规则
    public void pointcut() { }
}

拦截代码：

package com.example.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/getuser")
    public String getUser() {
        System.out.println("do getUser");
        return "get user";
    }

    @RequestMapping("/deluser")
    public String delUser() {
        System.out.println("do delUser");
        return "del user";
    }
}

其中：pointcut 方法为空方法，它不需要有方法体，此方法名就是起到⼀个“标识”的作⽤，标识下⾯的通知方法具体指的是哪个切点（因为切点可能有很多个

切点表达式（拦截规则）：

Execution：执行
*：表示返回值，匹配任意字符，只匹配一个元素（包、类或方法、方法参数），后面跟空格
com.example.demo.controller.UserController：包名+类名
.*：表示这个类下边的所有方法
..：参数，匹配任意字符，可以匹配多个元素，在表示类时，必须和 * 联合使用。
Execution(* com.example.demo.controller.UserController.*(..))：拦截 UserController 里边的所有方法中的所有参数，并且是任意返回值的切点

2.3 执行通知

2.3.1 前置通知

package com.example.demo.common;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect //定义切面
@Component
public class UserAspect {

    //定义切点
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))") //拦截规则
    public void pointcut() { }

    //前置通知
    @Before("pointcut()")
    public void doBefore() {
        System.out.println("执行了前置通知");
    }
}

作为对比，创建一个 ArticleController 类，不做任何拦截：

@RestController
@RequestMapping("/art")
public class ArticleController {
    @RequestMapping("/getart")
    public String getArticle() {
        System.out.println("do getArticle");
        return "getArticle";
    }
}

运行启动类，访问 localhost:8080/art/getart

只是执行了方法本身，通知没有执行

访问 localhost:8080/user/getuser

2.3.2 前置+后置通知

package com.example.demo.common;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect //定义切面
@Component
public class UserAspect {

    //定义切点
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))") //拦截规则
    public void pointcut() { }

    //前置通知
    @Before("pointcut()")
    public void doBefore() {
        System.out.println("执行了前置通知");
    }

    //后置通知
    @After("pointcut()")
    public void doAfter() {
        System.out.println("执行了后置通知");
    }
}

访问 localhost:8080/user/getuser

2.3.3 环绕通知

环绕通知需要传一个固定参数：ProceedingJoinPoint ，并且返回值是 Object

@Aspect //定义切面
@Component
public class UserAspect {

    //定义切点
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))") //拦截规则
    public void pointcut() { }

    //前置通知
    @Before("pointcut()")
    public void doBefore() {
        System.out.println("执行了前置通知");
    }

    //后置通知
    @After("pointcut()")
    public void doAfter() {
        System.out.println("执行了后置通知");
    }

    //环绕通知
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知执行之前");
        //执行目标方法
        Object result = joinPoint.proceed();
        System.out.println("环绕通知执行之后");
        return result;
    }
}

访问 localhost:8080/user/getuser

环绕通知：把整个执行过程放在一个方法中，进行原子性操作

例如统计目标执行的时间，前置和后置通知很难去写，单个统计是ok的，如果是多线程，前置方法和后置方法是非原子性的会出现混乱；但是环绕通知是在一个方法中，通过加锁进行目标执行的时间统计

3.Spring AOP 实现原理——动态代理

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

AOP 常见实现技术有以下两种：

静态代理：静态代理是一种在编译时就已经确定代理关系的代理方式。在静态代理中，代理类和被代理类都要实现同一个接口或继承同一个父类，代理类中包含了被代理类的实例，并在调用被代理类的方法前后执行相应的操作。静态代理的优点是实现简单，易于理解和掌握，但是它的缺点是需要为每个被代理类编写一个代理类，当被代理类的数量增多时，代码量会变得很大。
动态代理：动态代理是一种在运行时动态生成代理类的代理方式。在动态代理中，代理类不需要实现同一个接口或继承同一个父类，而是通过 Java 反射机制动态生成代理类，并在调用被代理类的方法前后执行相应的操作。动态代理的优点是可以为多个被代理类生成同一个代理类，从而减少了代码量，但是它的缺点是实现相对复杂，需要了解 Java 反射机制和动态生成字节码的技术。

例如：假设一个宿舍有三个人（张三李四王五）同一时间点了同一家外卖，配送到达之后；在没有动态代理，那就是需要自己去取（三个人各自取各自的，需要每人去跑一趟），如果有动态代理，这个时候就可以让赵六（代理）帮忙去取三个人的外卖只需要跑一趟。

在统一的动态代理中，写一个用户拦截方法（例如添加文章、修改方法和删除方法中每个方法都需要写一个用户判断操作），如果有动态代理只需要写一个操作即可

调用者首先来到代理对象中，代理对象会经过一个判定，去代理目标对象实现 AOP

动态代理使用 JDK Proxy 和 CGLIB 实现

实现了接口的类，使用 AOP 会基于 JDK 生成代理类；没有实现接口的类，会基于 CGLIB 生成代理类（通过实现代理类的子类实现动态代理，被 final 修饰的类是不能被代理）

3.1 JDK 动态代理

JDK 动态代理是一种使用 Java 标准库中的 java.lang.reflect.Proxy 类来实现动态代理的技术。在 JDK 动态代理中，被代理类必须实现一个或多个接口，并通过 InvocationHandler 接口来实现代理类的具体逻辑。

具体来说，当使用 JDK 动态代理时，需要定义一个实现 InvocationHandler 接口的类，并在该类中实现代理类的具体逻辑。然后，通过 Proxy.newProxyInstance() 方法来创建代理类的实例。该方法接受三个参数：类加载器、代理类要实现的接口列表和 InvocationHandler 对象，如下代码所示：

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();
    }
}

JDK 动态代理的优点是实现简单，易于理解和掌握，但是它的缺点是只能代理实现了接口的类，无法代理没有实现接口的类。

3.2 CGLIB 动态代理

GLIB 动态代理是一种使用 CGLIB 库来实现动态代理的技术。在 CGLIB 动态代理中，代理类不需要实现接口，而是通过继承被代理类来实现代理。具体来说，当使用 CGLIB 动态代理时，需要定义一个继承被代理类的子类，并在该子类中实现代理类的具体逻辑。然后，通过 Enhancer.create() 方法来创建代理类的实例。该方法接受一个类作为参数，表示要代理的类，如下代码所示：

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, MethodProxy 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(),new PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}

CGLIB 动态代理的优点是可以代理没有实现接口的类，但是它的缺点是实现相对复杂，需要了解 CGLIB 库的使用方法。

3.3 JDK Proxy VS CGLIB

JDK Proxy 来自于 Java；CGLIB 属于三方
JDK 动态代理基于接口，要求目标对象实现接口；CGLIB 动态代理基于类，可以代理没有实现接口的目标对象。
JDK 动态代理使用 java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler 来生成代理对象；CGLIB 动态代理使用 CGLIB 库来生成代理对象。
JDK 动态代理生成的代理对象是目标对象的接口实现；CGLIB 动态代理生成的代理对象是目标对象的子类。
CGLIB 动态代理无法代理 final 类和 final 方法；JDK 动态代理可以代理任意类
性能不同：JDK 7后 JDK Proxy 性能是略高于 CGLIB；JDK 7 之前 CGLIB 性能高于 JDK Proxy

奋斗小温

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring AOP

AOP（Aspect Oriented Programming）：面向切面编程，它是⼀种思想，它是对某⼀类事情的集中处理；AOP由切面（横切关注点的模块化单元，它将通知和切点组合在一起，描述了在何处、何时和如何应用横切关注点）、切点（用于定义哪些连接点被切面关注，即切面要织入的具体位置）、连接点（在程序执行过程中的某个特定点，例如方法调用、异常抛出）、通知（在特定切点上执行的代码，包括在连接点之前、之后或周围执行行为）、织入组成；AOP实现原理由 JDK Proxy 动态代理和 CGLIB 动态代理实现
复制链接

扫一扫