Spring AOP【AOP的基本实现与动态代理JDK Proxy 和 CGLIB区别】

简介: Spring AOP【AOP的基本实现与动态代理JDK Proxy 和 CGLIB区别】

🍎一. Spring AOP


🍒1.1 什么是Spring AOP


在介绍 Spring AOP 之前,⾸先要了解⼀下什么是 AOP?


AOP(Aspect Oriented Programming)

面向切⾯编程,它是⼀种思想,它是对某⼀类事情的集中处理。


⽐如⽤户登录权限的效验,没学 AOP 之前,我们所有需要判断⽤户登录的⻚⾯(中的⽅法),都要各⾃实现或调⽤⽤户验证的⽅法,然⽽有了 AOP 之后,我们只需要在某⼀处配置⼀下,所有需要判断⽤户登录⻚⾯(中的⽅法)就全部可以实现⽤户登录验证了,不再需要每个⽅法中都写相同的⽤户登录验证了


⽽ AOP 是⼀种思想,⽽ Spring AOP 是⼀个框架,提供了⼀种对 AOP 思想的实现,它们的关系和IoC 与 DI 类似


🍒1.2 Spring AOP的作用


我们之前的处理⽅式是每个 Controller 都要写⼀遍⽤户登录验证,然⽽当你的功能越来越多,那么你要写的登录验证也越来越多,⽽这些⽅法⼜是相同的,这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢?答案是有的,对于这种功能统⼀,且使⽤的地⽅较多的功能,就可以考虑 AOP来统⼀处理了


除了统⼀的⽤户登录判断之外,AOP 还可以实现:


● 统⼀日志记录

● 统⼀方法执⾏时间统计

● 统⼀的返回格式设置

● 统⼀的异常处理

● 事务的开启和提交等


也就是说使⽤ AOP 可以扩充多个对象的某个能⼒,所以 AOP 可以说是 OOP(Object OrientedProgramming)⾯向对象编程,的补充和完善


🍒1.3 AOP的组成


🍉1.3.1 切面(Aspect


切⾯(Aspect)由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包括了连接点的定义

切⾯是包含了:通知、切点和切⾯的类,相当于 AOP 实现的某个功能的集合


🍉1.3.2 连接点(Join Point)


应⽤执⾏过程中能够插⼊切⾯的⼀个点,这个点可以是⽅法调⽤时,抛出异常时,甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中,并添加新的⾏为,相当于我们的(客户端)

连接点相当于需要被增强的某个 AOP 功能的所有⽅法


🍉1.3.3 切点(Pointcut)


Pointcut 是匹配 Join Point 的谓词

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


切点相当于保存了众多连接点的⼀个集合(如果把切点看成⼀个表,⽽连接点就是表中⼀条⼀条的数据)


🍉1.3.4 通知(Advice)


切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中,切⾯的⼯作被称之为通知

通知:定义了切⾯是什么,何时使⽤,其描述了切⾯要完成的⼯作,还解决何时执⾏这个⼯作的问题


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


● 前置通知使⽤ @Before:通知⽅法会在⽬标⽅法调⽤之前执⾏

● 后置通知使⽤ @After:通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤

● 返回之后通知使⽤ @AfterReturning:通知⽅法会在⽬标⽅法返回后调⽤

● 抛异常后通知使⽤ @AfterThrowing:通知⽅法会在⽬标⽅法抛出异常后调⽤

● 环绕通知使⽤ @Around:通知包裹了被通知的⽅法,在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为


🍎二.Spring AOP的基本实现


AOP 整个组成部分的概念如下图所示,以多个⻚⾯都要访问⽤户登录权限为例:


3f1e41a0779b4d2c8b0cdad5800199c6.png

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

Spring AOP 的实现步骤如下:


  1. 添加 Spring AOP 框架⽀持
  2. 定义切⾯和切点
  3. 定义通知


🍒2.1 添加 Spring AOP 框架⽀持

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


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

🍒2.2 定义切面和切点

🍉2.2.1创建切面和切点


切点指的是具体要处理的某⼀类问题,⽐如⽤户登录权限验证就是⼀个具体的问题,记录所有⽅法的执⾏⽇志就是⼀个具体的问题,切点定义的是某⼀类问题

Spring AOP 切点的定义如下,在切点中我们要定义拦截的规则,具体实现如下:

package com.example.demo.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;
@Aspect //当前类是一个切面
@Component
public class UserAspect {
    // 定义一个切点 (设置拦截规则)
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){
    }

03f4966d217e40f68a24f7aee51b6c37.png


🍉2.2.2 切点的表达式说明


AspectJ ⽀持三种通配符:


(*) :匹配任意字符,只匹配⼀个元素(包,类,或⽅法,⽅法参数)

(…) :匹配任意字符,可以匹配多个元素 ,在表示类时,必须和 * 联合使⽤。

(+) :表示按照类型匹配指定类的所有类,必须跟在类名后⾯,如 com.cad.Car+ ,表示继承该类的所有⼦类包括本身


切点表达式由切点函数组成,其中 execution() 是最常⽤的切点函数,⽤来匹配⽅法,语法为:

切点表达式说明**execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)**

