SpringAOP

SpringAOP

AOP（Aspect-Oriented Programming）面向切面编程，是通过预编译方式和运行期间动态代理实现程序的统一维护的一种技术,

相关概念

连接点（Jointpoint）

表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为在哪里干；

切入点（Pointcut）： 选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为在哪里干的集合；

• 通知（Advice）：在连接点上执行的行为，通知提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置通知（before advice）、后置通知(after advice)、环绕通知（around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入通知；在AOP中表示为干什么；

• 方面/切面（Aspect）：横切关注点的模块化，比如上边提到的日志组件。可以认为是通知、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为在哪干和干什么集合；

• 引入（inter-type declaration）：也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为干什么（引入什么）；

• 目标对象（Target Object）：需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被通知的对象，从而也可称为被通知对象；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为对谁干；

• 织入（Weaving）：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。在AOP中表示为怎么实现的；

• AOP代理（AOP Proxy）：AOP框架使用代理模式创建的对象，从而实现在连接点处插入通知（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。在AOP中表示为怎么实现的一种典型方式

• 前置通知

  前置通知在目标方法执行之前执行，用于在方法执行前做一些准备工作或者进行一些前置条件的检查。如果前置通知抛出异常或者返回了一个 false 值，那么目标方法将不会被执行。

  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.Before;
  import org.springframework.stereotype.Component;
  
  @Aspect
  @Component
  public class MyAspect {
  
      @Before("execution(* com.example.demo.service.*.*(..))")
      public void beforeMethodExecution() {
          System.out.println("Before method execution: logging...");
      }
  }

• 后置通知

  后置通知在目标方法执行之后（无论是否发生异常）执行。它通常用于执行一些清理操作或者记录方法的执行结果。

  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.After;
  import org.springframework.stereotype.Component;
  
  @Aspect
  @Component
  public class MyAspect {
  
      @After("execution(* com.example.demo.service.*.*(..))")
      public void afterMethodExecution() {
          System.out.println("After method execution: cleaning up...");
      }
  }

• 返回通知

  返回通知在目标方法成功执行并返回结果后执行。可以通过该通知获取目标方法的返回值，并对其进行处理。

  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.AfterReturning;
  import org.springframework.stereotype.Component;
  
  @Aspect
  @Component
  public class MyAspect {
  
      @AfterReturning(pointcut = "execution(* com.example.demo.service.*.*(..))", returning = "result")
      public void afterMethodExecution(Object result) {
          System.out.println("After method execution: result = " + result);
      }
  }

• 异常通知

  异常通知在目标方法抛出异常时执行。可以通过该通知捕获异常并进行相应的处理。

  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.AfterThrowing;
  import org.springframework.stereotype.Component;
  
  @Aspect
  @Component
  public class MyAspect {
  
      @AfterThrowing(pointcut = "execution(* com.example.demo.service.*.*(..))", throwing = "ex")
      public void afterMethodExecution(Exception ex) {
          System.out.println("After method execution: Exception caught: " + ex.getMessage());
      }
  }

1. 添加依赖

首先，确保你的 Spring Boot 项目中添加了必要的 AOP 依赖。在 Maven 项目中，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. 创建切面类

一个切面类是用来定义横切逻辑的 Java 类。这些逻辑可以在应用程序的多个地方重复使用，例如日志记录、性能测量等。切面类需要使用@Aspect注解进行标记。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.demo.service.*.*(..))")
    public void beforeMethodExecution() {
        System.out.println("Before method execution: logging...");
    }
}

在上述例子中，我们创建了一个名为LoggingAspect的切面类，并在该类中定义了一个前置通知（使用@Before注解）。该通知会在com.example.demo.service包中所有方法执行之前打印一条日志。

通知类型

3. 定义切入点表达式

切入点表达式是用来指定哪些连接点（方法）将会被切面所影响。在上面的例子中，切入点表达式为execution(* com.example.demo.service.*.*(..))，其中*表示任意返回类型和方法名，(..)表示任意参数。

4. 启用 AOP

为了使 AOP 起作用，需要在 Spring Boot 应用程序的主类中添加@EnableAspectJAutoProxy注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableAspectJAutoProxy
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

5. 测试切面效果

现在，你已经完成了 AOP 的设置。可以在你的业务代码中调用com.example.demo.service包中的任何方法，然后观察控制台中的输出。你将会看到类似以下的日志输出：

Before method execution: logging...

这就证明了 AOP 切面已经成功地拦截了业务方法的执行，并在之前打印了日志。

注意：以上示例只是 AOP 的基本用法，实际应用中可能涉及更复杂的场景，例如使用不同类型的通知（前置、后置、环绕等）、定义更复杂的切入点表达式等。你可以根据自己的需求来扩展和定制切面。

希望这份 Spring Boot AOP 使用指南能对你有所帮助，祝你在开发过程中取得成功！

参考文档

• 官方文档

Demo

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class DemoAspect {

    /**
     * 定义切入点
     */
    @Pointcut("execution(* cn.devcxl.cms.login.LoginVerification+.verify(..))")
    private void pointcut() {
    }

    /**
     * 前置通知
     *
     * @param joinPoint
     */
    @Before("pointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        log.info("切入点之前处理");
    }

    /**
     * 环绕通知
     */
    @Around("pointcut()")
    public void around() {

    }

    /**
     * 后置通知
     */
    @After("pointcut()")
    public void afterMethodExecution() {
        log.info("切入点之前处理");
    }


    /**
     * 返回通知
     *
     * @param result
     */
    @AfterReturning(pointcut = "pointcut()", returning = "result")
    public void afterMethodExecution(Object result) {
        System.out.println("After method execution: result = " + result);
    }


    /**
     * 异常通知
     *
     * @param ex
     */
    @AfterThrowing(pointcut = "pointcut()", throwing = "ex")
    public void afterMethodExecution(Exception ex) {
        System.out.println("After method execution: Exception caught: " + ex.getMessage());
    }
}