作为Spring框架的两大核心支柱之一，面向切面编程（AOP，Aspect-Oriented Programming）与控制反转（IOC）相辅相成，共同支撑起Spring“简化Java开发”的核心目标。在实际开发中，日志记录、事务管理、权限校验等大量“横切逻辑”散落于业务代码中，导致代码冗余、耦合度高、维护成本激增。Spring AOP通过“将横切逻辑与业务逻辑分离”的设计思想，完美解决了这一痛点。本文将从核心概念、底层原理、实战应用、进阶拓展四个维度，全面拆解Spring AOP，助力开发者从“会用”到“吃透”。

一、直击核心：什么是Spring AOP？

要理解AOP，首先要明确其解决的核心问题——横切逻辑的分散性。在传统OOP（面向对象编程）开发中，业务逻辑按模块划分（如用户模块、订单模块），但横切逻辑（如日志）会渗透到各个模块中，形成“代码纠缠”。

1.1 AOP的本质：横切逻辑的抽离与织入

AOP的核心思想是：抽离横切逻辑形成“切面”，通过动态代理技术将切面“织入”到业务逻辑的指定位置，实现横切逻辑与业务逻辑的解耦。无需修改业务代码，即可完成对业务功能的增强。

举个直观例子：传统开发中，每个业务方法的日志记录需手动编写；基于AOP，可将日志逻辑抽离为切面，指定需要增强的业务方法，由框架自动在方法执行前后打印日志。

1.2 传统开发 vs AOP开发：代码对比

传统开发模式（日志逻辑嵌入业务代码）：

// 订单服务类
public class OrderService {
    public void createOrder() {
        // 横切逻辑：日志记录（嵌入业务代码）
        System.out.println("=== 开始执行创建订单方法 ===");
        try {
            // 核心业务逻辑
            System.out.println("创建订单成功");
            // 横切逻辑：日志记录
            System.out.println("=== 创建订单方法执行完成 ===");
        } catch (Exception e) {
            // 横切逻辑：异常日志
            System.out.println("=== 创建订单方法执行失败：" + e.getMessage() + " ===");
        }
    }
    
    public void cancelOrder() {
        // 横切逻辑：日志记录（重复代码）
        System.out.println("=== 开始执行取消订单方法 ===");
        try {
            // 核心业务逻辑
            System.out.println("取消订单成功");
            System.out.println("=== 取消订单方法执行完成 ===");
        } catch (Exception e) {
            System.out.println("=== 取消订单方法执行失败：" + e.getMessage() + " ===");
        }
    }
}

上述代码中，日志逻辑与业务逻辑深度耦合，且大量重复，后续修改日志格式需改动所有业务方法，维护成本极高。

AOP开发模式（横切逻辑抽离为切面）：

// 1. 业务类（仅保留核心业务逻辑）
@Service
public class OrderService {
    public void createOrder() {
        // 核心业务逻辑
        System.out.println("创建订单成功");
    }
    
    public void cancelOrder() {
        // 核心业务逻辑
        System.out.println("取消订单成功");
    }
}

// 2. 日志切面（抽离横切逻辑）
@Component
@Aspect
public class LogAspect {
    // 切入点：指定增强所有订单服务的方法
    @Pointcut("execution(* com.example.service.OrderService.*(..))")
    public void orderServicePointcut() {}
    
    // 前置通知：方法执行前打印日志
    @Before("orderServicePointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 开始执行" + methodName + "方法 ===");
    }
    
    // 后置通知：方法执行后打印日志
    @After("orderServicePointcut()")
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== " + methodName + "方法执行完成 ===");
    }
    
    // 异常通知：方法抛出异常时打印日志
    @AfterThrowing(value = "orderServicePointcut()", throwing = "e")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception e) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== " + methodName + "方法执行失败：" + e.getMessage() + " ===");
    }
}

通过AOP改造后，业务类仅保留核心逻辑，日志横切逻辑集中在切面中，实现了完全解耦。后续修改日志格式，只需修改切面代码，大幅降低维护成本。

1.3 Spring AOP的核心术语

