public interface Car {
    // 返回汽车相关信息
    String getInfo();
    // 汽车行驶方法
    void run();
}

public class Bugatti implements Car {

    private String info;

    public Bugatti(String info) {
        this.info = info;
    }

    @Override
    public void run() {
        System.out.println(this.info + " car running");
        try {
            // 模拟行驶耗时
            Thread.sleep(new Random().nextInt(3000));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getInfo() {
        return this.info;
    }
}

public class Ferrari implements Car {

    private String info;

    public Ferrari(String info) {
        this.info = info;
    }

    @Override
    public void run() {
        System.out.println(this.info + " car running");
        try {
            // 模拟行驶耗时
            Thread.sleep(new Random().nextInt(3000));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getInfo() {
        return this.info;
    }
}

public class SpeedTestUtil {

    // 存储启动时间
    private static ThreadLocal<Long> startTime = new ThreadLocal<Long>();

    public static void start() {
        // 记录启动时间
        startTime.set(System.currentTimeMillis());
    }

    public static void finish(String carName, String methodName) {
        // 获取结束时间
        long finishTime = System.currentTimeMillis();
        // 打印时间信息
        System.out.println(carName + " 执行" + methodName + "，耗时：" + (finishTime - startTime.get()) + " ms.\n");
    }
}

public class SpeedTestProxy implements Car {

    Car targetCar;

    public SpeedTestProxy(Car targetCar) {
        this.targetCar = targetCar;
    }

    @Override
    public String getInfo() {
        if (this.targetCar != null){
            return this.targetCar.getInfo();
        } else {
            return "";
        }
    }

    @Override
    public void run() {
        if (this.targetCar != null) {
            System.out.println("静态测速代理开始测试车型：" + this.targetCar.getInfo());
            SpeedTestUtil.start();
            targetCar.run();
            SpeedTestUtil.finish(this.targetCar.getInfo(), "run");
        } else {
            System.out.println("You need provide a Car to test");
        }
    }
}

private static void testSpeed() {
    // 测试Bugatti
    Bugatti bugatti = new Bugatti("Bugatti Chiron");
    SpeedTestProxy bugattiTest = new SpeedTestProxy(bugatti);
    bugattiTest.run();

    // 测试Ferrari
    Ferrari ferrari = new Ferrari("Ferrari California T");
    SpeedTestProxy ferrariTest = new SpeedTestProxy(ferrari);
    ferrariTest.run();
}

静态测速代理开始测试车型：Bugatti Chiron
Bugatti Chiron car running
Bugatti Chiron 执行run，耗时：2125 ms.

静态测速代理开始测试车型：Ferrari California T
Ferrari California T car running
Ferrari California T 执行run，耗时：2566 ms.

public class SpeedTestInvocationHandler<T extends Car> implements InvocationHandler {

    T targetCar;

    public SpeedTestInvocationHandler(T targetCar) {
        this.targetCar = targetCar;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (targetCar != null) {
            if ("run".equals(method.getName())) {
                System.out.println("动态测速代理开始执行：" + this.targetCar.getInfo() + " " + method.getName());
                SpeedTestUtil.start();
                Object result = method.invoke(this.targetCar, args);
                SpeedTestUtil.finish(this.targetCar.getInfo(), method.getName());
                return result;
            } else {
                return method.invoke(this.targetCar, args);
            }
        } else {
            throw new Throwable("Target Error, You need provide a Car to test");
        }
    }
}

private static void testBugatti() throws Exception {
    // 先创建需要测速的目标类
    Bugatti bugatti = new Bugatti("Bugatti Chiron");
    // 构造Bugatti类对象所关联的调用处理器
    InvocationHandler handler = new SpeedTestInvocationHandler<Bugatti>(bugatti);
    // 通过目标类的类加载器和目标类所实现的接口来获取一个代理类
    Class<?> proxyClass = Proxy.getProxyClass(Bugatti.class.getClassLoader(), new Class[]{Car.class});
    // 通过反射从代理类获取构造器，唯一参数类型是调用处理器接口类型
    Constructor<?> constructor = proxyClass.getConstructor(new Class[]{InvocationHandler.class});
    // 通过代理类构造器创建动态代理类实例，构造时调用处理器对象作为参数被传入
    Car car = (Car) constructor.newInstance(new Object[]{handler});
    car.run();
}

动态测速代理开始执行：Bugatti Chiron run
Bugatti Chiron car running
Bugatti Chiron 执行run，耗时：2629 ms.

Class<?> proxyClass = Proxy.getProxyClass(Bugatti.class.getClassLoader(), new Class[]{Car.class});

Constructor<?> constructor = proxyClass.getConstructor(new Class[]{InvocationHandler.class});

Car car = (Car) constructor.newInstance(new Object[]{handler});

private static void testFerrari() throws Exception {

    final Ferrari ferrari = new Ferrari("Ferrari California T");
    // 构造Ferrari类对象所关联的调用处理器
    InvocationHandler handler = new SpeedTestInvocationHandler<Ferrari>(ferrari);
    // 创建代理类对象
    Car car = (Car) Proxy.newProxyInstance(Car.class.getClassLoader(), new Class[]{Car.class}, handler);
    car.run();
}

private static void testFerrari() throws Exception {

    final Ferrari ferrari = new Ferrari("Ferrari California T");
    // 匿名类形式的InvocationHandler调用处理器实现
    Car car = (Car) Proxy.newProxyInstance(Car.class.getClassLoader(), new Class[]{Car.class}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("测速代理开始执行：" + ferrari.getInfo() + " " + method.getName());
            SpeedTestUtil.start();
            Object result = method.invoke(ferrari, args);
            SpeedTestUtil.finish(ferrari.getInfo(), method.getName());
            return result;
        }
    });
    car.run();
}

/**
 * 该方法负责集中处理动态代理类上的所有方法调用，调用处理器根据传入的三个参数进行预处理或分派到委托类实例上进行执行
 * @param proxy 代理类实例
 * @param method 被调用的方法对象
 * @param args 调用参数
 * @return
 * @throws Throwable
 */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException;

// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException;

// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
public static boolean isProxyClass(Class<?> cl);

// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException;

package com.coderap.foundation.proxy;

import sun.misc.ProxyGenerator;

import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.util.*;

public class Proxy implements java.io.Serializable {

    private static final long serialVersionUID = -2222568056686623797L;

    // 代理类名的前缀。生成的代理类一般是以 $Proxy + 数字 的形式命名的，如常见的 $Proxy0
    private final static String proxyClassNamePrefix = "$Proxy";

    // 代理类构造方法需要的参数类型
    private final static Class[] constructorParams = {InvocationHandler.class};

    /**
     * 用于缓存代理类类加载器的Map，这个Map的格式如下：
     * WeakHashMap - {
     *     ClassLoader：HashMap - {
     *         interfaceName : ProxyClass
     *     }
     * }
     */
    private static Map loaderToCache = new WeakHashMap();

    /**
     * marks that a particular proxy class is currently being generated
     * 用于标记代理类是否已经生成成功了
     */
    private static Object pendingGenerationMarker = new Object();

    // 这个属性是用于构成代理类名称的，每生成一个代理类，该值就会+1，因此代理类的类名都是$Proxy0, $Proxy1, $Proxy2...依次递增的形式
    private static long nextUniqueNumber = 0;

    // 用作nextUniqueNumber递增过程的锁对象
    private static Object nextUniqueNumberLock = new Object();

    // 所以已生成的代理类，主要用于 {@link #isProxyClass} 方法的实现
    private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());

    // 用于引用传入的调用处理器
    protected InvocationHandler h;

    // 禁止外部构造
    private Proxy() {
    }

    // 在构造时会保存传入的InvocationHandler以供后期使用
    protected Proxy(InvocationHandler h) {
        this.h = h;
    }

    /**
     * 给定一个类加载器和一系列接口，返回一个代理类对象（java.lang.Class类型）
     * 这个代理类对象会实现所有指定的接口，如果之前已经实现过相应接口序列的代理类，将会直接返回
     * 否则根据类加载器动态生成一个新的代理类
     *
     * 对于interfaces参数有以下标准:
     * 1. 必须都为接口，不能为类或其他基本类型；
     * 2. 任意两个接口都不能引用同一Class对象（identical）；
     * 3. 所有的接口应该对传入的类加载器可见，也就是说对于任意接口i要满足 Class.forName(i.getName(), false, cl) == i ；
     * 4. 所有的非public的接口应该在一个包中，否则代理类将无法实现这些接口，不管这个接口放在哪个包；
     * 5. 对于有相同签名的指定接口中任何成员方法：
     *      - 如果任何方法的返回类型是基本类型或void，那么所有的方法必须具有与此相同的返回类型。
     *      - 否则，该方法之一必须是返回类型，它可以指派给该方法其余的所有返回类型。
     * 6. 得到的代理类必须不超过虚拟机在类上施加的任何限制。例如，虚拟机可以限制某一类实现至多65535的接口数；在这种情况下，interfaces数组的大小必须不超过65535。
     *
     * 如果违反了这些限制，将抛出IllegalArgumentException。如果interfaces数组参数或其任何元素为null，则将抛出NullPointerException。
     *
     * 注意，指定的代理接口的顺序非常重要：对接口组合相同但顺序不同的代理类的两个请求会导致两个不同的代理类。
     *
     * @param loader     代理类的类加载器
     * @param interfaces 代理类实现的接口集合
     * @return 用指定的类加载器定义的代理类，它可以实现指定的接口
     * @throws IllegalArgumentException 如果违反传递到getProxyClass的参数上的任何限制
     * @throws NullPointerException     如果interfaces数组参数或其任何元素为null
     */
    public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
            throws IllegalArgumentException {
        // 最多传入65535个接口
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        Class proxyClass = null;

        // 从这里开始进行interfaces参数验证
        String[] interfaceNames = new String[interfaces.length];

        Set interfaceSet = new HashSet();    // for detecting duplicates

        for (int i = 0; i < interfaces.length; i++) {
            /*
             * - 验证传入的接口对于传入的ClassLoader是否都为可见的（通过使用loader循环加载传入的interface，判断的到的interface与传入的interface是否一致）；
             */
            String interfaceName = interfaces[i].getName();
            Class interfaceClass = null;
            try {
                interfaceClass = Class.forName(interfaceName, false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != interfaces[i]) {
                throw new IllegalArgumentException(
                        interfaces[i] + " is not visible from class loader");
            }


            /*
             * - 传入的接口是否是接口；
             */
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
            }


            /*
             * - 验证是否重复加载（通过interfaceSet记录每个传入的接口）
             */
            if (interfaceSet.contains(interfaceClass)) {
                throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
            }
            interfaceSet.add(interfaceClass);

            interfaceNames[i] = interfaceName;
        }


        Object key = Arrays.asList(interfaceNames);

        // 对代理类进行缓存的判断
        Map cache;
        synchronized (loaderToCache) {
            // 从loaderToCache这个缓存Map中根据类加载器读取，读取到的value还是一个Map
            cache = (Map) loaderToCache.get(loader);
            if (cache == null) {
                // 如果读到的Map为空，则创建一个Map，并将其以类加载器为键存入loaderToCache中
                cache = new HashMap();
                loaderToCache.put(loader, cache);
            }
        }

        /*
         * Look up the list of interfaces in the proxy class cache using
         * the key.  This lookup will result in one of three possible
         * kinds of values:
         *     null, if there is currently no proxy class for the list of
         *         interfaces in the class loader,
         *     the pendingGenerationMarker object, if a proxy class for the
         *         list of interfaces is currently being generated,
         *     or a weak reference to a Class object, if a proxy class for
         *         the list of interfaces has already been generated.
         */
        synchronized (cache) {
            /*
             * Note that we need not worry about reaping the cache for
             * entries with cleared weak references because if a proxy class
             * has been garbage collected, its class loader will have been
             * garbage collected as well, so the entire cache will be reaped
             * from the loaderToCache map.
             */
            do {
                // 循环根据传入的interface接口从cache中读取
                Object value = cache.get(key);
                if (value instanceof Reference) {
                    // 如果是Reference，则在Reference中尝试获取代理类
                    proxyClass = (Class) ((Reference) value).get();
                }
                if (proxyClass != null) {
                    // proxy class already generated: return it
                    // 如果读到的不为空，表示之前已经进行了代理类的生成，则直接返回
                    return proxyClass;
                } else if (value == pendingGenerationMarker) {
                    // 代理类正在被生成，需要等待
                    try {
                        cache.wait();
                    } catch (InterruptedException e) {
                    }
                    continue;
                } else {
                    // 表示没有获取到相关的代理类，或者代理类正在生成，用这个属性进行标记
                    cache.put(key, pendingGenerationMarker);
                    break;
                }
            } while (true);
        }

        try {
            String proxyPkg = null;    // package to define proxy class in

            /*
             * 验证所有的非public的接口是否在同一个包，
             * 如果不在，将会报错，如果都在同一个包，将记录这个包名
             * 实现的代理类将放在这个包中
             */
            for (int i = 0; i < interfaces.length; i++) {
                // 获取接口访问权限
                int flags = interfaces[i].getModifiers();
                if (!Modifier.isPublic(flags)) {
                    // 如果接口不是是public的
                    String name = interfaces[i].getName();
                    // 获取接口包名
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {    // if no non-public proxy interfaces,
                proxyPkg = "";        // use the unnamed package
            }

            {
                // 维护代理标记数字
                long num;
                synchronized (nextUniqueNumberLock) {
                    num = nextUniqueNumber++;
                }
                // 代理类名即 包名 + proxyClassNamePrefix（本例中即 $Proxy） + 数字
                String proxyName = proxyPkg + proxyClassNamePrefix + num;

                // 生成指定的代理类文件
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                        proxyName, interfaces);
                try {
                    // 生成指定的代理类
                    proxyClass = defineClass0(loader, proxyName,
                            proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    throw new IllegalArgumentException(e.toString());
                }
            }
            // 将代理类进行缓存
            proxyClasses.put(proxyClass, null);

        } finally {
            /*
             * 最后对生成的代理类进行缓存，缓存在cache（即loaderToCache）中，
             * 以接口名为键，以WeakReference包装的代理类为值
             */
            synchronized (cache) {
                if (proxyClass != null) {
                    cache.put(key, new WeakReference(proxyClass));
                } else {
                    cache.remove(key);
                }
                cache.notifyAll();
            }
        }
        return proxyClass;
    }

    /**
     * 返回代理对象的实例对象，需要制定类加载器，接口列表和调用处理器
     *
     * @param h          调用处理器
     * @param loader     类加载器
     * @param interfaces 接口列表
     * @return 代理类实例
     * @throws IllegalArgumentException 如果违反传递到getProxyClass的参数上的任何限制（来自getProxyClass的异常）
     * @throws NullPointerException     如果interfaces数组参数或其任何元素为null（来自getProxyClass的异常）
     */
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
            throws IllegalArgumentException {
        if (h == null) {
            throw new NullPointerException();
        }

        // 根据传入的ClassLoader和interfaces查找对象的代理类
        Class cl = getProxyClass(loader, interfaces);

        try {
            /**
             * 获得代理类的构造器，这里默认传入的参数是constructorParams
             * 所以我们在分步调用的时候可以直接传入new Class[]{InvocationHandler.class}
             */
            Constructor cons = cl.getConstructor(constructorParams);
            // 反射方式创建代理对象，传入了调用处理器
            return (Object) cons.newInstance(new Object[]{h});
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        } catch (IllegalAccessException e) {
            throw new InternalError(e.toString());
        } catch (InstantiationException e) {
            throw new InternalError(e.toString());
        } catch (InvocationTargetException e) {
            throw new InternalError(e.toString());
        }
    }

    /**
     * 判断某个类是否是代理类
     *
     * @param cl 测试的目标类
     * @return
     * @throws NullPointerException cl为null时
     */
    public static boolean isProxyClass(Class<?> cl) {
        if (cl == null) {
            throw new NullPointerException();
        }
        // 在proxyClasses中查找键
        return proxyClasses.containsKey(cl);
    }

    /**
     * 返回特定代理对象的调用处理器
     *
     * @param proxy 代理类的实例对象
     * @return 该代理类的实例对象的调用处理器
     * @throws IllegalArgumentException 当传入的proxy不是代理类对象时
     */
    public static InvocationHandler getInvocationHandler(Object proxy)
            throws IllegalArgumentException {
        // 首先判断传入的对象是否是代理类生成的对象
        if (!isProxyClass(proxy.getClass())) {
            throw new IllegalArgumentException("not a proxy instance");
        }
        // 直接返回h，即构造Proxy时传入的调用处理器
        java.lang.reflect.Proxy p = (java.lang.reflect.Proxy) proxy;
        return p.h;
    }

    // 本地方法，用于生成代理类
    private static native Class defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);
}

private static void getBugattiProxyClassFile() {
    Bugatti bugatti = new Bugatti("Bugatti Chiron");
    byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", bugatti.getClass().getInterfaces());
    String path = "/Users/LennonChin/Desktop/BugattiProxyClass.class";
    FileOutputStream fos = null;
    try {
        fos = new FileOutputStream(path);
        fos.write(classFile);
        fos.flush();
        System.out.println("代理类class文件写入成功");
    } catch (Exception e) {
        System.out.println("写文件错误");
    } finally {
        if (fos != null) {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.coderap.foundation.proxy.Car;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Car {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m0;
    private static Method m2;

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("com.coderap.foundation.proxy.Car").getMethod("getInfo");
            m3 = Class.forName("com.coderap.foundation.proxy.Car").getMethod("run");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    public $Proxy0(InvocationHandler var1) throws {
        super(var1);
    }

    public final String getInfo() throws {
        try {
            return (String) super.h.invoke(this, m4, (Object[]) null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void run() 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 {
        try {
            return (Boolean) super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 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);
        }
    }
}