Spring AOP - 技术栈

文章目录

- 一.AOP基础
- - 1.AOP是什么？
- 二.AOP的组成
- 三.SpringAOP
- - 1.添加依赖
  - 2.定义切⾯和切点
- [三.Spring AOP 实现原理](#三.Spring AOP 实现原理)
- - 1.织入:代理的⽣成时机
  - 2.动态代理

一.AOP基础

1.AOP是什么？

AOP是一种思想,它是对某一类事情的统一处理.例如⽤户登录权限的效验等都需要统一处理

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

统⼀⽇志记录
统⼀⽅法执⾏时间统计
统⼀的返回格式设置
统⼀的异常处理
事务的开启和提交等

使用AOP可以扩充对象的某个能力,可以理解AOP是OOP的补充和完善

二.AOP的组成

1.切面(Aspect)

切面由切点和通知组层,也包含了连接点的定义

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

2.连接点

应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段

时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为。

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

3.切点(Pointcut)

Pointcut 是匹配 Join Point 的谓词。

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

4.通知(Advice)

切面的工作称为通知

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

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

⽅法进⾏调⽤

前置通知使用@Before：通知⽅法会在⽬标⽅法调⽤之前执⾏。
后置通知使⽤ @After：通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤。
返回之后通知使⽤ @AfterReturning：通知⽅法会在⽬标⽅法返回后调⽤。
抛异常后通知使⽤ @AfterThrowing：通知⽅法会在⽬标⽅法抛出异常后调⽤。
环绕通知使⽤ @Around：通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为。

三.SpringAOP

1.添加依赖

复制代码

<!-- 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.定义切⾯和切点

复制代码

@Aspect // 表明此类为⼀个切⾯

@Component

public class UserAspect {
 // 定义切点，这⾥使⽤ AspectJ 表达式语法

 @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
 public void pointcut(){ }
}

函数不需要具体实现,只做一个声明,@Pointcut描述了规则,定义了匹配什么包下面的具体方法

切点表达式说明

AspectJ ⽀持三种通配符

：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）
... ：匹配任意字符，可以匹配多个元素，在表示类时，必须和 * 联合使⽤。

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

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

execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)

修饰符可以省略

throws可以省略

具体实现如下 ：

@Aspect

复制代码

@Component

public class UserAspect {
 // 定义切点⽅法

 @Pointcut("execution(* com.example.demo.controller.UserController.*
(..))")
 public void pointcut(){ }
 // 前置通知

 @Before("pointcut()")
 public void doBefore(){
 System.out.println("执⾏ Before ⽅法");
 }
 // 后置通知

 @After("pointcut()")
 public void doAfter(){
 System.out.println("执⾏ After ⽅法");
 }
 // return 之前通知

 @AfterReturning("pointcut()")
 public void doAfterReturning(){
 System.out.println("执⾏ AfterReturning ⽅法");
 }
 // 抛出异常之前通知

 @AfterThrowing("pointcut()")
 public void doAfterThrowing(){
 System.out.println("执⾏ doAfterThrowing ⽅法");
 }
 
 // 添加环绕通知

 @Around("pointcut()")
 public Object doAround(ProceedingJoinPoint joinPoint){
 Object obj = null;
 System.out.println("Around ⽅法开始执⾏");
 try {
 // 执⾏拦截⽅法

 obj = joinPoint.proceed();
 } catch (Throwable throwable) {
 throwable.printStackTrace();
 }
 System.out.println("Around ⽅法结束执⾏");
 return obj;
 }
}

三.Spring AOP 实现原理

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

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

1.织入:代理的⽣成时机

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

编译期：切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就
是以这种⽅式织⼊切⾯的。
类加载期：切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器
（ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载
时织⼊（load-time weaving. LTW）就⽀持以这种⽅式织⼊切⾯。
运⾏期：切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。

2.动态代理

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

CGLIB是Java中的动态代理框架，主要作⽤就是根据⽬标类和⽅法，动态⽣成代理类。
Java中的动态代理框架，⼏乎都是依赖字节码框架（如 ASM，Javassist 等）实现的。
字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码⽂件信息，修改部分信息，或动态⽣成⼀个 class。

JDK 和 CGLIB 实现的区别

DK 实现，要求被代理类必须实现接⼝,在运⾏时动态的在内存中⽣成了代理类对象
CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的⽣成代理类对象。