理解AOP的核心术语是掌握AOP的基础，这些术语描述了AOP的核心组成部分与执行流程：

  • **切面（Aspect）：**封装横切逻辑的组件，如上述的“日志切面”“事务切面”。在Spring中，通过@Aspect注解声明切面。
  • **连接点（Join Point）：**程序执行过程中的特定位置，如方法调用前、方法执行后、异常抛出时。Spring AOP仅支持“方法级别的连接点”。
  • **切入点（Pointcut）：**通过表达式筛选出的“需要增强的连接点”。如“所有service包下的方法”“OrderService中的createOrder方法”，通过@Pointcut注解定义。
  • **通知（Advice）：**切面在连接点执行的具体逻辑，即“增强的代码”。Spring支持5种通知类型（后续详解）。
  • **目标对象（Target）：**被增强的业务对象，如上述的OrderService实例。
  • **代理对象（Proxy）：**Spring AOP通过动态代理技术为目标对象创建的代理实例，横切逻辑通过代理对象织入到目标方法中，开发者实际调用的是代理对象。
  • **织入（Weaving）：**将切面逻辑融入目标对象业务逻辑的过程。Spring AOP的织入发生在运行时（动态织入）。

二、深入底层：Spring AOP的实现原理

Spring AOP的核心底层是动态代理技术，通过为目标对象创建代理对象，在代理对象中嵌入横切逻辑，从而实现对目标方法的增强。Spring AOP默认提供两种动态代理实现：JDK动态代理、CGLIB动态代理。

2.1 两种动态代理实现对比

实现方式 核心原理 适用场景 优缺点
JDK动态代理 基于Java反射机制，通过Proxy类创建目标对象的代理类，代理类实现目标对象的所有接口 目标对象实现了至少一个接口 优点：JDK原生支持，无需依赖第三方库；缺点：仅支持接口代理，不支持类代理
CGLIB动态代理 基于ASM字节码生成框架，通过生成目标对象的子类作为代理类，重写目标方法实现增强 目标对象未实现接口（或强制指定使用CGLIB） 优点：支持类代理，适用范围更广；缺点：依赖第三方库（Spring已内置CGLIB），生成子类时无法代理final方法（final方法无法重写）

2.2 Spring AOP的代理选择逻辑

Spring AOP默认遵循以下代理选择规则：

  1. 若目标对象实现了至少一个接口，默认使用JDK动态代理；

  2. 若目标对象未实现接口，自动使用CGLIB动态代理；

  3. 可通过配置强制使用CGLIB代理（如Spring Boot中配置spring.aop.proxy-target-class=true）。

2.3 动态代理原理简单实现（辅助理解）

为了让大家更直观理解动态代理的工作机制，这里分别给出JDK动态代理和CGLIB动态代理的简单手动实现（实际开发中Spring会自动完成）。

2.3.1 JDK动态代理手动实现

// 1. 定义业务接口
public interface OrderService {
    void createOrder();
}

// 2. 实现业务接口
public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder() {
        System.out.println("创建订单成功");
    }
}

// 3. 实现InvocationHandler（横切逻辑增强）
public class LogInvocationHandler implements InvocationHandler {
    // 目标对象
    private Object target;
    
    public LogInvocationHandler(Object target) {
        this.target = target;
    }
    
    // 代理对象的方法执行时，会调用此方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强：日志记录
        System.out.println("=== 开始执行" + method.getName() + "方法 ===");
        try {
            // 执行目标对象的核心业务方法
            Object result = method.invoke(target, args);
            // 后置增强：日志记录
            System.out.println("=== " + method.getName() + "方法执行完成 ===");
            return result;
        } catch (Exception e) {
            // 异常增强：日志记录
            System.out.println("=== " + method.getName() + "方法执行失败：" + e.getMessage() + " ===");
            throw e;
        }
    }
}

// 4. 测试：创建代理对象并调用
public class JdkProxyTest {
    public static void main(String[] args) {
        // 目标对象
        OrderService target = new OrderServiceImpl();
        // 创建代理对象
        OrderService proxy = (OrderService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new LogInvocationHandler(target)
        );
        // 调用代理对象的方法（自动增强横切逻辑）
        proxy.createOrder();
    }
}

2.3.2 CGLIB动态代理手动实现

// 1. 无接口的业务类
public class OrderService {
    public void createOrder() {
        System.out.println("创建订单成功");
    }
}

