JDK动态代理

        JDK动态代理是Java语言中一种实现代理模式的机制。它允许在运行时动态生成代理类和代理对象，这些代理对象可以拦截被代理对象的方法调用，进行一些额外的操作，然后再将调用转发给被代理对象。

使用JDK动态代理，你需要定义一个接口作为被代理对象和代理对象之间的中介，然后使用Proxy类和InvocationHandler接口来生成代理对象。

下面是一个简单的示例来说明JDK动态代理的使用：

首先，定义一个接口（被代理对象）：

public interface Hello {
    void sayHello();
}

然后，实现该接口的具体类（被代理对象）：

public class HelloImpl implements Hello {
    @Override
    public void sayHello() {
        System.out.println("Hello!");
    }
}

接下来，创建一个实现InvocationHandler接口的类（代理对象）：

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

public class HelloProxy implements InvocationHandler {
    private Hello target;

    public HelloProxy(Hello target) {
        this.target = target;
    }

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

最后，使用Proxy类生成代理对象并调用方法：

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        Hello hello = new HelloImpl();
        Hello proxy = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(),
                                                      new Class[] { Hello.class },
                                                      new HelloProxy(hello));
        proxy.sayHello();
    }
}

当运行上述代码时，你会看到以下输出：

Before calling sayHello()
Hello!
After calling sayHello()

这就是JDK动态代理的基本用法。通过代理对象，你可以在方法调用前后进行一些额外的操作，例如日志记录、性能监测等。