Spring AOP 核心概念、应用场景与底层原理详解 | 极客日志

Javajava

Spring AOP 核心概念、应用场景与底层原理详解

Spring AOP 旨在将横切关注点从业务逻辑中分离，通过模块化增强可维护性。核心涉及切入点、连接点、通知及切面等概念。实现上依赖代理模式，JDK 动态代理需目标类实现接口，CGLIB 则基于继承生成子类字节码。通过 @Aspect 等注解配置，可在运行时动态织入日志、事务等逻辑，有效降低代码耦合度并统一管理。

abccba发布于 2026/3/15更新于 2026/4/251 浏览

Spring AOP 核心概念、应用场景与底层原理详解

Spring AOP 核心概念、应用场景与底层原理详解

在这里插入图片描述

概述

面向切面编程（Aspect Oriented Programming，AOP）是一种编程范式，旨在将横切关注点（Cross-Cutting Concerns，如日志、事务、安全等）从业务逻辑中分离出来。通过模块化的方式增强代码的可维护性和复用性，其核心思想是通过'切面'定义通用功能，并在运行时动态织入到目标代码中。

横切关注点：指的是在系统中"横向"跨越多个模块、多个层次的功能需求，它们无法很好地被封装在单个类或模块中。

场景示例：性能监控

硬编码实现

@Slf4j
public class HardCoding {
    public void demo() {
        long startTime = System.currentTimeMillis();
        // 业务代码
        log.info("消耗时间:{}", System.currentTimeMillis() - startTime);
    }

    public static void main(String[] args) {
        new HardCoding().demo();
    }
}

使用这种硬编码方式监控业务性能主要有以下缺点：

代码侵入性强：业务代码与监控代码耦合，修改监控代码会影响业务代码
重复代码多：每个方法都要重复编写监控代码，维护困难
不利于管理：监控逻辑分散，难以统一管理
容易遗漏：开发人员可能忘记添加监控代码

在这里插入图片描述

AOP 实现

首先引入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>3.4.8</version>
    <!-- 应与 SpringBoot 版本一致 -->
</dependency>

@Slf4j
@RestController
@RequestMapping("/demo")
public class Controller {
    @RequestMapping("/a")
    public void methodA() {
        log.info("执行 methodA");
    }

    @RequestMapping("/b")
    public void methodB() {
        log.info("执行 methodB");
    }

    @RequestMapping("/c")
    public void methodC() {
        log.info("执行 methodC");
    }
}

@Component
@Slf4j
@Aspect
public class AOP {
    @Around("execution(* org.example.springaop.blog_demo.Controller.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        // 执行业务
        Object result = joinPoint.proceed();
        // 计算时间
        log.info("消耗时间:{}", System.currentTimeMillis() - startTime);
        return result;
    }
}

// 语法结构 execution(<访问限定修饰符><返回类型><包名。类名。方法 (方法参数)><异常>)

@Slf4j
@RestController
@RequestMapping("/demo")
public class Controller {
    @RequestMapping("/a")
    public Object methodA(Integer id) {
        log.info("执行 methodA");
        return id;
    }

    @RequestMapping("/b")
    public void methodB() {
        log.info("执行 methodB");
        throw new RuntimeException("发生异常");
    }
}

@Component
@Slf4j
@Aspect
public class AOP {
    @Pointcut("execution(* org.example.springaop.blog_demo.Controller.*(..))")
    public void pointcut() {}

    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("doAround:业务执行前");
        // 执行业务
        Object result = joinPoint.proceed();
        log.info("doAround:业务执行后,result:{}", result);
        return "success";
    }

    @Before("pointcut()")
    public void doBefore() {
        log.info("doBefore");
    }

    @After("pointcut()")
    public void doAfter() {
        log.info("doAfter");
    }

    @AfterReturning(value = "pointcut()", returning = "id")
    public void doAfterReturning(Integer id) {
        // 发生异常时不执行
        log.info("doAfterReturning,id:{}", id);
    }

    @AfterThrowing(value = "pointcut()", throwing = "throwable")
    public void doAfterThrowing(Throwable throwable) {
        log.info("doAfterThrowing,throwable:{}", throwable.getMessage());
    }
}

@Target(ElementType.METHOD) // 注解级别：方法注解
@Retention(RetentionPolicy.RUNTIME) // 生命周期：运行时
public @interface CustomizeAspect {}

// 添加到切面类中
@Around("@annotation(org.example.springaop.config.CustomizeAspect)")
public Object customize(ProceedingJoinPoint joinPoint) throws Throwable {
    log.info("customize before");
    Object result = joinPoint.proceed();
    log.info("customize after,result:{}", result);
    return "success";
}

// 添加到 Controller 类中
@RequestMapping("/c")
@CustomizeAspect
public Object methodC(Integer id) {
    log.info("执行 methodC");
    return id;
}