// 2. 实现MethodInterceptor（横切逻辑增强）
public class LogMethodInterceptor implements MethodInterceptor {
    // 目标对象
    private Object target;
    
    public LogMethodInterceptor(Object target) {
        this.target = target;
    }
    
    // 代理对象的方法执行时，会调用此方法
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 前置增强：日志记录
        System.out.println("=== 开始执行" + method.getName() + "方法 ===");
        try {
            // 执行目标对象的核心业务方法
            Object result = method.invoke(target, args);
            // 后置增强：日志记录
            System.out.println("=== " + method.getName() + "方法执行完成 ===");
            return result;
        } catch (Exception e) {
            // 异常增强：日志记录
            System.out.println("=== " + method.getName() + "方法执行失败：" + e.getMessage() + " ===");
            throw e;
        }
    }
}

// 3. 测试：创建CGLIB代理对象并调用
public class CglibProxyTest {
    public static void main(String[] args) {
        // 目标对象
        OrderService target = new OrderService();
        // 创建CGLIB增强器
        Enhancer enhancer = new Enhancer();
        // 设置父类（目标类）
        enhancer.setSuperclass(target.getClass());
        // 设置回调（横切逻辑）
        enhancer.setCallback(new LogMethodInterceptor(target));
        // 创建代理对象（子类）
        OrderService proxy = (OrderService) enhancer.create();
        // 调用代理对象的方法
        proxy.createOrder();
    }
}

2.4 Spring AOP的核心执行流程

Spring AOP的执行过程可概括为“初始化切面→筛选切入点→创建代理对象→织入增强逻辑→执行目标方法”，具体步骤如下：

  1. 容器启动时，扫描并识别带有@Aspect注解的切面类；
  2. 解析切面类中的切入点表达式（@Pointcut），筛选出需要增强的目标方法；
  3. 为目标对象创建代理对象（根据目标对象是否实现接口选择JDK或CGLIB代理）；
  4. 开发者调用目标方法时，实际调用的是代理对象的方法；
  5. 代理对象根据通知类型（@Before、@After等），在目标方法执行的指定位置织入切面的横切逻辑；
  6. 执行目标对象的核心业务方法；
  7. 根据通知类型，执行后续的增强逻辑（如后置通知、异常通知）。

三、实战核心：Spring AOP的注解式开发

Spring AOP的开发方式分为XML配置和注解配置，目前主流使用注解配置（简洁高效）。本节将详细讲解注解式开发的核心步骤与常用功能。

3.1 开发前置：依赖导入

Spring AOP的核心依赖已包含在spring-context中，若使用Maven，直接引入spring-context依赖即可（Spring Boot项目引入spring-boot-starter-web会自动依赖）：

<!-- Maven依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.20</version>
</dependency>

3.2 核心步骤：注解式开发流程

注解式开发Spring AOP只需3步：声明切面、定义切入点、编写通知。

3.2.1 步骤1：开启AOP自动代理

在Spring配置类上添加@EnableAspectJAutoProxy注解，开启Spring对AspectJ风格AOP的支持（Spring Boot项目中，@SpringBootApplication已默认包含此功能，可省略）：

@Configuration
@ComponentScan("com.example") // 扫描组件
@EnableAspectJAutoProxy // 开启AOP自动代理
public class SpringConfig {
}

3.2.2 步骤2：声明切面类

创建切面类，添加@Component注解（将切面交给IOC容器管理）和@Aspect注解（声明此类为切面类）：

// 日志切面类
@Component
@Aspect
public class LogAspect {
    // 后续将切入点和通知定义在此处
}

3.2.3 步骤3：定义切入点（@Pointcut）

切入点通过@Pointcut注解定义，核心是“切入点表达式”，用于筛选需要增强的目标方法。

3.2.3.1 核心切入点表达式语法

Spring AOP支持多种切入点表达式，最常用的是“execution表达式”，语法格式如下：

execution([访问修饰符] 返回值类型 包名.类名.方法名(参数类型) [异常类型])

