Java动态代理：代理类与目标类混淆问题案例

原创一时失言乱红尘 2024-12-04 18:06 18阅读 0赞

在Java的动态代理中，可能会遇到代理类与目标类混淆的问题。以下是一个简单案例：

1. 原始代码（假设有一个类`TargetClass`）：
```java
public class TargetClass {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}
```
2. 创建动态代理类，这里使用CGLIB库：
```java
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyClass implements MethodInterceptor {
    private Enhancer enhancer;
    private Object targetObject;

public ProxyClass(Class<T> targetClass) {
        this.enhancer = new Enhancer();
        this.targetObject = enhancer.create(targetClass);
    }

@Override
    public Object intercept(Object object, Method method, Object[] args) throws Throwable {
        // 在方法执行前后添加操作
        String methodName = method.getName();
        if ("doSomething".equals(methodName))) {
            System.out.println("Before calling target method...");
            // 调用目标类的方法
            method.invoke(targetObject, args);
            System.out.println("After calling target method...");
        }
        return null;
    }

public T getTargetClassInstance() {
        return (T) this.targetObject;
    }
}
```
3. 使用代理类调用目标方法：
```java
public class Client {
    public static void main(String[] args) {
        // 创建代理对象
        ProxyClass proxy = new ProxyClass(TargetClass.class);

// 调用目标方法，实际上通过代理来执行
        TargetClass target = proxy.getTargetClassInstance();
        target.doSomething();

// 关闭代理
        proxy.close();
    }
}
```
在这个案例中，代理类`ProxyClass`实现了CGLIB库中的`MethodInterceptor`接口。这样，在调用目标方法时，实际上是通过代理来执行的，从而达到混淆目标类的目的。在程序运行结束后，需要关闭代理以释放资源。