0
0

Spring AOP 动态代理

文章目录

提示：以下是本篇文章正文内容，Java系列学习将会持续更新

一、认识 Spring AOP

1-1 什么是 Spring AOP？

AOP（Aspect Oriented Programming）：面向切面编程，它是一种思想，它是对某一类事情的集中处理。比如用户登录权限的效验，没学 AOP 之前，我们所有需要判断用户登录的方法，都要各自实现或调用用户验证。然而有了 AOP 之后，我们只需要在某一处配置一下，就可以一下实现所有的用户登录验证了，不再需要每个方法中都写相同代码。对于这种功能统一，且使用的地方较多的功能，就可以考虑 AOP来统一处理了。

而 AOP 是一种思想，而 Spring AOP 是一个框架，提供了一种对 AOP 思想的实现，它们的关系和 IoC与 DI 类似。

1-2 AOP 的功能？

除了统一的用户登录验证之外，AOP 还可以实现：

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

也就是说使用 AOP 可以扩充多个对象的某个能力，所以 AOP 可以说是 OOP（Object Oriented
Programming，面向对象编程）的补充和完善。

1-3 如何学习？

Spring AOP 学习主要分为以下 3 个部分：

  1. 学习 AOP 是如何组成的？
  2. 学习 Spring AOP 使用。
  3. 学习 Spring AOP 实现原理。

二、AOP 组成

AOP 整个组成部分的概念如下图所示，以多个页面都要访问用户登录权限为例：
在这里插入图片描述

2-1 切面 @Aspect

切面（

Aspect

）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。

切面类 用

@Aspect

注解修饰。

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

2-2 连接点（Join Point）

应用执行过程中能够插入切面的一个点，这个点可以是方法调用时、抛出异常时、甚至修改字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

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

2-3 切点 @Pointcut

Pointcut

是匹配 连接点 (Join Point) 的谓词。
Pointcut 的作用就是提供一组规则（

使用 AspectJ pointcut expression language 来描述

）来匹配 Join Point，给满足规则的 Join Point 添加 Advice。

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

切点表达式说明，

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-4 通知（Advice）

切面也是有目标的 ——它必须完成的工作。在 AOP 术语中，切面的工作被称之为通知。

通知：定义了切面是什么，何时使用，其描述了切面要完成的工作，还解决何时执行这个工作的问题。

Spring 切面类中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用：

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

切点相当于要增强的方法。

三、Spring AOP 的使用

我们使用 Spring AOP 来实现一下 AOP 的功能，完成的目标是拦截所有 

UserController

里面的方法，每次调用 UserController 中任意一个方法时，都执行相应的通知事件。

Spring AOP 的实现步骤如下：

  1. 添加 Spring AOP 框架支持。
  2. 定义切面和切点。
  3. 定义通知。

3-1 execution 连接法

3-1-1 添加 AOP 框架支持

Spring Boot Starter AOP 官方文档

在 pom.xml 中修改原本的依赖配置：

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

3-1-2 定义切面、切点、通知

用户注册服务的类：

@ServicepublicclassUserService{publicvoidregister(String username,String password){System.out.printf("UserService.register(username = %s, password = %s)\n", username, password);}}

为用户注册服务定义AOP：

importorg.aspectj.lang.ProceedingJoinPoint;importorg.aspectj.lang.annotation.*;importorg.springframework.stereotype.Component;@Component// 1. 首先，把类注册到 Spring 中@Aspect// 2. 需要声明这个类是一个 切面类publicclassUserAspect{/**
     * 定义切点方法: 
     * 通过 AspectJ（市场做 AOP 做的比较早的，而且做的比较强的）
     * 所以 Spring 这里使用 AspectJ 规范语法，但并没有使用 AspectJ 的实现
     * 当执行 com.example.aop.UserService 下的任意方法(*)
     * 方法的参数不限(..)
     * 返回值类型不限 *
     */@Pointcut("execution(* com.example.aop.UserService.*(..))")publicvoidpointcut(){}// 前置通知: 表示在切点方法之前执行@Before("pointcut()")// 切点方法名publicvoiddoBefore(){System.out.println("执行 Before 方法");}// 后置通知@After("pointcut()")publicvoiddoAfter(){System.out.println("执行 After 方法");}// return 之前通知@AfterReturning("pointcut()")publicvoiddoAfterReturning(){System.out.println("执行 AfterReturning 方法");}// 抛出异常之前通知@AfterThrowing("pointcut()")publicvoiddoAfterThrowing(){System.out.println("执行 doAfterThrowing 方法");}// 添加环绕通知@Around("pointcut()")publicObjectdoAround(ProceedingJoinPoint joinPoint){Object obj =null;System.out.println("Around 方法开始执行");try{// 执行拦截方法
            obj = joinPoint.proceed();}catch(Throwable throwable){
            throwable.printStackTrace();}System.out.println("Around 方法结束执行");return obj;}}