各部分说明：

  • 访问修饰符：可选（如public、private），省略时匹配所有访问修饰符；
  • 返回值类型：必填（如void、String、*（匹配任意返回值））；
  • 包名.类名：必填（如com.example.service.OrderService，支持通配符：*（匹配任意字符）、…（匹配任意包或子包））；
  • 方法名：必填（如createOrder，支持*通配符）；
  • 参数类型：必填（如()匹配无参方法、(String)匹配单个String参数、(…)匹配任意参数）；
  • 异常类型：可选（指定方法抛出的异常类型，如throws Exception）。
3.2.3.2 常用切入点表达式示例
@Aspect
@Component
public class LogAspect {
    // 1. 匹配com.example.service包下所有类的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceAllMethod() {}
    
    // 2. 匹配com.example.service包及子包下所有类的所有方法
    @Pointcut("execution(* com.example.service..*.*(..))")
    public void serviceAllMethodWithSubPackage() {}
    
    // 3. 匹配OrderService类的所有public方法
    @Pointcut("execution(public * com.example.service.OrderService.*(..))")
    public void orderServicePublicMethod() {}
    
    // 4. 匹配OrderService类的createOrder方法（无参）
    @Pointcut("execution(* com.example.service.OrderService.createOrder())")
    public void orderServiceCreateOrder() {}
    
    // 5. 匹配OrderService类的createOrder方法（参数为String）
    @Pointcut("execution(* com.example.service.OrderService.createOrder(String))")
    public void orderServiceCreateOrderWithStringParam() {}
    
    // 6. 匹配所有返回值为String的service层方法
    @Pointcut("execution(String com.example.service..*.*(..))")
    public void serviceMethodReturnString() {}
}

3.2.4 步骤4：编写通知（Advice）

通知是切面的核心逻辑，Spring支持5种核心通知类型，覆盖方法执行的全生命周期：

3.2.4.1 5种通知类型详解
通知类型 注解 执行时机 核心特点
前置通知 @Before 目标方法执行前 无法阻止目标方法执行（除非抛出异常）
后置通知 @After 目标方法执行后（无论是否抛出异常） 必然执行，适合资源清理
返回通知 @AfterReturning 目标方法正常执行完成后 可获取目标方法的返回值
异常通知 @AfterThrowing 目标方法抛出异常后 可获取目标方法的异常信息
环绕通知 @Around 目标方法执行前后（全程包裹） 最灵活，可控制目标方法的执行（如超时控制、重试），可修改返回值
3.2.4.2 通知实战示例
@Aspect
@Component
public class LogAspect {
    // 切入点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void servicePointcut() {}
    
    // 1. 前置通知：获取方法名和参数
    @Before("servicePointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName(); // 获取方法名
        Object[] args = joinPoint.getArgs(); // 获取方法参数
        System.out.printf("【前置通知】方法：%s，参数：%s%n", methodName, Arrays.toString(args));
    }
    
    // 2. 后置通知：仅记录方法执行完成
    @After("servicePointcut()")
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.printf("【后置通知】方法：%s 执行完成%n", methodName);
    }
    
    // 3. 返回通知：获取方法返回值
    @AfterReturning(value = "servicePointcut()", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.printf("【返回通知】方法：%s，返回值：%s%n", methodName, result);
    }
    
    // 4. 异常通知：获取异常信息
    @AfterThrowing(value = "servicePointcut()", throwing = "e")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception e) {
        String methodName = joinPoint.getSignature().getName();
        System.out.printf("【异常通知】方法：%s，异常信息：%s%n", methodName, e.getMessage());
    }
    
    // 5. 环绕通知：控制方法执行（示例：统计方法执行时间）
    @Around("servicePointcut()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        String methodName = proceedingJoinPoint.getSignature().getName();
        long startTime = System.currentTimeMillis();
        
        Object result = null;
        try {
            // 执行目标方法（相当于调用业务方法）
            result = proceedingJoinPoint.proceed();
        } catch (Exception e) {
            System.out.printf("【环绕通知-异常】方法：%s，异常：%s%n", methodName, e.getMessage());
            throw e; // 抛出异常，让后续异常通知处理
        }
        
        long endTime = System.currentTimeMillis();
        System.out.printf("【环绕通知】方法：%s，执行耗时：%dms%n", methodName, (endTime - startTime));
        return result; // 返回目标方法的返回值
    }
}

