Java动态代理深入理解：Proxy的动态创建案例

原创心已赠人 2024-10-25 04:12 27阅读 0赞

在Java中，动态代理是一个强大的工具，它允许我们在运行时根据需要创建和配置对象。这通常用于实现行为拦截、提高性能或管理复杂性。

以下是一个使用Proxy动态创建对象并进行方法拦截的简单示例：

1. 创建接口（Interface）：
```java
public interface MyInterface {
    void doSomething();
}
```

2. 实现接口（Implement Interface）：
```java
class MyRealObject implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}
```

3. 创建动态代理（Create Dynamic Proxy）：
这里我们使用Java的反射API来创建Proxy对象。
```java
import java.lang.reflect.Proxy;

public class DynamicProxyExample {

private static final Class<MyInterface> clazz = MyInterface.class;
    private static final Object realObject = new MyRealObject();
    private static final Method methodTo Intercept = clazz.getMethod("doSomething");

public static void main(String[] args) {
        // 创建动态代理对象
        MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
                getClass().getClassLoader(),
                new Class[]{ clazz }, 
                new MyInvocationHandler(realObject, methodTo Intercept))
        ;
        
        // 使用动态代理对象进行方法调用
        proxyInstance.doSomething();
    }
}

// 这是动态代理处理的逻辑，它接收来自代理对象的方法调用，并在必要时转发给实际对象
class MyInvocationHandler implements InvocationHandler {
    private final Object realObject;
    private final Method methodTo Intercept;

public MyInvocationHandler(Object realObject, Method methodTo Intercept) {
        this.realObject = realObject;
        this.methodTo Intercept = methodTo Intercept;
    }

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (methodTo Intercept.equals(method)) && args.length == 0) {
            // 这个方法需要被代理，且没有参数
            return method.invoke(realObject);
        } else {
            // 其他情况，直接返回调用对象本身
            return proxy;
        }
    }
}
```

这个例子中，我们首先定义了一个接口`MyInterface`和一个实现了这个接口的类`MyRealObject`。然后我们创建了一个动态代理对象，并通过反射来拦截特定方法的调用。

这就是Java动态代理的基本思想：在运行时根据需要创建并配置对象的行为。