如何用Java反射实现动态代理

在Java中，动态代理是一种强大的机制，允许你在运行时创建一个实现了一组接口的新类。动态代理通常用于实现AOP（面向切面编程）、事件监听、事务管理等场景。下面是一个使用Java反射实现动态代理的简单示例。

步骤

1. 定义接口：首先，你需要定义一个或多个接口，代理类将实现这些接口。

2. 创建InvocationHandler：实现InvocationHandler接口，这个接口有一个方法invoke，它会在代理对象的方法被调用时执行。

3. 创建代理对象：使用Proxy.newProxyInstance方法创建代理对象。

示例代码

1. 定义接口

public interface Calculator {
    int add(int a, int b);
    int subtract(int a, int b);
}

2. 实现接口

public class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int subtract(int a, int b) {
        return a - b;
    }
}

3. 创建InvocationHandler

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

public class CalculatorInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

4. 创建代理对象

import java.lang.reflect.Proxy;

public class DynamicProxyDemo {
    public static void main(String[] args) {
        // 创建目标对象
        Calculator target = new CalculatorImpl();

        // 创建InvocationHandler
        CalculatorInvocationHandler handler = new CalculatorInvocationHandler(target);

        // 创建代理对象
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
            Calculator.class.getClassLoader(),
            new Class<?>[] { Calculator.class },
            handler
        );

        // 使用代理对象调用方法
        int resultAdd = proxy.add(3, 5);
        System.out.println("Result of add: " + resultAdd);

        int resultSubtract = proxy.subtract(10, 4);
        System.out.println("Result of subtract: " + resultSubtract);
    }
}

解释

1. 定义接口：Calculator接口定义了两个方法add和subtract。

2. 实现接口：CalculatorImpl类实现了Calculator接口。

3. 创建InvocationHandler：CalculatorInvocationHandler类实现了InvocationHandler接口，并在invoke方法中添加了前置和后置处理逻辑。

4. 创建代理对象：在DynamicProxyDemo类中，使用Proxy.newProxyInstance方法创建了一个代理对象。这个方法需要三个参数：

   • 类加载器：用于加载代理类。
   • 接口数组：代理类需要实现的接口。
   • InvocationHandler：处理代理对象的方法调用。

通过这种方式，你可以在运行时动态地创建代理对象，并在方法调用前后添加额外的逻辑。