// 定义类A
public class  ClassA{
    public void methoda(){
       System.out.println("我是方法a!");
    }
}
// 定义类B
public class ClassB{
    // 组合ClassA
    ClassA  A;
    public ClassB(ClassA A){
        this.A = A;
    }
    
    @Override
    public void methodb(){
        System.out.println("我是方法a的附加功能代码，我执行啦~!");
        A.methoda();
        System.out.println("我是方法a的附加功能代码，我完成啦~!");
    }
}

我是方法a的附加功能代码，我执行啦~!
我是方法a!
我是方法a的附加功能代码，我完成啦~!

// 被代理类的接口（上图中subject）
public interface ImpA{
      void methoda();
}
// 定义类A（上图中RealSubject）
public class  ClassA implements ImpA{
    public void methoda(){
       System.out.println("我是方法a!");
    }
}
// 定义类B（上图中Proxy）
public class ClassB implements  ImpA {
    // 组合ClassA
    ImpA  A;
    public ClassB(ClassA A){
        this.A = A;
    }
    
    // 重写被代理类的方法
    @Override
    public void methoda(){
        System.out.println("我是方法a的附加功能代码，我执行啦~!");
        A.methoda();
        System.out.println("我是方法a的附加功能代码，我完成啦~!");
    }
}
// 客户端类（上图中Client）
public class Main{
    // 创建被代理对象实例
    ImpA A = new ClassA();
    // 构造器注入被代理对象实例
    ImpA B = new ClassB(A);
    // 调用代理方法
    B.methoda();
}

public class MyHandler implements InvocationHandler{
    // 标识被代理类的实例对象
    private Object delegate;   
    // 构造器注入被代理对象
    public MyHandler(Object delegate){
       this.delegate = delegate;
    }
    
    // 重写invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("被代理方法调用前的附加代码执行~ ");
        // 真实的被代理方法调用
        method.invoke(delegate, args);
        System.out.println("被代理方法调用后的附加代码执行~ ");
    } 
}

public class MainTest{
    public static void main(String[] args) {    
        // 创建被代理对象
        ImplA A = new ClassA();
        // 创建处理器类实现
        InvocationHandler myHandler = new MyHandler(A);
        // 重点！ 生成代理类， 其中proxyA就是A的代理类了
        ImplA proxyA = (ImplA)Proxy.newProxyInstance(A.getClass().getClassLoader(), A.getClass().getInterfaces(), myHandler);
        // 调用代理类的代理的methoda方法， 在此处就会去调用上述myHandler的invoke方法区执行，至于为什么，先留着疑问，下面会说清楚~
        proxyA.methoda();
    }
}

被代理方法调用前的附加代码执行~
我是方法a！
被代理方法调用后的附加代码执行~

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