// 业务类
@Service
public class OrderService {
    public String createOrder(String orderNo) {
        if (orderNo == null || orderNo.isEmpty()) {
            throw new IllegalArgumentException("订单号不能为空");
        }
        return "订单创建成功：" + orderNo;
    }
}

// 测试类
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        OrderService orderService = context.getBean(OrderService.class);
        
        // 测试正常执行
        orderService.createOrder("ORDER_20240501");
        System.out.println("=== 分割线 ===");
        // 测试异常执行
        try {
            orderService.createOrder("");
        } catch (Exception e) {
            // 捕获异常，避免程序终止
        }
    }
}
3.2.4.3 执行结果分析
【前置通知】方法：createOrder，参数：[ORDER_20240501]
【环绕通知】方法：createOrder，执行耗时：1ms
【返回通知】方法：createOrder，返回值：订单创建成功：ORDER_20240501
【后置通知】方法：createOrder 执行完成
=== 分割线 ===
【前置通知】方法：createOrder，参数：[]
【环绕通知-异常】方法：createOrder，异常：订单号不能为空
【异常通知】方法：createOrder，异常信息：订单号不能为空
【后置通知】方法：createOrder 执行完成

从结果可看出：

  1. 正常执行时，通知执行顺序：环绕通知（前）→ 前置通知 → 目标方法 → 环绕通知（后）→ 返回通知 → 后置通知；
  2. 异常执行时，通知执行顺序：环绕通知（前）→ 前置通知 → 目标方法（抛异常）→ 环绕通知（异常）→ 异常通知 → 后置通知；
  3. 后置通知无论是否异常都会执行，返回通知仅在正常执行时执行，异常通知仅在异常时执行。

四、进阶拓展：Spring AOP的高级应用与常见问题

掌握基础开发后，本节将讲解Spring AOP的高级应用场景与实际开发中常见的问题及解决方案。

4.1 高级应用：切入点表达式的组合使用

Spring AOP支持通过逻辑运算符（&&、||、!）组合多个切入点表达式，实现更灵活的筛选规则：

@Aspect
@Component
public class LogAspect {
    // 切入点1：匹配service包下的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void servicePointcut() {}
    
    // 切入点2：匹配方法名以create开头的方法
    @Pointcut("execution(* com.example.service.*.create*(..))")
    public void createMethodPointcut() {}
    
    // 组合1：service包下且方法名以create开头的方法（&&）
    @Before("servicePointcut() && createMethodPointcut()")
    public void serviceCreateMethodAdvice(JoinPoint joinPoint) {
        System.out.printf("【组合通知】增强create开头的service方法：%s%n", joinPoint.getSignature().getName());
    }
    
    // 组合2：service包下或方法名以create开头的方法（||）
    @Before("servicePointcut() || createMethodPointcut()")
    public void serviceOrCreateMethodAdvice(JoinPoint joinPoint) {
        // 逻辑处理
    }
    
    // 组合3：不匹配service包下的方法（!）
    @Before("!servicePointcut()")
    public void notServiceMethodAdvice(JoinPoint joinPoint) {
        // 逻辑处理
    }
}

4.2 高级应用：引入增强（Introduction）

引入增强是Spring AOP的高级功能，允许为目标对象动态添加新的接口实现，而无需修改目标对象的代码。例如，为OrderService动态添加“日志记录能力”接口：

// 1. 定义需要动态添加的接口
public interface Loggable {
    void log();
}

// 2. 实现接口（增强逻辑）
public class LoggableImpl implements Loggable {
    @Override
    public void log() {
        System.out.println("动态添加的日志方法：Loggable.log()");
    }
}

// 3. 切面中通过@DeclareParents实现引入增强
@Aspect
@Component
public class IntroductionAspect {
    // value：指定需要增强的目标类（com.example.service.OrderService）
    // defaultImpl：指定接口的实现类
    @DeclareParents(value = "com.example.service.OrderService", defaultImpl = LoggableImpl.class)
    public static Loggable loggable; // 要添加的接口
}

// 4. 测试：目标对象可强转为新接口
public class IntroductionTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        OrderService orderService = context.getBean(OrderService.class);
        
        // 目标对象强转为Loggable接口（动态添加的能力）
        Loggable loggable = (Loggable) orderService;
        loggable.log(); // 调用动态添加的方法
    }
}