其中权限修饰符与异常项一般省略,返回类型方法以及参数不可省略,其他项可以省略


权限修饰符(省略):

填写权限修饰符,就只会匹配相应修饰符修饰的方法省略,权限不作为限制,所有权限修饰符的方法都会匹配


返回类型,必须参数,不可省略:

填写具体返回类型,就匹配相应返回类型的方法

*表示匹配所有返回值类型的方法


包,类,一般情况下要有,但是可以省略:

填写包和类,就只匹配你所规定的包或类

*表示匹配某目录下所有的包或者类

+作用在类上,匹配该类以及继承该类的所有子类


方法,表示需要匹配方法的名字,参数表示需要匹配参数列表的类型,不可省略:

指定方法名和参数列表,就只匹配你所限定的方法

*可以作用在方法匹配字段上,表示匹配某类中所有的方法

…可以作用在参数列表上,对参数列表类型不做限制


异常(省略):可以匹配抛出指定异常的方法,该参数一般省略

表达式示例:

要记得放回类型 * 要与包名有一个空格


表达式 说明
execution(* com.cad.demo.User.*(…)) 匹配 User 类⾥的所有⽅法
execution(* com.cad.demo.User+.*(…)) 匹配该类的⼦类包括该类的所有⽅法
execution(* com.cad..(…)) 匹配 com.cad 包下的所有类的所有⽅法
execution(* com.cad….(…)) 匹配 com.cad 包下、⼦孙包下所有类的所有⽅法
execution(* addUser(String, int)) 匹配 addUser ⽅法,且第⼀个参数类型是 String,第⼆个参数类型是 int


🍒2.3 自定义相关通知


我们先实现切面定义在的类

@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/sayhi")
    public String sayHi(){
        System.out.println("你好,世界!");
        return "你好,世界!";
    }
}

🍉2.3.1 前置通知 (@Before)


// 定义通知
    @Before("pointcut()")
    public void doBefire(){
        System.out.println("前置通知:被执行了");
    }


我们可以看到前置通知是能在实现方法前先打印在控制台


32a37ac3b8164c4b819412d650241437.png


🍉2.3.2 后置通知 (@After)

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

295e1a7bc3c04fa19c0f3df496b551e2.png


🍉2.3.3 返回之后通知 (@AfterReturning)

    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        System.out.println("执行了AfterReturning方法");
    }

我们可以看到返回之后通知实在后置通知之后的

cfdfb6b6d922474c99122f6ccf62d2b0.png


🍉2.3.4 抛异常后通知 (@AfterThrowing)


我们来实现一个抛出异常错误的方法

 @RequestMapping("/sayhi")
    public String sayHi(){
        System.out.println("你好,世界!");
        int num = 10 / 0;
        return "你好,世界!";
    }
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        System.out.println("执行了AfterThrowing方法");
    }

9ded11c5891f48ffb92cbe8a195969f6.png


