AOP实现原理[编辑 | 编辑源代码]

简介[编辑 | 编辑源代码]

面向切面编程（AOP, Aspect-Oriented Programming）是Spring框架的核心功能之一，它通过横向切割关注点（Cross-Cutting Concerns）来增强代码的模块化。AOP允许开发者将日志记录、事务管理、安全控制等与业务逻辑无关的功能从核心业务代码中分离出来，从而提高代码的可维护性和复用性。

Spring AOP的实现基于动态代理机制，主要分为两种方式：

JDK动态代理：针对实现了接口的目标类
CGLIB动态代理：针对没有实现接口的目标类

核心概念[编辑 | 编辑源代码]

以下是AOP中的关键术语：

切面（Aspect）：横切关注点的模块化（如日志模块）
连接点（Join Point）：程序执行过程中的特定点（如方法调用）
通知（Advice）：在连接点执行的动作（如方法前后执行的代码）
切入点（Pointcut）：匹配连接点的表达式
目标对象（Target Object）：被代理的对象
织入（Weaving）：将切面应用到目标对象的过程

实现机制[编辑 | 编辑源代码]

JDK动态代理[编辑 | 编辑源代码]

当目标类实现了接口时，Spring会使用JDK的java.lang.reflect.Proxy类创建代理对象。

// 接口
public interface UserService {
    void saveUser();
}

// 实现类
public class UserServiceImpl implements UserService {
    public void saveUser() {
        System.out.println("保存用户");
    }
}

// 代理处理器
public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置通知");
        Object result = method.invoke(target, args);
        System.out.println("后置通知");
        return result;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new MyInvocationHandler(target)
        );
        proxy.saveUser();
    }
}

输出结果：

前置通知
保存用户
后置通知

CGLIB动态代理[编辑 | 编辑源代码]

对于没有实现接口的类，Spring使用CGLIB库通过继承方式创建子类代理。

// 目标类
public class ProductService {
    public void addProduct() {
        System.out.println("添加商品");
    }
}

// 方法拦截器
public class MyMethodInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("前置处理");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("后置处理");
        return result;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ProductService.class);
        enhancer.setCallback(new MyMethodInterceptor());
        
        ProductService proxy = (ProductService) enhancer.create();
        proxy.addProduct();
    }
}

输出结果：

前置处理
添加商品
后置处理

代理选择策略[编辑 | 编辑源代码]

Spring AOP按照以下顺序选择代理方式：

如果目标对象实现了接口 → 使用JDK动态代理
如果目标对象没有实现接口 → 使用CGLIB
可以通过配置强制使用CGLIB：<aop:config proxy-target-class="true">

实际应用案例[编辑 | 编辑源代码]

事务管理[编辑 | 编辑源代码]

Spring的事务管理就是基于AOP实现的典型例子：

@Transactional
public void transferMoney(Account from, Account to, double amount) {
    from.debit(amount);
    to.credit(amount);
}

Spring会在方法执行前开启事务，执行后根据结果提交或回滚事务。

性能监控[编辑 | 编辑源代码]

可以创建一个切面来监控方法执行时间：

@Aspect
@Component
public class PerformanceAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object logPerformance(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long elapsed = System.currentTimeMillis() - start;
        System.out.println(pjp.getSignature() + " 执行时间: " + elapsed + "ms");
        return result;
    }
}