Spring AOP 核心概念、注解与底层原理实战 | 极客日志

Javajava

Spring AOP 核心概念、注解与底层原理实战

Spring AOP 通过面向切面编程将日志、事务等横切关注点从业务逻辑中分离。文章对比了硬编码与 AOP 实现的差异，详细解析了切入点、通知、切面等核心术语。涵盖 @Aspect、@Pointcut、@Around 等关键注解用法，以及 @annotation 和 @Order 的高级配置。深入探讨了代理模式，包括 JDK 动态代理与 CGLIB 的实现机制及区别，帮助开发者理解 AOP 底层原理并应用于实际项目。

未来可期发布于 2026/3/15更新于 2026/4/251 浏览

Spring AOP 核心概念、注解与底层原理实战

概述

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

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

场景举例：监控业务性能

硬编码实现

@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>

@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 {
    // ... 同上逻辑
}

@Component
@Slf4j
@Aspect
@Order(2)
public class AOP2 {
    // ... 同上逻辑
}

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();
    }
}