public class Proxy implements java.io.Serializable {
    // 处理类实例 变量
    protected InvocationHandler h;
    // 用于存储 已经通过动态代理获取过的代理类缓存
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>  proxyClassCache = new WeakCache<>(new KeyFactory(),new ProxyClassFactory());
    // 私有无参构造，使得只能通过传入InvocationHandler参数来创建该对象
    private Proxy() {}
    // 保护 构造函数，入参InvocationHandler处理类
    protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }
    public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces) throws IllegalArgumentException{
        ...
    }
    public static boolean isProxyClass(Class<?> cl) {
        ...
    }
    public static InvocationHandler getInvocationHandler(Object proxy)  throws IllegalArgumentException {
        ...
    }
    // 生成代理类的实现方法
    public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException{
        ...
	}
    // 各种私有方法
    private ... ...
}

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException{
        // 1. 克隆对应的接口，用于代理类实现的接口数组
        final Class<?>[] intfs = interfaces.clone();
        ...
        /*
         * Look up or generate the designated proxy class.  源码中的介绍
         * 2. 查找或者生成指定的代理类， 下面会详细介绍
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * Invoke its constructor with the designated invocation handler.
         * 3. 上面代码已经生成了代理类 cl，cl其中包含一个参数为传入的InvocationHandler h的构造函数， 获取该构造函数并通过该构造函数创建一个类的实例对象并返回
         */
        try {
            // 4. 通过《反射》获取参数为InvocationHandler的构造函数
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            // 5. 判断构造函数是否为私有的，如果为私有的则需要设置私有可访问权限
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 6. 通过上述获取的构造函数创建对应的 实例对象，并返回！over~
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
           // 各种异常处理
        }
    }

    private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        // proxyClassCache是WeakCache弱引用缓存类，如果之前就生成过对应的代理类就从缓存中取，如果没生成过就重新生成
        return proxyClassCache.get(loader, interfaces);
    }

   public V get(K key, P parameter) {
        ...
        // 这部分主要是获取对应的 函数式接口，如果不明白函数式接口，google一下吧~
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;
        while (true) {  // 此处为什么是while循环呢， 主要是supplier不为空的话，则执行下面的语句赋值后，再循环执行下一次则supplier不为空
            if (supplier != null) {
                // 如果存在对应的函数式接口，  调用函数式接口对应的代码
                // 重点！！！调用函数式接口！！
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            if (factory == null) {
                // 创建一个 专门创建代理类字节码的工厂类，实现类是ProxyClassFactory
                factory = new Factory(key, parameter, subKey, valuesMap);
            }
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // 将supplier赋值factory
                    supplier = factory;
                }}}} }

       public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            // 获取接口对应的接口class对象
            for (Class<?> intf : interfaces) {
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } 
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { }
            }
            String proxyPkg = null;
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
            // 判断是否包含公有的接口对象，判断是否可以通过jdk proxy的方式进行生成代理类
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                    }
                }
            }
            // 如果没有公有接口类，需要使用CGLib来实现。。。
            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
            // 组装代理类的类名称
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
            // 重点！！ 此处生成代理类的字节码数组
            byte[] proxyClassFile = ProxyGenerator.generateProxyClassproxyName, interfaces, accessFlags);
            try {
               // 通过类加载器将字节码数组加载到JVm的方法区中生成Class对象！
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
            }
        }

private byte[] generateClassFile() {
        // 首先，默认代理的三个方法：hashCode\equals\toString
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        // 获取所有的要被代理类实现的接口
        Class[] var1 = this.interfaces;
        int var2 = var1.length;
        int var3;
        Class var4;
        // 遍历上述获取的接口
        for(var3 = 0; var3 < var2; ++var3) {
            // 赋值： 将接口的Class对象赋值！
            var4 = var1[var3];
            // 通过“反射”获取所有方法
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;
            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                // 将方法添加到 要被代理的方法中
                this.addProxyMethod(var8, var4);
            }
        }
        // 获取要代理方法后，开始组装字节码
        var14.writeInt(-889275714);
        var14.writeShort(0);
        var14.writeShort(this.accessFlags);
        var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
        // 注意！！！  .... 此处省略了绝大部分 字节码的组装过程，只给出了几行代码展示一下字节码的组装
        // 最终返回组装好的字节码文件
        return var13.toByteArray();
        }
    }

private static native Class<?> defineClass0(ClassLoader loader, String name,
                                                byte[] b, int off, int len);

    // 定义构造函数的参数类型，下面的一个语句使用
    private static final Class<?>[] constructorParams =    { InvocationHandler.class };
    // 通过反射获取上述获取的Class对象的带参构造函数，参数必须是上述定义的 InvocationHandler.class类型
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    // 检查权限，如果是私有权限，设为可被访问
    if (!Modifier.isPublic(cl.getModifiers())) {
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
               public Void run() {
                   cons.setAccessible(true);
                    return null;
                }
          });
     }
     // 通过构造函数传入对应 处理类h 参数，生成实例！
    return cons.newInstance(new Object[]{h});

final class $Proxy0 extends Proxy implements ImplA {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;
    
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.test.ImplA").getMethod("methoda");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
           // ..
        }
    }
   
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    // 需要被加强的方法methoda
    public final void methoda() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final boolean equals(Object var1) throws  {
        // 省略部分代码。。。
        return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
    }
    public final String toString() throws  {
        // 省略部分代码。。。
        return (String)super.h.invoke(this, m2, (Object[])null);
    }
    public final int hashCode() throws  {
        // 省略部分代码。。。
        return (Integer)super.h.invoke(this, m0, (Object[])null);
    }
}