AOP的底层原理和应用场景

面向切面编程（AOP）是一种编程范式，它允许开发者将横切关注点（如日志记录、事务管理等）从核心业务逻辑中分离出来。不同的 AOP 框架实现原理有所不同，下面详细介绍两种常见的 AOP 底层实现原理：动态代理和字节码织入。

 

动态代理

动态代理是 Spring AOP 默认采用的实现方式，它分为 JDK 动态代理和 CGLIB 动态代理。

1. JDK 动态代理

• 原理：JDK 动态代理是基于接口实现的。它利用 Java 的反射机制，在运行时创建一个实现了目标接口的代理类，该代理类会拦截对目标对象方法的调用，并在调用前后插入切面逻辑。
• 关键类和接口
  • java.lang.reflect.Proxy：这是 JDK 提供的用于创建动态代理对象的核心类。通过调用其 newProxyInstance 方法可以创建一个代理对象。
  • java.lang.reflect.InvocationHandler：这是一个接口，需要实现该接口来定义代理对象的方法调用逻辑。当调用代理对象的方法时，实际上会调用 InvocationHandler 的 invoke 方法。
• 示例代码

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义接口
interface UserService {
    void addUser();
}

// 实现接口
class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("Adding user...");
    }
}

// 实现 InvocationHandler 接口
class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method execution");
        Object result = method.invoke(target, args);
        System.out.println("After method execution");
        return result;
    }
}

// 测试类
public class JdkProxyExample {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(userService);
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler
        );
        proxy.addUser();
    }
}

• 局限性：JDK 动态代理只能为实现了接口的类创建代理对象，如果目标类没有实现任何接口，则无法使用 JDK 动态代理。