🍉2.3.5 环绕通知 (@Around)

我们来通过环绕通知实现一个统计方法执行的时间通知的功能

这个使用System.currentTimeMillis()方法统计的时间不够准确

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


我们应该使用 StopWatch stopWatch = new StopWatch()

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

7b86d13c96e34ae3a6509db6902f6e47.png


🍎三.动态代理

🍒3.1 Spring AOP动态代理


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


Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下,实现了接⼝的类,使⽤ AOP 会基于 JDK ⽣成代理类,没有实现接⼝的类,会基于 CGLIB ⽣成代理类



15b74a5ca7094ef5a44f1cc8a6fa407d.png



织⼊(Weaving):代理的⽣成时机


织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程,切⾯在指定的连接点被织⼊到⽬标对象中


在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊:

● 编译期:切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的


● 类加载期:切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器(ClassLoader),它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊(load-time weaving. LTW)就⽀持以这种⽅式织⼊切⾯


● 运⾏期:切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下,在织⼊切⾯时,AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的


此种实现在设计模式上称为动态代理模式,在实现的技术⼿段上,都是在 class 代码运⾏期,动态的织⼊字节码

我们学习 Spring 框架中的AOP,主要基于两种⽅式:JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法,在运⾏期,动态的织⼊字节码⽣成代理类


●CGLIB是Java中的动态代理框架,主要作⽤就是根据⽬标类和⽅法,动态⽣成代理类

●Java中的动态代理框架,⼏乎都是依赖字节码框架(如 ASM,Javassist 等)实现的

●字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码⽂件信息,修改部分信息,或动态⽣成⼀个 class动态代理


🍒3.2 JDK 和 CGLIB 实现的区别


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


JDK 和 CGLIB 实现的区别:

● JDK是官方提供的, CGLIB是第三方提供的

● JDK实现动态代理性能不高,CGLIB实现动态代理性能高

● JDK可以实现带有final修饰类,CGLIB不可以实现带有final修饰类



a3388beaca5b4e7aa6d8ebcfde75da15.jpg

相关文章
|
4天前
|
Java Maven 数据安全/隐私保护
详解 Java AOP:面向方面编程的核心概念与 Spring 实现
详解 Java AOP:面向方面编程的核心概念与 Spring 实现
16 1
|
2天前
|
设计模式 网络安全 开发工具
|
2天前
|
XML 安全 Java
Spring高手之路19——Spring AOP注解指南
在本文中,我们将深入探索Spring AOP(面向切面编程)的核心概念及其在现代Spring应用中的实际应用。从基本的注解使用到复杂的切面配置,本文将一步步指导你如何利用Spring AOP提升代码的模块化,帮助你在Spring开发路上更进一步。
16 3
Spring高手之路19——Spring AOP注解指南
|
4天前
|
缓存 Java uml
Spring压轴题:当循环依赖遇上Spring AOP
Spring压轴题:当循环依赖遇上Spring AOP
13 1
|
6天前
|
XML 监控 Java
Java一分钟之-Spring AOP:基于Spring的AOP
【6月更文挑战第13天】Spring框架集成AOP支持,便于实现如日志、监控和事务管理等关注点的集中管理。本文探讨Spring AOP的核心概念(切面、切入点、通知和代理),常见问题(代理对象理解不清、切入点表达式错误、通知类型混淆和事务管理配置不当)及其对策,并提供注解式日志记录代码示例。通过学习和实践,开发者能更好地运用Spring AOP提升代码质量。
16 2
|
15天前
|
Java Spring
【JavaEE进阶】 Spring AOP源码简单剖析
【JavaEE进阶】 Spring AOP源码简单剖析
|
15天前
|
Java Spring
【JavaEE进阶】 Spring AOP详解
【JavaEE进阶】 Spring AOP详解
|
15天前
|
数据采集 Java 程序员
【JavaEE进阶】 Spring AOP快速上手
【JavaEE进阶】 Spring AOP快速上手
|
21天前
|
Java Spring
|
21天前
|
Java Spring