从动态代理到Spring AOP：解耦横切逻辑的编程艺术

原创已于 2025-08-10 22:10:28 修改 · 1.3k 阅读

24 ·

CC 4.0 BY-SA版权

文章标签：

#java #spring boot #后端 #spring #AOP

于 2025-08-10 21:44:52 首次发布

引言

在Java开发中，日志记录、权限校验、事务管理等横切关注点（Cross-Cutting Concerns）往往需要重复编写在多个业务方法中。这种代码侵入性不仅降低开发效率，更让系统维护变得困难。本文将从Java原生动态代理技术切入，逐步揭示Spring AOP如何通过"切面编程"优雅解决这些痛点。

一、动态代理：横切逻辑的原始实现

1.1 动态代理基础原理

Java动态代理通过java.lang.reflect.Proxy类在运行时生成代理对象，其核心机制包含：

InvocationHandler接口：定义invoke(Object proxy, Method method, Object[] args)方法，拦截所有代理方法的调用
Proxy.newProxyInstance()：根据类加载器、接口数组和调用处理器创建代理对象

1.2 耗时监控案例实现

以下代码通过动态代理记录ArrayList的add()方法执行耗时：

import java.lang.reflect.*;
import java.util.*;

public class ArrayListProxyDemo {
    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        List<String> proxyList = (List<String>) Proxy.newProxyInstance(
            ArrayList.class.getClassLoader(),
            new Class[]{List.class},
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    long start = System.currentTimeMillis();
                    Object result = method.invoke(originalList, args);
                    long end = System.currentTimeMillis();
                    System.out.println(method.getName() + "耗时: " + (end - start) + "ms");
                    return result;
                }
            });
        
        proxyList.add("Spring");
        proxyList.add("AOP");
    }
}

输出结果：

1.3 动态代理的局限性

接口依赖：必须基于接口实现，无法代理没有实现接口的类
代码冗余：每个需要代理的类都需要编写InvocationHandler
功能单一：难以实现复杂的切面逻辑组合

二、Spring AOP：动态代理的进化形态

2.1 AOP核心概念体系

概念	说明
JoinPoint	程序执行过程中的特定点（如方法调用、异常抛出），Spring仅支持方法级连接点
PointCut	切入点表达式，精确匹配需要增强的JoinPoint
Advice	在特定JoinPoint执行的增强逻辑，包含@Before、@After等5种类型
Aspect	切面= PointCut + Advice + 切面优先级等元数据
Weaving	将Advice织入目标对象的过程，Spring在运行时通过动态代理实现

2.2 通知类型详解

Spring提供5种标准通知类型：

@Aspect
@Component
public class LogAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint jp) {
        System.out.println("前置通知: 准备执行" + jp.getSignature());
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", 
                   returning = "result")
    public void logAfterReturning(Object result) {
        System.out.println("返回通知: 执行结果" + result);
    }

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", 
                  throwing = "ex")
    public void logAfterThrowing(Exception ex) {
        System.out.println("异常通知: 发生异常" + ex.getMessage());
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter() {
        System.out.println("最终通知: 方法执行完毕");
    }

    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知前");
        Object result = pjp.proceed();
        System.out.println("环绕通知后");
        return result;
    }
}

2.3 切入点表达式语法

Spring支持6种表达式设计器：

1、execution（最常用）

// 匹配com.example.service包下所有类的所有方法
@Pointcut("execution(* com.example.service.*.*(..))")
 
// 匹配UserService类中返回String类型的方法
@Pointcut("execution(String com.example.service.UserService.*(..))")

注：execution(返回值类型全限定类名.方法名(参数类型))，其中“*”表示任意的，路径中的“..”表示匹配任意类型的多级目录，参数位置(*)表示匹配任意类型的一个参数，(..)表示匹配任意类型任意个数的参数。

2、within

// 匹配service包及其子包下的所有方法
@Pointcut("within(com.example.service..*)")

3、@annotation

// 匹配带有@Loggable注解的方法
@Pointcut("@annotation(com.example.Loggable)")

4、bean

// 匹配名为userService的Spring Bean
@Pointcut("bean(userService)")

5、args

// 匹配第一个参数为String类型的方法
@Pointcut("args(java.lang.String,..)")

6、逻辑运算组合表达式

// 匹配service包下带有@Loggable注解的方法
@Pointcut("execution(* com.example.service.*.*(..)) && @annotation(com.example.Loggable)")

2.4 执行顺序控制

通过@Order注解控制多个切面的执行顺序：

@Aspect
@Order(1)  // 优先级高于Order(2)的切面
public class PriorityAspect1 {}

@Aspect
@Order(2)
public class PriorityAspect2 {}

三、Spring AOP实战：操作日志记录

3.1 需求分析

实现以下功能：

记录所有Controller方法的调用信息
包含请求URL、方法名、执行耗时
自动捕获异常并记录

3.2 实现步骤

1、pom.xml中添加依赖（Spring Boot项目）：

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

2、定义切面类：

import org.aspectj.lang.*;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.*;
import javax.servlet.http.*;

@Aspect
@Component
public class WebLogAspect {
    
    // 定义切入点：匹配所有Controller包下的方法
    @Pointcut("execution(* com.example.controller.*.*(..))")
    public void webLog() {}

    @Around("webLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取请求对象
        HttpServletRequest request = ((ServletRequestAttributes) 
            RequestContextHolder.getRequestAttributes()).getRequest();
        
        // 记录请求信息
        String url = request.getRequestURL().toString();
        String method = request.getMethod();
        String className = joinPoint.getSignature().getDeclaringTypeName();
        String methodName = joinPoint.getSignature().getName();
        
        long start = System.currentTimeMillis();
        Object result = null;

        boolean isSuccess = true; // 标记是否成功
    
        try {
            result = joinPoint.proceed();
        } catch (Exception e) {
            isSuccess = false;
            System.err.println("异常信息: " + e.getMessage());
            throw e; // 继续抛出异常
        } finally {
            long end = System.currentTimeMillis();
            System.out.printf("请求URL: %s | 方法: %s.%s() | 状态: %s | 耗时: %dms%n",
                url, className, funcName, 
                isSuccess ? "成功" : "失败", // 根据异常标记状态
                end - start);

            // 可在此处实现操作日志入库或写入日志文件
        }
        return result;
    }
}