public interface Subject {
    /**
     * 接口方法
     */
    void doSomething();
    /**
     * sayHello
     *
     * @param name name
     * @return string
     */
    String sayHello(String name);
}

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject do something");
    }
    @Override
    public String sayHello(String name) {
        System.out.println("RealSubject sayHello");
        return "hello-" + name;
    }
}

public class JdkDynamicProxyFactory {
    /**
     * 創(chuàng)建target類的代理對象
     * 注意：當調(diào)用代理對象中的方法時，其實就是調(diào)用的InvocationHandler里面的invoke方法，然后在invoke方法里調(diào)用目標對象對應的方法
     *
     * @param <T> 泛型
     * @return 代理對象
     */
    public static <T> T getProxy(Object target) {
        // 創(chuàng)建代理實例，分別傳入：【加載target類的類加載器、target類實現(xiàn)的接口、InvocationHandler】
        Object proxyInstance = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("執(zhí)行目標方法前");
                        // 執(zhí)行目標方法
                        Object result = method.invoke(target, args);
                        System.out.println("執(zhí)行目標方法后");
                        // 返回目標方法的執(zhí)行結果
                        return result;
                    }
                });
        // 返回代理對象
        return (T) proxyInstance;
    }
}

public class Client {
    public static void main(String[] args) {
        // 保存生成的代理類的字節(jié)碼文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        // 目標對象
        RealSubject target = new RealSubject();
        // 使用JDK動態(tài)代理為【target對象】創(chuàng)建代理對象
        Subject proxy = JdkDynamicProxyFactory.getProxy(target);
        // 調(diào)用代理對象的方法
        proxy.doSomething();
        System.out.println("=====================華麗的分割線=====================");
        proxy.sayHello("wenpan");
    }
}

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

// 1、代理類首先繼承了Proxy類（這也說明了為什么JDK代理需要實現(xiàn)接口，因為Java是單繼承的），并且實現(xiàn)了目標接口Subject
public final class $Proxy0 extends Proxy implements Subject {
  	// 2、可以看到，在代理類中將我們的【目標接口Subject】的【所有方法（包括object父類的方法）】都以【靜態(tài)屬性的形式】保存了起來
    private static Method m1;
    private static Method m3;
    private static Method m4;
    private static Method m2;
    private static Method m0;
  	// 以靜態(tài)代碼塊的形式為屬性賦值
    static {
          try {
              m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
              m3 = Class.forName("com.stone.design.mode.proxy.jdk.Subject").getMethod("doSomething");
              m4 = Class.forName("com.stone.design.mode.proxy.jdk.Subject").getMethod("sayHello", Class.forName("java.lang.String"));
              m2 = Class.forName("java.lang.Object").getMethod("toString");
              m0 = Class.forName("java.lang.Object").getMethod("hashCode");
          } catch (NoSuchMethodException var2) {
              throw new NoSuchMethodError(var2.getMessage());
          } catch (ClassNotFoundException var3) {
              throw new NoClassDefFoundError(var3.getMessage());
          }
      }
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
  	// 3、object父類的equals方法
    public final boolean equals(Object var1) throws  {
        try {
          	// 這里的supper是指的Proxy類，調(diào)用【Proxy類】的【h屬性】的invoke方法執(zhí)行
          	// 重點：【注意這里的super.h】其實就是我們創(chuàng)建代理對象是傳入的【InvocationHandler】，不信往后面看
          	// 這里也就體現(xiàn)了創(chuàng)建代理對象時為什么需要傳入【InvocationHandler】，以及為什么調(diào)用代理對象的方法時都是執(zhí)行的invoke方法
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
  	// 4、目標接口的方法
    public final void doSomething() throws  {
        try {
          	// 調(diào)用了【Proxy.h屬性】的invoke方法
          	// 注意這里的super.h】其實就是我們創(chuàng)建代理對象是傳入的【InvocationHandler】，不信往后面看
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
  	// 5、目標接口的方法
    public final String sayHello(String var1) throws  {
        try {
          	// 調(diào)用了【Proxy.h屬性】的invoke方法
          	// 注意這里的super.h】其實就是我們創(chuàng)建代理對象是傳入的【InvocationHandler】，不信往后面看
            return (String)super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
}

public class Proxy implements java.io.Serializable {
  	// h屬性，保存我們傳遞進來的InvocationHandler
    protected InvocationHandler h;
    // 【有參構造器】注意這里的參數(shù)
    protected Proxy(InvocationHandler h) {
      Objects.requireNonNull(h);
      this.h = h;
    }
    // 生成代理對象的方法
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
        throws IllegalArgumentException{
      	// 1、InvocationHandler強制不允許為空
        Objects.requireNonNull(h);
        // 獲取到目標接口
        final Class<?>[] intfs = interfaces.clone();
        /*
         * Look up or generate the designated proxy class.
         * 2、獲取到代理類的Class對象（也就是Proxy）
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * Invoke its constructor with the designated invocation handler.
         * 通過反射執(zhí)行 cl 的有參構造，也就是下面這個，可以看到通過反射執(zhí)行Proxy有參構造，
         * 將InvocationHandler賦值到了h屬性上
         */
        try {
            // 3、獲取到有參構造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            // 4、通過構造器來創(chuàng)建一個代理對象并返回，這里傳入的參數(shù)h 就是我們的【InvocationHandler】
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            // 省略....
        }
    }
}