4.3 常见问题与解决方案

4.3.1 问题1：private方法无法被增强

原因：Spring AOP的动态代理技术无法代理private方法（JDK代理基于接口，private方法不对外暴露；CGLIB代理生成子类，无法重写private方法）。
解决方案：将需要增强的方法改为public或protected；若必须为private，需通过AspectJ的编译时织入（而非Spring AOP的运行时织入）实现。

4.3.2 问题2：final方法无法被增强

原因：CGLIB代理通过生成子类重写目标方法实现增强，而final方法无法被重写；JDK代理虽不依赖继承，但final方法属于接口的话，代理类仍无法重写。
解决方案：移除方法的final修饰符；若无法移除，同样需使用AspectJ的编译时织入。

4.3.3 问题3：内部方法调用无法触发AOP增强

场景：目标对象的A方法内部调用本类的B方法，若B方法被切面增强，此时调用A方法无法触发B方法的增强逻辑。

@Service
public class OrderService {
    public void A() {
        B(); // 内部调用B方法，无法触发AOP增强
    }
    
    public void B() {
        System.out.println("B方法执行");
    }
}

原因：内部调用时，调用的是目标对象本身的B方法，而非代理对象的B方法，因此无法织入增强逻辑。
解决方案：

  1. 通过容器获取代理对象，再调用B方法（不推荐，耦合容器）；
  2. 将B方法抽取到其他类中，通过依赖注入调用（推荐，解耦且符合AOP规范）。
// 解决方案2：抽取B方法到其他类
@Service
public class BService {
    public void B() {
        System.out.println("B方法执行");
    }
}

@Service
public class OrderService {
    @Autowired
    private BService bService;
    
    public void A() {
        bService.B(); // 调用代理对象的B方法，可触发增强
    }
}

4.3.4 问题4：多个切面的执行顺序如何控制

场景：多个切面同时增强同一个目标方法时，通知的执行顺序不明确。
解决方案：通过@Order注解或实现Ordered接口指定切面的优先级，值越小，优先级越高（前置通知先执行，后置通知后执行）。

// 切面1：优先级1（更高）
@Aspect
@Component
@Order(1)
public class LogAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice() {
        System.out.println("【LogAspect】前置通知");
    }
}

// 切面2：优先级2（更低）
@Aspect
@Component
@Order(2)
public class TransactionAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice() {
        System.out.println("【TransactionAspect】前置通知");
    }
}

// 执行结果：
// 【LogAspect】前置通知
// 【TransactionAspect】前置通知

五、总结

Spring AOP以“横切逻辑与业务逻辑分离”为核心思想，基于动态代理技术实现了对业务方法的无侵入增强，是解决代码冗余、降低耦合度的关键技术。本文从核心概念、底层原理、实战应用到进阶拓展，全面覆盖了Spring AOP的核心知识点：

  • AOP的本质是抽离横切逻辑为切面，通过代理对象织入业务逻辑，实现解耦；
  • Spring AOP底层依赖JDK和CGLIB两种动态代理，根据目标对象是否实现接口自动选择；
  • 注解式开发是主流，核心步骤为“开启AOP代理→声明切面→定义切入点→编写通知”；
  • 5种通知类型覆盖方法全生命周期，环绕通知最灵活，可控制方法执行流程；
  • 实际开发中需注意private/final方法无法增强、内部调用不触发AOP等问题，通过规范代码结构或调整织入方式解决。

Spring AOP在实际开发中应用广泛，如日志框架集成、事务管理、权限控制等。深入理解AOP的原理与实践，不仅能提升代码质量和开发效率，更能帮助开发者更好地理解Spring生态中基于AOP的高级功能（如Spring Transaction、Spring Security），构建扎实的Java开发基础。

# java # spring
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

一个 API 入口调用多个大模型：AiiOnly客户端 + CC Switch 打通 Codex AI编程流程

avatar AI编程社区
cover

VSCode Claude Code + MiMo 中转免登录完整配置教程（解决原生登录弹窗 + 模型报错）

avatar AI编程社区
cover

从零开始做一个属于自己的 Skill（保姆级教程）

avatar AI编程社区