SpringAOP面向切面编程

文章目录

  • 一. AOP是什么?
  • 二. AOP相关概念
  • 三. SpringAOP的简单演示
  • 四. SpringAOP实现原理

一. AOP是什么?

AOP(Aspect Oriented Programming):面向切面编程,它是一种编程思想,是对某一类事情的集中处理它能够在不改原有代码的前提下对其功能进行增强,就是你代码已经写好了,使用 AOP 可以在不改动代码的前提下增强功能,如对于一个功能,可以基于 AOP 完成对该功能执行效率的计算,能够在功能正式执行前或者执行后,添加其他的功能执行,能够在该功能发生异常后,对其异常进行处理。

想象一个场景,我们在做后台系统时,除了登录和注册等几个功能不需要做用户登录验证之外,其他几乎所有页面都需要先验证用户登录的状态,那这个时候我们要怎么处理呢?

如果不使用 AOP,我们就需要在每一个 Controller 层都写一遍验证用户是否已经登录的逻辑,如果你实现的功能有很多,并且这些功能都需要进行登录验证,那你就需要编写大量重复的代码, 这样代码修改和维护的成本也会很高。

但如果使用 AOP,在进入核心的业务代码之前会做统一的一个拦截,去验证用户是否登录,验证通过的就可以继续请求,此时就不需要每一处都写相同的用户登录逻辑了。

除了登录验证功能之外,还有很多功能也可以使用 AOP,比如:

  • 统一日志记录与持久化。
  • 统一方法执行时间统计。
  • 统一数据返回格式。
  • 统一处理程序中的异常。
  • 统一事务的开启与提交。

也就是说使用 AOP 可以扩充多个对象的某个能力,所以 AOP 可以说是 OOP (Object Oriented Programming,面向对象编程)的补充和完善,它可以将横切关注点从应用程序的主业务逻辑中分离出来,使得这些关注点可以集中处理,从而提高代码复用性、可维护性和系统可扩展性。

SpringAOP 是一个框架,提供了对 AOP 的实现,与 IOC 与 DI 的关系类似。

二. AOP相关概念

  1. 切面(Aspect)–> 类:某一方面的具体内容处理(AOP实现的某个功能的集合)就是一个切面,由切点(Pointcut)和通知(Advice)组成 ;比如用户登录判断就是一个切面(接口对于登录权限的校验)。
  2. 切点(Pointcut)–>方法:定义拦截规则;比如切面对于哪些接口需要进行判断拦截。
  3. 连接点(Joinpoint):所有可能触发切点的点就是连接点(被这个切面所处理的点)。
  4. 通知(方法的具体实现):执行 AO P业务(具体需要执行的拦截方法)。

在 Spring 切面类中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会调用对应满足条件的方法:

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

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

SpringAOP面向切面编程_第1张图片

三. SpringAOP的简单演示

1️⃣第一步,添加 Spring Boot AOP 依赖支持。

在 SpringBoot 项目中导入 AOP 依赖时可以不设置版本号,SpringBoot 会帮助我们自动适配。

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

2️⃣第二步,定义切面,我们使用@Aspect注解将类标识为切面类,并使用注解 @Component 将类实例化到容器中。

package com.example.demo.common;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

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

3️⃣第三步,定义切点,配置拦截规则,可以使用AspectJ表达式类来进行描述,它的语法格式如下:

切入点表达式标准格式:动作关键字(访问修饰符  返回值  包名./接口名.方法名(参数) 异常名)

AspectJ ⽀持三种通配符:

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

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

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

其中访问修饰符和异常可以省略,比如下面这个表达式:

SpringAOP面向切面编程_第2张图片

任意声明一个方法,不需要具体实现,使用注解@Pointcut修饰,里面的value属性填写AspectJ表达式,这个方法就可以视为连接目标方法的一个切点。

但要注意,这种表达式的书写是非常繁琐的,目前有更好的AOP实现,可以更加灵活的配置,也就是说这里的写法其实并不常用。

代码实现:

@Aspect // 定义切面
@Component
public class UserAspect {
    // 切点
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut() {
    }
}

4️⃣第四步,创建通知。

有了切点,要对切点处的方法进行相关处理,需要编写具体的增强方法,也就是通知,下面我们需要在切面类中简单编写几个方法来表示通知,通知就是将共性功能抽取出来后形成的方法。

要注意对于环绕通知,由于在实现增强方法时,需要介入到方法执行前和后,那么必须得获取到目标的方法,不然无法控制你实现的那些代码是在目标方法执行前执行的,哪些方法是在目标方法执行后执行的。

对于这项工作,SpringAOP 已经帮我们做了,所有的切点方法都已经加载到ProceedingJoinPoint对象当中,只要调用proceed方法就能够执行目标方法。

package com.example.demo.common;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
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("执行了后置通知");
    }

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

5️⃣第五步,创建连接点。

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";
    }
}

此时,就可以启动 SpringAOP 了,然后通过浏览器去访问定义的这两个连接点,看通知效果。

SpringAOP面向切面编程_第3张图片

我们可以在Controller层再创建一个ArticleController类用来对照,访问一下看此时是否会执行通知。

package com.example.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

结果如下:

因为我们设置的拦截规则不包含这个类,也就不会执行通知了。

SpringAOP面向切面编程_第4张图片

SpringAOP面向切面编程_第5张图片

四. SpringAOP实现原理

Spring AOP 是构建在动态代理基础上,因此 Spring 对 AOP 的支持局限于方法级别的拦截(使用动态代理技术实现方法的调用)。

Spring AOP 支持 JDK ProxyCGLIB 方式实现动态代理。默认情况下,实现了接口的类,使用 SpringAOP 会基于 JDK 生成代理类,没有实现接口的类,会基于 CGLIB 生成代理类。

SpringAOP面向切面编程_第6张图片

下面简单的来说一下原理,首先,要有一个目标对象,在上面的例子中,目标对象就是UserController,然后通过基于这个目标对象,创建一个代理类,并在某一规定的时机生成,这个时机就是织入,最后在这个代理类上加上一些增强的方法,这个过程就叫做引入

下面又出来了一组相关概念:

目标对象:代理的目标对象。

织入(weaving): 即代理的生成时机,织入是把切面应用到目标对象并创建新的代理对象的过程,切面在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入∶

  • 编译期∶切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ 的织入编译器就是以这种方式织入切面的。
  • 类加载器∶切面在目标类加载到 JVM 时被织入。这种方式需要特殊的类加载器(ClassLoader),它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5 的加载时织入(load-time weaving.LTW)就支持以这种方式织入切面。
  • 运行期∶切面在应用运行的某一时刻被织入。一般情况下,在织入切面时,AOP 容器会为目标对象动态创建一个代理对象。SpringAOP 就是以这种方式织入切面的。

引入(introduction):在不修改代码的前提下,引入可以在运行期为类动态地添加一些方法或字段。

JDK Proxy 与 CGLIB 的区别:

  1. 出身不同,一个由 JDK 实现,一个由 CGLIB 实现。
  2. 实现不同,JDK Proxy 要求代理类实现接口才能实现代理,它只能代理接口中定义的方法;CGLIB 是通过实现代理类的子类完成动态代理,可以为任意一个类创建代理对象,包括没有实现任何接口的类,它能够代理类中所有非 final 的方法。
  3. 性能不同,JDK7 之后 JDK Proxy 性能是略高于 CGLIB 的; 而在 JDK7 之前 CGLIB 性能是略高于 JDK Proxy 的。

你可能感兴趣的:(JavaEE,java,spring,AOP,面向切面,动态代理)