Spring AOP【AOP的基本实现与动态代理JDK Proxy 和 CGLIB区别】
Spring AOP【AOP的基本实现与动态代理JDK Proxy 和 CGLIB区别】
- 一. Spring AOP
-
- 1.1 什么是Spring AOP
- 1.2 Spring AOP的作用
- 1.3 AOP的组成
-
- 1.3.1 切面（Aspect）
- 1.3.2 连接点（Join Point）
- 1.3.3 切点（Pointcut）
- 1.3.4 通知（Advice）
- 二.Spring AOP的基本实现
-
- 2.1 添加 Spring AOP 框架⽀持
- 2.2 定义切面和切点
-
- 2.2.1创建切面和切点
- 2.2.2 切点的表达式说明
- 2.3 自定义相关通知
-
- 2.3.1 前置通知 (@Before)
- 2.3.2 后置通知 (@After)
- 2.3.3 返回之后通知 (@AfterReturning)
- 2.3.4 抛异常后通知 (@AfterThrowing)
- 2.3.5 环绕通知 (@Around)
- 三.动态代理
-
- 3.1 Spring AOP动态代理
- 3.2 JDK 和 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 整个组成部分的概念如下图所示，以多个⻚⾯都要访问⽤户登录权限为例：
接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能，完成的⽬标是拦截所有 UserController ⾥⾯的⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件
Spring AOP 的实现步骤如下：
- 添加 Spring AOP 框架⽀持
- 定义切⾯和切点
- 定义通知
2.1 添加 Spring AOP 框架⽀持
在 pom.xml 中添加如下配置：
org.springframework.boot
spring-boot-starter-aop
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(){
}
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("前置通知:被执行了");
}
我们可以看到前置通知是能在实现方法前先打印在控制台
2.3.2 后置通知 (@After)
@After("pointcut()")
public void doAfter(){
System.out.println("后置通知:被执行了");
}
2.3.3 返回之后通知 (@AfterReturning)
@AfterReturning("pointcut()")
public void doAfterReturning(){
System.out.println("执行了AfterReturning方法");
}
我们可以看到返回之后通知实在后置通知之后的
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方法");
}
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;
}
三.动态代理
3.1 Spring AOP动态代理
Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截
Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下，实现了接⼝的类，使⽤ AOP 会基于 JDK ⽣成代理类，没有实现接⼝的类，会基于 CGLIB ⽣成代理类
织⼊（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 实现的区别
- JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完成
- CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的⽣成代理类对象
JDK 和 CGLIB 实现的区别:
● JDK是官方提供的, CGLIB是第三方提供的
● JDK实现动态代理性能不高,CGLIB实现动态代理性能高
● JDK可以实现带有final修饰类,CGLIB不可以实现带有final修饰类
