使用Java动态代理实现AOP编程

原创男娘i 2024-10-07 02:45 73阅读 0赞

在Java中，动态代理主要通过Proxy类和InvocationHandler接口来实现。以下是一个简单的例子，演示如何使用动态代理实现AOP（面向切面编程）。

1. 创建一个被代理的类`TargetClass`：

```java
public class TargetClass {
    private String targetMethod;

public TargetClass(String targetMethod) {
        this.targetMethod = targetMethod;
    }

@Override
    public String toString() {
        return "TargetClass{" +
                "targetMethod='" + targetMethod + '\'' +
                '}';
    }
}
```

2. 创建一个实现了`InvocationHandler`接口的代理类`ProxyClass`：

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

public class ProxyClass implements InvocationHandler {
    private TargetClass targetInstance;

public ProxyClass(TargetClass targetInstance) {
        this.targetInstance = targetInstance;
    }

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        // 判断是否是我们需要拦截的方法
        if (methodName.equals(targetMethod))) {
            System.out.println("Before method execution: " + args[0]);

// 执行方法，但不会真正调用目标对象的相应方法
            Object result = method.invoke(this.targetInstance, args));

System.out.println("After method execution: " + result);

return result;
        } else {
            // 如果不是我们需要拦截的方法，直接返回结果
            return method.invoke(this.targetInstance, args));
        }
    }
}
```

3. 最后使用代理类来调用目标方法：

```java
public class Main {
    public static void main(String[] args) {
        TargetClass target = new TargetClass("targetMethod");
        ProxyClass proxy = new ProxyClass(target);
        // 调用代理类的某个方法，如"targetMethod"
        proxy.invoke(proxy, MethodHandles.lookup().findMethod(target.getClass(), "targetMethod")), null);
    }
}
```

这样，我们就使用Java动态代理实现了AOP编程。