Java Runtime动态代理实现

Java Runtime动态代理是一种在运行时创建代理对象的技术，它允许我们在程序运行时动态地生成代理类，而不是在编译时生成。这种技术主要用于实现AOP（面向切面编程）或者在方法调用前后添加额外的逻辑。

要实现Java Runtime动态代理，需要以下几个步骤：

1. 创建一个接口：首先需要定义一个接口，代理类将实现这个接口。

public interface MyInterface {
    void doSomething();
}

2. 创建一个实现InvocationHandler接口的类：这个类将负责处理代理对象的方法调用。

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

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

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

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

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        MyInterface target = new MyInterfaceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(target);

        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler
        );

        proxy.doSomething();
    }
}

4. 创建一个实现接口的具体类：

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Doing something");
    }
}

运行上述代码，输出结果如下：

Before method call
Doing something
After method call

这就是Java Runtime动态代理的基本实现。在实际应用中，可以根据需要扩展MyInvocationHandler类，以实现更复杂的逻辑。