解锁Spring AOP的神秘面纱

目录

  • Spring AOP的组成
    • 组成部分与常用注解
    • 举例理解
  • Spring AOP的实现
    • 添加 Spring AOP 框架⽀持
    • 定义切⾯和切点
    • 定义通知
    • 切点表达式说明
  • Spring AOP 实现原理
    • JDK动态代理
    • CGLIB动态代理

Spring AOP作为Spring框架的核心模块,为我们提供了一种优雅的方式来处理横切关注点。本篇博客将从组成、实现和实现原理三个方面深入剖析Spring AOP,并结合具体的例子进行说明。

Spring AOP的组成

组成部分与常用注解

  • 切面(Aspect):切面是横切关注点的具体实现,它定义了在何处、何时执行横切逻辑。我们可以通过切点和通知来定义一个切面。
  • 连接点(Join Point):连接点是方法在程序执行过程中能够被拦截的特定点(这个点可以是⽅法调⽤时,抛出异常时,甚⾄修改字段
    时)。在Spring AOP中,连接点通常表示方法的执行。
  • 切点(Pointcut):切点指定了在哪些方法上应该应用切面逻辑。可以使用表达式或注解等方式来定义切点,精确定位到目标方法。
  • 通知(Advice):通知定义了在切点上执行的横切逻辑,可以在方法执行前、后或抛出异常时被触发。

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

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

举例理解

下面通过一个生活中的例子,我们可以更直观地理解Spring AOP的组成部分及其运作方式。
在这个例子中,我们可以将Spring AOP的组成部分与咖啡馆的场景联系起来:

  1. 切面(Aspect):切面就好像是咖啡馆提供的不同附加服务,比如打包、送货等。每种附加服务都是一个切面,它定义了一个特定的横切逻辑。

  2. 切点(Pointcut):切点就像是决定在哪些情况下应该提供附加服务。例如,每次有人点了咖啡,那就是一个切点,表示一个可以应用附加服务的地方。

  3. 通知(Advice):通知就是具体的附加服务的实现。在咖啡馆中,这可以是将咖啡打包的过程,或者是送货员将咖啡送到指定地点的过程。

  4. 连接点(Join Point):连接点就像是咖啡的准备过程,比如磨咖啡豆、冲泡咖啡等。这些过程都是咖啡制作的特定点,也就是连接点。

当你在咖啡馆点一杯咖啡时,Spring AOP的运作方式如下:

  1. 切面定义了附加服务,比如打包和送货。

  2. 切点决定了在哪些情况下应该提供附加服务,比如在每次点咖啡时。

  3. 通知实现了附加服务的具体逻辑,比如将咖啡打包或送到指定地点。

  4. 连接点是咖啡的制作过程,每个步骤都是一个连接点,而在某些连接点上(即切点匹配的地方),会触发附加服务的通知。

这样,当你点了一杯咖啡时,Spring AOP就会在制作咖啡的过程中,根据切点的匹配情况触发相应的附加服务通知,比如将咖啡打包好或送到指定地点。

Spring AOP的实现

Spring AOP的实现主要依赖于JDK动态代理和CGLIB动态代理两种方式。默认情况下,Spring AOP使用JDK动态代理,但也可以通过配置切换到CGLIB动态代理。

添加 Spring AOP 框架⽀持

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


<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-aopartifactId>
dependency>

定义切⾯和切点

切点指的是具体要处理的某⼀类问题,Spring AOP 切点的定义如下,在切点中我们要定义拦截的规则,具体实现如下:

@Aspect    //表明这个类为一个切面
@Component
public class UserAspect {
  //定义切点,使⽤ AspectJ 表达式语法
    @Pointcut("execution(* com.example.springaop.Controller.UserController.* (..))")
    public void pointcut(){ }  
}

@Pointcut 注解标注的方法是一个空方法,它不需要具体的方法体。它的作用是为下面的通知方法提供一个标识,用来指定具体指向哪个切点。

定义通知

通知定义的是被拦截的⽅法具体要执⾏的业务,比如统一异常处理等待。

依旧是在刚才的切面类UserAspect中书写代码:

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

我们在UserController中写一个测试方法:

@RestController
@ResponseBody
@RequestMapping("/con")
public class UserController {
    @RequestMapping("/tsst")
    public Object test() {
        System.out.println("测试方法执行");
        return "测试";
    }
}

我们在浏览器进行访问测试方法:
在这里插入图片描述
解锁Spring AOP的神秘面纱_第1张图片
通过控制台信息发现前置通知方法的实现在测试方法之前,至于其他通知方法我们也补全于切面类当中

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

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

    @AfterThrowing
    public void doAfterThrowing() {
        System.out.println("执行异常抛出之前的通知方法");
    }

    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object obj = new Object();

        System.out.println("开始执行环绕通知方法");
        try {
            //执行目标方法
            joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("环绕通知方法结束");
        return obj;
    }

可以将环绕通知方法理解为包裹目标方法的一层“包装”,它可以在目标方法执行前后进行一些额外的操作和控制。通过环绕通知,我们可以在不改变目标方法原有逻辑的同时,添加一些横切关注点的功能,例如日志记录、性能监控、事务管理等。

切点表达式说明

AspectJ ⽀持三种通配符

  • *:匹配任意字符,只匹配⼀个元素(包,类,或⽅法,⽅法参数)
  • .. :匹配任意字符,可以匹配多个元素 ,在表示类时,必须和 * 联合使⽤
  • +:表示按照类型匹配指定类的所有类,必须跟在类名后⾯,如com.cad.Car+ ,表示继承该类的所有⼦类包括本身

切点表达式由切点函数组成,其中 execution() 是最常⽤的切点函数,⽤来匹配⽅法,语法为:execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)
其中修饰符与异常可以省略

示例:

execution(* com.cad.demo.User+.*(..))

匹配该类的⼦类包括该类的所有⽅法。

execution(* addUser(String, int))

匹配 addUser ⽅法,且第⼀个参数类型是 String,第⼆个参数类型是 int。

Spring AOP 实现原理

Spring AOP的实现原理主要依赖于动态代理机制。当使用Spring AOP时,它会在运行时为目标对象生成一个代理对象,并将切面逻辑织入到目标对象的方法调用中。
Spring AOP所使用的代理方式可以分为两种:JDK动态代理和CGLIB动态代理。

JDK动态代理

当目标对象实现了至少一个接口时,Spring AOP会使用JDK动态代理来生成代理对象。JDK动态代理是通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现的。

  • 在Spring AOP中,首先会根据目标对象和切面对象,创建一个实现了InvocationHandler接口的代理对象。
  • 当目标对象的方法被调用时,代理对象的invoke()方法会被调用。在invoke()方法内部,可以通过反射机制来执行目标方法,同时在目标方法的执行前后,插入切面逻辑。

CGLIB动态代理

当目标对象没有实现任何接口时,Spring AOP会使用CGLIB动态代理来生成代理对象。CGLIB动态代理是通过继承目标类并重写目标方法的方式实现的。

  • 在Spring AOP中,首先会针对目标对象生成一个继承了目标类的代理类,并在代理类中重写目标方法。
  • 当目标对象的方法被调用时,代理对象的相应重写方法会被调用。在重写方法中,可以在目标方法的执行前后,插入切面逻辑。

总结起来,Spring AOP的实现原理是通过动态代理机制,在运行时为目标对象生成代理对象,并将切面逻辑织入到目标对象的方法中。具体使用JDK动态代理还是CGLIB动态代理取决于目标对象是否实现了接口。

你可能感兴趣的:(JavaEE,spring,java,学习,java-ee,spring,boot)