3-1-3 调用 AOP

@SpringBootApplicationpublicclassAopApplication{publicstaticvoidmain(String[] args){SpringApplication.run(AopApplication.class, args);//        可以在主方法中直接调用//        UserServiceImpl userService = new UserServiceImpl();//        userService.register("wangshaoyu", "123456");}@Bean// 也可以在加载数据时调用: 服务启动执行，执行加载数据等操作publicCommandLineRunnerrunner(UserServiceImpl userService){returnnewCommandLineRunner(){@Overridepublicvoidrun(String... args)throwsException{
                userService.register("wangshaoyu","123456");}};}}

3-2 @annotation 自定义切点注解

①自定义切点注解：

@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public@interfaceSomePointcut{}

②定义切面类：

@Component@AspectpublicclassMyAspect{// 将一个注解定义成 切点，哪个方法需要 AOP，就可以把这个注解修饰在方法上@Pointcut("@annotation(com.example.aop.SomePointcut)")// 指向自定义注解publicvoidsomePointcut(){}@Before("somePointcut()")publicvoidbeforeMethodInvoked(){System.out.println("MyAspect.beforeMethodInvoked()");}@After("somePointcut()")publicvoidafterMethodInvoked(){System.out.println("MyAspect.afterMethodInvoked()");}}

③使用自定义注解 修饰要连接切面的方法：

@ComponentpublicclassCourseService{@SomePointcut// 执行 add() 方法，会被代理publicvoidadd(String name){System.out.println("CourseService.add(), name = "+ name);}publicvoiddelete(String name){System.out.println("CourseService.delete(), name = "+ name);this.add(name);// 这里会不会去执行 AOP 的两个通知？// 不会，因为这里的 this 指向的就是 CourseService 对象本身，所以没有代理}}

四、Spring AOP 实现原理

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

Spring AOP 支持 

JDK Proxy

和 

CGLIB

方式实现动态代理。默认情况下，实现了接口的类，使用 AOP 会基于 JDK 生成代理类；没有实现接口的类，会基于 CGLIB 生成代理类。
在这里插入图片描述

4-1 动态代理

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

我们学习 Spring 框架中的AOP，主要基于两种方式：JDK 及 CGLIB 的方式。这两种方式的代理目标都是被代理类中的方法，在运行期，动态的织入字节码生成代理类。

  • CGLIB 是 Java中的动态代理框架，主要作用就是根据目标类和方法，动态生成代理类。
  • Java 中的动态代理框架，几乎都是依赖字节码框架（如 ASM，Javassist 等）实现的。
  • 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码文件信息，修改部分信息，或动态生成一个 class。

4-2 JDK 和 CGLIB 的区别

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

五、总结

AOP 是对某方面能力的统一实现，它是一种实现思想，Spring AOP 是对 AOP 的具体实现，Spring AOP 可通过 

@AspectJ

（注解）的方式来实现 AOP 的功能。Spring AOP 的实现步骤是：

  1. 添加 AOP 框架支持。
  2. 定义切面和切点。
  3. 定义通知。

Spring AOP 是通过动态代理的方式，在运行期将 AOP 代码植入到程序中的，它的实现方式有两种：

JDK Proxy

和 

CGLIB

。

spring:aop:# true 是 CGLib, 默认为 true# false 是 JDK Proxy（代理对象必须是一个接口）proxy-target-class:false

总结:
提示：这里对文章进行总结：
以上就是今天的学习内容，本文是Spring AOP的学习，学习AOP的思想，AOP的使用(定义切面、切点和通知)，以及两种常用的AOP使用方法。之后的学习内容将持续更新！！！

标签： spring java 后端
本文转载自: https://blog.csdn.net/qq15035899256/article/details/126560766
版权归原作者 一只咸鱼。。 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Spring AOP 动态代理”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

如何构建全生命周期的安全体系架构来确保容器的安全？

使用Selenium与WebDriver实现跨浏览器自动化数据抓取

开源利器：gh-proxy —— 打造你的高速GitHub通道

大数据之Flink（二）

SpringBootWeb增删改查入门案例

Spring的监听机制详解

Ai 编程实战(1)-让 Ai 帮你写一个前端页面

文章导航