JDK 的动态代理

JDK的动态代理是一种通过Java的反射机制实现的代理方式。下面是使用JDK的动态代理的详细步骤和说明：

1. 定义接口：首先需要定义一个接口，该接口是被代理类和代理类共同实现的接口。

2. 实现InvocationHandler接口：创建一个实现java.lang.reflect.InvocationHandler接口的代理类，该类用于处理方法调用和增强逻辑。在invoke()方法中，可以编写在方法调用前后进行的额外操作。

3. 创建被代理对象：创建一个实现了接口的原始类，也就是被代理类。

4. 创建代理对象：通过java.lang.reflect.Proxy类的newProxyInstance()方法生成代理对象。该方法接收三个参数：ClassLoader对象、代理类要实现的接口数组、InvocationHandler对象。

5. 调用代理对象：使用生成的代理对象来调用目标方法

6. import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;
   
   // 定义接口
   public interface TargetInterface {
       void doSomething();
   }
   
   // 被代理类
   public class Target implements TargetInterface {
       public void doSomething() {
           System.out.println("原始类的方法逻辑");
       }
   }
   
   // 代理类的InvocationHandler
   public class MyInvocationHandler implements InvocationHandler {
       private Object target;
   
       public MyInvocationHandler(Object target) {
           this.target = target;
       }
   
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // 在方法调用前进行的额外操作
           System.out.println("前置增强代码...");
   
           // 调用目标对象的方法
           Object result = method.invoke(target, args);
   
           // 在方法调用后进行的额外操作
           System.out.println("后置增强代码...");
   
           return result;
       }
   }
   
   // 测试类
   public class Main {
       public static void main(String[] args) {
           Target target = new Target();  // 创建被代理对象
   
           // 创建代理对象
           TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                   target.getClass().getClassLoader(),
                   target.getClass().getInterfaces(),
                   new MyInvocationHandler(target));
   
           // 调用代理对象的方法
           proxy.doSomething();
       }
   }
   

   proxy.doSomething()方法的执行会触发代理类的invoke方法，是因为在动态代理中，代理对象被创建时会关联一个InvocationHandler对象，这个InvocationHandler对象就是我们在创建代理对象时传入的MyInvocationHandler实例。

   当调用代理对象的方法时，实际上是通过代理对象的invoke方法来处理方法调用。invoke方法接收三个参数：proxy、method和args。其中，proxy是代理对象自身，method是被调用的方法，args是方法的参数。在invoke方法中，我们可以编写与方法调用相关的逻辑，例如前置增强、后置增强等。

   总结起来，代理对象的方法调用实际上会转发给invoke方法，在invoke方法中可以按需处理方法调用。这种方式实现了动态代理的功能，可以在目标方法调用前后进行一些额外的操作。

=========================================

当您调用 proxy.doSomething() 时，代理对象会拦截该方法的调用，并将控制权转发给 InvocationHandler 中的 invoke() 方法。在 invoke() 方法中，您可以添加额外的逻辑，然后决定是否调用实际的目标对象的 myMethod() 方法，或者执行其他操作。

请注意，在创建代理对象时，需要为 Proxy.newProxyInstance() 方法传递一个实现 InvocationHandler 接口的对象，该对象将负责处理方法调用的拦截和转发。这就是 InvocationHandler 中的 invoke() 方法被调用的地方。