Java动态代理：实现对象行为的改变案例解析

原创柔情只为你懂 2024-09-14 21:12 41阅读 0赞

Java动态代理是一种在运行时根据需要创建对象的机制。主要用于改变已有对象的行为，比如添加额外的方法、修改方法的行为等。

以下是一个简单的动态代理案例，我们将一个普通的`Calculator`对象通过代理模式使其能够进行加法和乘法重载：

1. 创建Subject（目标）接口：
```java
public interface Calculator {
    double add(double a, double b));
    double multiply(double a, double b));
}
```

2. 创建Proxy（代理）类，实现 InvocationHandler（回调）接口，通过这个回调处理具体的计算方法调用：
```java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class CalculatorProxy implements InvocationHandler {
    private Object target; // 被代理对象

public CalculatorProxy(Object target) {
        this.target = target; // 将被代理对象存储
    }

@Override
    public Object invoke(Invocation invocation) throws Throwable {
        // 获取调用的方法名和参数
        String methodName = invocation.getMethodName();
        Method originalMethod = target.getClass().getMethod(methodName);
        Class<?>[] parameterTypes = originalMethod.getParameterTypes();

// 根据实际方法类型调用代理对象
        if (parameterTypes.length == 0) {
            return originalMethod.invoke(this.target);
        } else if (parameterTypes.length == 1 && parameterTypes[0].equals(double.class))) {
            return originalMethod.invoke(this.target, (double[]) invocation.getArguments()[0]]);
        }

throw new IllegalArgumentException("Invalid method call or parameters");
    }
}
```

3. 创建具体代理对象并设置目标：
```java
Calculator calculator = new Calculator() {
    @Override
    public double add(double a, double b)) {
        // 在原始方法实现中添加额外逻辑
        return a + b + 1; // 模拟加法重载，返回带有额外值的结果
    }

@Override
    public double multiply(double a, double b)) {
        // 直接返回乘法结果，不改变任何行为
        return a * b;
    }
};
CalculatorProxy proxy = new CalculatorProxy(calculator);
```

4. 使用代理对象进行计算：
```java
System.out.println(proxy.invoke(new Object[]{10, 5}}, new Object[]{"add", (double[]) new double[]{10, 5}})));
```
输出结果：
```
16.0
```
这里我们模拟了一个加法重载的`Calculator`对象，通过代理模式，计算方法的行为被改变，实现了在原有基础上添加额外逻辑的功能。