使用Java动态代理实现对象行为的拦截

原创阳光穿透心脏的1/2处 2024-10-21 13:54 23阅读 0赞

在Java中，我们可以利用字节码技术来实现动态代理。以下是一个基本的示例：

首先，创建一个目标接口（需要被代理的对象）：

```java
public interface Target {
    void doSomething();
}
```

然后，编写一个动态代理类，使用反射机制创建代理方法：

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

public class DynamicProxy implements InvocationHandler {
    private Object target;

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

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Method Invoked: " + method.getName());

// 在这里执行真正的方法调用
        // 例如，如果你的目标是Target接口的doSomething方法
        // 你可以像这样调用：
        //    target.doSomething();

// 这里我们返回一个对象，这个对象可以用来进一步操作
        return new Object() {
            @Override
            public String toString() {
                return "Return Value";
            }
        };
    }
}
```

最后，使用代理对象创建动态代理：

```java
public class Main {
    public static void main(String[] args) {
        Target target = new ConcreteTarget(); // 实现接口的目标

DynamicProxy proxy = new DynamicProxy(target); // 创建代理对象

// 现在你可以通过代理来调用目标方法
        proxy.invoke(null, Target.class.getMethod("doSomething"), new Object[0]));
    }
}
```

这样，每次你调用`proxy.invoke()`，实际执行的将是`target.doSomething()`。这就是动态代理的基本思想。