@Component
@Slf4j
@Aspect
@Order(1)
public class AOP1 {
    @Pointcut("execution(* org.example.springaop.controller.Controller.*(..))")
    public void pointcut() {}

    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("doAround1:业务执行前");
        Object result = joinPoint.proceed();
        log.info("doAround1:业务执行后,result:{}", result);
        return "success1";
    }

    @Before("pointcut()")
    public void doBefore() {
        log.info("doBefore1");
    }

    @After("pointcut()")
    public void doAfter() {
        log.info("doAfter1");
    }

    @AfterReturning(value = "pointcut()", returning = "id")
    public void doAfterReturning(Integer id) {
        log.info("doAfterReturning1,id:{}", id);
    }

    @AfterThrowing(value = "pointcut()", throwing = "throwable")
    public void doAfterThrowing(Throwable throwable) {
        log.info("doAfterThrowing1,throwable:{}", throwable.getMessage());
    }

    @Around("@annotation(org.example.springaop.config.CustomizeAspect)")
    public Object customize(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("customize before1");
        Object result = joinPoint.proceed();
        log.info("customize after1,result:{}", result);
        return "success1";
    }
}

@Component
@Slf4j
@Aspect
@Order(2)
public class AOP2 {
    @Pointcut("execution(* org.example.springaop.controller.Controller.*(..))")
    public void pointcut() {}

    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("doAround2:业务执行前");
        Object result = joinPoint.proceed();
        log.info("doAround2:业务执行后,result:{}", result);
        return "success2";
    }

    @Before("pointcut()")
    public void doBefore() {
        log.info("doBefore2");
    }

    @After("pointcut()")
    public void doAfter() {
        log.info("doAfter2");
    }

    @AfterReturning(value = "pointcut()", returning = "id")
    public void doAfterReturning(Integer id) {
        log.info("doAfterReturning2,id:{}", id);
    }

    @AfterThrowing(value = "pointcut()", throwing = "throwable")
    public void doAfterThrowing(Throwable throwable) {
        log.info("doAfterThrowing2,throwable:{}", throwable.getMessage());
    }

    @Around("@annotation(org.example.springaop.config.CustomizeAspect)")
    public Object customize(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("customize before2");
        Object result = joinPoint.proceed();
        log.info("customize after2,result:{}", result);
        return "success2";
    }
}

public interface IHouse {
    void rent();
    void sell();
}

// 房东
public class RealHouse implements IHouse {
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }

    @Override
    public void sell() {
        System.out.println("房东售卖房子");
    }
}

// 中介
public class HouseProxy implements IHouse {
    private final IHouse realHouse;

    public HouseProxy(IHouse realHouse) {
        this.realHouse = realHouse;
    }

    @Override
    public void rent() {
        System.out.println("开始代理");
        realHouse.rent();
        System.out.println("结束代理");
    }

    @Override
    public void sell() {
        System.out.println("开始代理");
        realHouse.sell();
        System.out.println("结束代理");
    }

    public static void main(String[] args) {
        IHouse iHouse = new HouseProxy(new RealHouse());
        iHouse.rent();
        iHouse.sell();
    }
}

@Slf4j
public class JDKInvocationHandler implements InvocationHandler {
    private final Object realHouse;

    public JDKInvocationHandler(Object realHouse) {
        this.realHouse = realHouse;
    }

    @Override
    // Object proxy:生成的代理对象实例，Method method:被调用的目标方法对象，Object[] args:调用目标方法时传入的参数数组
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("JDK 开始代理");
        // 调用 realHouse 的方法
        Object invoke = method.invoke(realHouse, args);
        log.info("JDK 结束代理,invoke:{}", invoke);
        return invoke;
    }
}

public class Main {
    public static void main(String[] args) {
        IHouse target = new RealHouse();
        // JDK 动态代理，只能代理接口
        IHouse iHouse = (IHouse) Proxy.newProxyInstance(
            RealHouse.class.getClassLoader(),
            new Class[]{IHouse.class},
            new JDKInvocationHandler(target)
        );
        iHouse.rent();
        iHouse.sell();
    }
}

// interface MethodInterceptor extends Callback
@Slf4j
public class CGLibMethodInterceptor implements MethodInterceptor {
    private final Object realHouse;

    public CGLibMethodInterceptor(Object realHouse) {
        this.realHouse = realHouse;
    }

    @Override
    // Object obj:动态生成的代理对象实例，Method method:当前被拦截的目标方法对象，Object[] args:方法调用时传入的参数数组，MethodProxy proxy:方法代理对象
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        log.info("开始代理");
        IHouse result = (IHouse) method.invoke(realHouse, args);
        log.info("结束代理");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        RealHouse target = new RealHouse();
        RealHouse realHouse = (RealHouse) Enhancer.create(
            RealHouse.class,
            new CGLibMethodInterceptor(target)
        );
        realHouse.rent();
        realHouse.sell();
    }
}