Spring AOP 核心概念与实战：面向切面编程详解

注解解释:

• Aspect => 标识切面类
• Component => 将该类交给 Spring 容器管理，使其能自动扫描并注入
• Around => 指明对哪些方法生效
• Slf4j => 自动生成日志对象，可调用 log.info() 等方法打印日志

Spring AOP 的核心术语

理解这些术语是掌握 AOP 的关键：

1. Aspect（切面）：
   • 是什么：横切关注点的模块化。它是一个类，里面包含了需要被织入到业务代码中的各种通知（Advice）。包含了切点、通知、连接点。
2. Join Point（连接点）：
   • 是什么：程序执行过程中可以插入切面的点。在 Spring AOP 中，连接点总是代表执行的方法。
3. Pointcut（切点）：
   • 是什么：一个表达式，用于定义在哪些连接点上应用通知。它告诉 AOP：'在哪里' 执行切面代码。例如，你可以定义一个切点，匹配所有 com.example.service 包下以 delete 开头的方法。
4. Advice（通知）：
   • 是什么：切面在特定连接点上执行的动作。指具体要做的⼯作，指哪些重复的逻辑，它回答了'什么时候'和'做什么'的问题。
   • 类型：
     • @Before：在目标方法执行之前执行。
     • @After：在目标方法执行之后执行（无论是否成功完成）。
     • @AfterReturning：在目标方法成功执行并返回结果后执行。
     • @AfterThrowing：在目标方法抛出异常后执行。
     • @Around：最强大的通知，它包围了连接点。可以在方法调用前后执行自定义行为，并决定是否继续执行方法、返回值或抛出异常。

3.通知类型注解

写两个方法，用于测试。

package com.example.springaopdemo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/t1")
    public String t1(){
        log.info("执行 t1");
        return "t1";
    }
    @RequestMapping("/t2")
    public boolean t2(){
        log.info("执行 t2");
        throw new RuntimeException("Test Exception"); // 模拟异常
    }
}

编写 AOP。

package com.example.springaopdemo.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TestAspect {
    // 抽取切点
    @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))")
    public void pt(){}

    // 前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 doBefore 方法");
    }

    // 后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 After 方法");
    }

    // 返回后通知
    @AfterReturning("pt()")
    public void doAfterReturning() {
        log.info("执行 AfterReturning 方法");
    }

    // 抛出异常后通知
    @AfterThrowing(pointcut = "pt()", throwing = "e")
    public void doAfterThrowing(Exception e) {
        log.info("执行 doAfterThrowing 方法");
    }

    // 添加环绕通知
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        log.info("Around 方法开始执行");
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("Around 方法结束执行");
        return result;
    }
}

4.@PointCut+@Order

@PointCut

在上面中存在大量的同样的切点表达式，使用该注解能够定义可重用的切点表达式，避免在多个通知中重复编写相同的表达式。

通过@PointCut 注解定义一个公共切点方法，该方法本身没有实现，仅作为切点表达式的载体：

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}

重用切点表达式

定义好的切点可以在其他通知中通过方法名引用，避免重复编写表达式：

@Before("serviceLayer()")
public void beforeService() { 
    // 前置通知逻辑 
}
@After("serviceLayer()")
public void afterService() { 
    // 后置通知逻辑 
}

@Order 用于设置优先级，控制多个切面的执行顺序，@Order() 中的数字越小，优先级越高。

@Component
@Aspect
@Slf4j
public class TestAspect2 {
    @Before("com.example.springaopdemo.aspect.TestAspect.pt()")
    public void doBefore() {
        log.info("执行 doBefore2 方法");
    }
}

@Component
@Aspect
@Slf4j
public class TestAspect3 {
    @Before("com.example.springaopdemo.aspect.TestAspect.pt()")
    public void doBefore() {
        log.info("执行 doBefore3 方法");
    }
}

@Aspect
@Component
@Slf4j
public class TestAspect {
    // 抽取切点
    @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))")
    public void pt(){}
    // 前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 doBefore 方法");
    }
}

执行结果：也就是切面默认执行顺序 (按照类名排序)。

通过添加@Order 注解可以人为控制切面执行顺序。

@Order(3)
public class TestAspect(){}

@Order(2)
public class TestAspect2(){}

@Order(1)
public class TestAspect3(){}

添加之后执行结果：

5.切点表达式

有两种：

第一种 execution(<访问修饰符><返回类型><包名。类名。方法名 (方法参数)><异常>)。

其中访问修饰符和异常可以省略，"*" 匹配任意字符，".." 匹配多个连续符号。

第二种 @annotation => 自定义注解。

相比较第一种有一定规律来说，想要执行的方法没有规律可以使用这种。

// 自定义注解
@Retention(RetentionPolicy.RUNTIME) // 设置生命周期
@Target({ElementType.METHOD}) // 设置注解使用位置
public @interface TimeRecord { }

// 注解通过切面实现
@Aspect
@Component
@Slf4j
public class TimeRecordAspect {
    @Around("@annotation(com.example.springaopdemo.aspect.TimeRecord)")
    public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature() + "耗时" + (end - start) + "ms");
        return result;
    }
}

注解完成自定义之后，只要在对应方法添加该注解即可实现计算方法运行时间的功能。

6.代理模式

它为另一个对象提供一个替身或占位符，以控制对这个对象的访问。其核心目的是：在不修改原始对象（目标对象）代码的前提下，通过代理对象来增强或控制对目标对象的访问。

一个标准的代理模式通常包含三个角色：

• 抽象主题 (Subject)：定义了目标对象和代理对象的公共接口。这样在任何使用目标对象的地方都可以透明地使用代理对象。
• 真实主题 (Real Subject)：即'目标对象'，是业务逻辑的真正执行者。
• 代理 (Proxy)：持有对真实主题的引用，客户端直接与代理交互。代理可以在调用真实主题的前后，添加额外的处理逻辑。

分为静态代理和动态代理，区别在于代理对象的 class 文件生成的时机。

• 静态代理:程序运行之前就创建好了代理对象。
• 动态代理:程序运行时动态生成代理对象。

其中动态代理有两种：

• JDK 动态代理 => 要求目标类必须实现至少一个接口。代理对象会实现与目标类相同的接口。
• CGLIB 字节码增强 => 当目标类没有实现接口时，Spring 会使用 CGLIB。它通过生成目标类的子类来创建代理，因此不能代理 final 类或方法。

7.Spring AOP 原理

Spring AOP 是通过动态代理将横切关注点 (如日志、事务) 模块化，并织入到目标方法的编程范式。

它的实现同时使用了 JDK 和 CGLIB。

工作流程：

1. Spring 容器启动时，会自动扫描被@Aspect 注解的类。
2. 通过扫描切点表达式，找到所有匹配的 Bean（即目标对象）。
3. 通过 ProxyFactory 创建目标对象对应的代理对象 (JDK/CGLIB) 并将通知封装成拦截器链。
4. 在调用代理对象方法时，拦截器链被触发，按顺序执行通知逻辑，最终调用目标方法。

此外 ProxyFactory 有个很重要的属性 proxyTargetClass，

SpringBoot 默认为 true，Spring 默认为 false。

可以通过在 application.properties 中进行配置：spring.aop.proxy-target-class=true/false。