java动态代理源码分析

所谓动态代理，即通过代理类Proxy的代理，接口和实现类之间可以不直接发生联系，而可以在运行期（Runtime）实现动态关联。

Java动态代理类位于Java.lang.reflect包下，主要涉及到两个类。

（1）接口InvocationHandler：该接口中仅定义了一个方法。

Object invoke(Object obj, Method method, Object[] args);
在实际使用时，第一个参数obj一般指代理类，method是被代理的方法，args为该方法的参数数组。

（2）proxy：该类即为动态代理类，作用类实现了InvocationHandler接口的代理类，其中主要方法有：

protected Proxy(InvocationHandler h)：构造方法，用于给内部的h赋值。
static Class getProxyClass(ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用。

动态代理应用

public interface Hello {
    public void sayHello();
}
//实现接口
public class HelloEarth implements Hello {
    @Override
    public void sayHello() {
        System.out.println("Hello earth!");
    }

}

//实现接口增强
public class HelloEarthWrapper1 implements Hello {
    private Hello helloImpl;
    public HelloEarthWrapper1(Hello helloImpl) {
        this.helloImpl = helloImpl;
    }
    @Override
    public void sayHello() {
        System.out.println("在sayHello之前执行了这条语句......");
        helloImpl.sayHello();
    }
}

//通过继承对类进行增强
public class HelloEarthWrapper2 extends HelloEarth {
    private Hello helloImpl;
    public HelloEarthWrapper2(Hello helloImpl) {
        this.helloImpl = helloImpl;
    }
    @Override
    public void sayHello() {
        System.out.println("在sayHello之前执行了这条语句......");
        helloImpl.sayHello();
    }
}

//实现InvocationHandler接口
public class HelloHandler implements InvocationHandler {

    private Object proxyed; // 被代理的类

    // 被代理的对象
    public HelloHandler(Object obj) {
        this.proxyed = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object result;
        System.out.println("在sayHello()之前可以执行的语句");
        // 调用原始对象的方法
        result = method.invoke(this.proxyed, args);
        System.out.println("在调用sayHello()之后");
        return result;
    }
}

//测试
    @Test
    public void test1() {
        Hello helloImpl = new HelloEarth();
        Hello helloWrapper = new HelloEarthWrapper2(helloImpl);
        helloWrapper.sayHello();
    }

    @Test
    public void test2() {
        // 被代理类的实例
        Hello hello = new HelloEarth();
        // InvocationHandler接口,传入被代理的类

        InvocationHandler handler = new HelloHandler(hello);

        // 生成代理类
        // 1. 给我被代理类的类加载器加载被代理的类，为啥要类加载器呢
        // 2. 给我被代理类的接口信息
        // 3. 给我如何增强接口中的方法信息
        Hello proxy = (Hello) Proxy.newProxyInstance(hello.getClass()
        .getClassLoader(), hello.getClass().getInterfaces(), handler);
        // 调用代理的方法
        proxy.sayHello();
    }

使用包装类进行包装

包装类中有一个被包装的类的引用作为属性，和被包装类实现相同的接口，然后在实现接口的方法中调用和被包装类同名的接口中的方法实现方法的增强。这种解决方案的缺点就是当接口中的方法过多的时候就需要为接口中的每个方法都写一遍，即时不需要增强的方法也需要实现。

另一种做法是继承被包装的类，然后在包装类中重写需要增强的方法，但是缺点是只有在被包装类出现的地方才能使用被包装类，而实现接口的方法是在接口出现的地方都可以使用包装类。继承了被包装类之后的类，就是去了接口的好处，在包装类作为引用类型的地方必须的是被包装类及其子类，而不是接口出现。

使用动态代理

使用动态代理则可以不需要实现接口中所有的方法，又可以获得接口的好处。动态代理要求要包装的对象必须实现一个接口，该接口定义了准备在包装器中使用的所有方法，这一限制是鼓励面向接口的编程，而不是限制编程，根据经验，每个类至少应该实现一个接口。良好的接口用法不仅使动态代理成为可能，还有利于程序的模块化。

主要的步骤有：

首先根据被代理对象创建一个代理类

创建动态代理对象的proxy1，第一个参数为被代理类的类加载器，第二个参数为该类的接口，第三个对象为代理对象的实例。

通过调用代理对象中增强的方法

上述过程就是告诉Proxy类用一个指定的类加载器来动态创建一个对象，该对象要实现指定的接口，并用提供的InvocationHandler来代替传统的方法主体。在实现InvocationHandler接口的类中invoke()方法中，完全不存在对Hello接口的引用，在上述的例子中，以构造方法的传参的形式，为InvocationHandler的实现类提供了被代理接口的实例。代理接口实例上的任何方法调用最终都由InvocationHandler的实例委托给代理接口实例，这是最常见的设计。但是，InvocationHandler实例不一定非要委托给被代理的接口的另一个实例。事实上，InvocationHandler可以自行提供方法主体，完全不必委托给被代理类来实现。如果被代理接口发生变化，InvocationHandler中的实例仍然是可用的。

动态代理可以实现许多AOP方面的功能：安全、事务、日志、过滤、编码、解码等功能，而且纯粹是热插拔的。AOP的好处是可以对类的实例统一实现拦截操作，通常应用在日志、权限、缓存、连接池中等。

** 基于动态代理的字节码库 **

了解动态代理的原理之后，我们完全可以自己实现这样一个动态代理，只要生成该类的class文件的内存映像即可。有很多这样的工具。

BCEL：

SERP：

ASM：Java字节码汇编语言。ASM是轻量级的Java字节码处理框架，可以动态生成二进制格式的stub类或其他代理类，或者在类被Java虚拟机装载之前动态修改类。ASM设计的目的就是在运行时使用，因此要尽量体积小速度快。

cglib：Code Generation Library的缩写，依赖与ASM库。Spring和Hibernate选择了同样的cglib包。Hibernate主要利用cglib生成pojo的子类并用override get方法来实现lazy loading机制，Spring则是利用cglib来实现动态代理。JDK的动态代理必须得实现接口才行。

使用CGLib进行动态代理

//普通类
public class HelloWorld{
    public void savePerson() {
        System.out.println("hello, world!");
    }
}

//增强类
public class HelloWorldInterceptor implements MethodInterceptor{

    // 被增强的类
    private Object target;
    // 如何增强方法的信息
    private Strength strength;

    public HelloWorldInterceptor(Object target, Strength strength) {
        super();
        this.target = target;
        this.strength = strength;
    }

    /**
     * 用来产生代理对象
     */
    public Object createProxy(){
        // 增强类
        Enhancer enhancer = new Enhancer();
        // 设置增强类的回调方法
        enhancer.setCallback(this);
        //设置代理类的父类
        enhancer.setSuperclass(HelloWorld.class);
        return enhancer.create();
    }

    // 这里相当于InvocationHandler接口中的invoke方法
    public Object intercept(Object arg0, Method method, Object[] arg2,
            MethodProxy arg3) throws Throwable {
        this.strength.begin();
        method.invoke(target, arg2);
        this.strength.end();
        return null;
    }
}

//增强的方法

// 待增强的方法
public class Strength {
    // 前增强
    public void begin(){
        System.out.println("begin......");
    }
    // 后增强
    public void end(){
        System.out.println("end.......");
    }
}

//测试
/**
 * 使用cglib产生的代理类，其代理类是目标类的子类
 */
public class TestHello {
    @Test
    public void testPersonDaoProxy(){
        Object target = new HelloWorld();
        Strength strength = new Strength();
        HelloWorldInterceptor interceptor = new HelloWorldInterceptor(target, strength);
        HelloWorld helloWorldProxy = (HelloWorld)interceptor.createProxy();
        helloWorldProxy.savePerson();
    }
}

源码分析

InvocationHandler源码

/**
 * 每个代理类实例都有一个与之关联的invocation句柄。
 * 当代理类的实例调用一个方法的时候，
 * 该方法的invocation被编码并且被分发到它对应的invocation句柄
 */
public interface InvocationHandler {

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

Proxy源码

/**
 * Proxy类提供了用于创建代理对象和实例的静态方法， 并且它也是所有通过这些静态方法创建出的代理类的父类。
 *
 * 从某个接口创建代理对象的方法如下：
 *
 * InvocationHandler handler = new MyInvocationHandler(...);
 * Class proxyClass = Proxy.getProxyClass(
 *     Foo.class.getClassLoader(), new Class[] { Foo.class });
 * Foo f = (Foo) proxyClass.
 *     getConstructor(new Class[] { InvocationHandler.class }).
 *     newInstance(new Object[] { handler });
 * 或者有更简单的方法
 * Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
 *                   new Class[] { Foo.class }, handler);
 *
 * 一个动态代理类（以下简称为代理类）是该类被创建时在运行时动态
 * 实现一系列接口的类，有如下的特性。
 *
 * 动态代理接口是被动态类实现的接口。代理实例是代理类一个一个实例。
 *
 * 每个代理实例都和一个实现了InvocationHandler接口的invocation handler对象关联。
 * 通过代理接口进行的代理类实例的方法调用将会被分发给invocation handler实例，同时传递的
 * 参数有代理实例，确定被调用方法的Method对象和Object数组类型的参数。
 */

// 代理对象是可以序列化的
public class Proxy implements java.io.Serializable {

    private static final long serialVersionUID = -2222568056686623797L;

    /** 为所有代理类的类名添加前缀，难怪hibernate中很多类都有$Proxy */
    private final static String proxyClassNamePrefix = "$Proxy";

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

    /** 将代理类的类加载器放在Proxy的maps结构中缓存起来 */
    /** 为啥这里用了WeakHashMap() */
    private static Map<ClassLoader, Map<List<String>, Object>> loaderToCache
        = new WeakHashMap<>();

    /** 用于标记正在生成的代理类 */
    private static Object pendingGenerationMarker = new Object();

    /** 下一个用于生成唯一代理类名字的数字 */
    private static long nextUniqueNumber = 0;
    private static Object nextUniqueNumberLock = new Object();

    /** 所有代理类的集合，用于isProxyClass方法的实现 */
    private static Map<Class<?>, Void> proxyClasses =
        Collections.synchronizedMap(new WeakHashMap<Class<?>, Void>());

    /**
     * 代理实例的invocationHandler对象，原来放在这儿啊.
     * @serial
     */
    protected InvocationHandler h;

    /**
     * 禁止实例化
     */
    private Proxy() {
    }

    /**
     * 从一个子类中创建代理类的实例（最典型的是一个动态代理类）
     * 构造方法的参数是用来指定invocation handler
     * 这个方法还是受保护的呢
     */
    protected Proxy(InvocationHandler h) {
        doNewInstanceCheck();
        this.h = h;
    }

    /**
     * 为什么不注释这个方法?
     * 类名大致意思是代理访问助手?
     * 这还是个静态的内部类
     */
    private static class ProxyAccessHelper {
        // The permission is implementation specific.
        // 权限是指定实现的。
        static final Permission PROXY_PERMISSION =
            new ReflectPermission("proxyConstructorNewInstance");
        // These system properties are defined to provide a short-term
        // workaround if customers need to disable the new security checks.
        // 这些系统配置被定义用来提供短期的配置，如果用户需要禁止新的安全检查。
        static final boolean allowNewInstance;
        static final boolean allowNullLoader;
        static {
            allowNewInstance = getBooleanProperty("sun.reflect.proxy.allowsNewInstance");
            allowNullLoader = getBooleanProperty("sun.reflect.proxy.allowsNullLoader");
        }

        // 方法参数还可以这样修饰final?
        private static boolean getBooleanProperty(final String key) {
            String s = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty(key);
                }
            });
            return Boolean.valueOf(s);
        }

        // 需要进行创建新实例的检查么
        static boolean needsNewInstanceCheck(Class<?> proxyClass) {
            if (!Proxy.isProxyClass(proxyClass) || allowNewInstance) {
                return false;
            }

            if (ReflectUtil.isNonPublicProxyClass(proxyClass)) {
                for (Class<?> intf : proxyClass.getInterfaces()) {
                    if (!Modifier.isPublic(intf.getModifiers())) {
                        return true;
                    }
                }
            }
            return false;
        }
    }

    /*
     * Access check on a proxy class that implements any non-public interface.
     *
     * @throws  SecurityException if a security manager exists, and
     *          the caller does not have the permission.
     */
    private void doNewInstanceCheck() {
        SecurityManager sm = System.getSecurityManager();
        Class<?> proxyClass = this.getClass();
        if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(proxyClass)) {
            try {
                sm.checkPermission(ProxyAccessHelper.PROXY_PERMISSION);
            } catch (SecurityException e) {
                throw new SecurityException("Not allowed to construct a Proxy "
                        + "instance that implements a non-public interface", e);
            }
        }
    }

    /**
     * 这个方法是重头了
     * 从给定的类加载器和接口数组返回动态代理类的Class对象。
     * Returns the {@code java.lang.Class} object for a proxy class
     * given a class loader and an array of interfaces.
     * 代理将会通过指定的类加载器所定义而且将会实现所提供的所有的接口。
     *
     * 如果已经有实现了相同接口的代理类存在，那么将会直接放回已经存在的代理类;
     * 否则，将会动态地创建和由类加载器定义的代理类被返回。

     * 对于传递给Proxy.getProxyClass方法的参数有若干限制。
     *
     * 在数组中所有的类类型必须是接口，不是其他的类类型或者原始类型。
     * 接口数组中的接口必须两两不同
     * 所有的接口类型都可以通过指定的类加载器按名字进行加载。
     * 也就是对于数组中的每个接口i如下判断必须为true
     *     Class.forName(i.getName(), false, cl) == i
     *
     * 所有非公开的接口都必须在相同的包里面;不然的话，代理类不可能实现所有的接口，
     * 不论它是在哪个包里面定义的。
     *
     * 对于指定接口的成员方法的集合的中的方法必须有相同的签名。
     *
     * 如果任何方法的返回类型是原始类型或者为空，那么所有的的方法都必须有相同的返回类型。
     *
     * 不然，其中一个方法必须可以对其他方法的返回类型是可赋值的。
     *
     * 生成的代理类不能超过虚拟机对其中的类的限制。例如，虚拟机会限制一个类的接口个数不超过65535;
     * 因此传进去的接口的数组的长度不能超过65535
     *
     * 如果以上约束有违反的话，将会抛出IllegalArgumentException异常。
     * 如果有接口是null的话，就会报NullPointerException异常。
     *
     * 注意到特定的代理接口的顺序是有意义的:对于创建具有相同代理接口的不同顺序的请求生成的代理类是不同的两个
     * 代理类。（卧槽，这个也有影响，不读下源码一脸懵逼）
     */
    @CallerSensitive
    public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
        throws IllegalArgumentException
    {
        // 安全管理
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, interfaces);
        }

        // 返回代理对象
        return getProxyClass0(loader, interfaces);
    }

    /*
     * Check permissions required to create a Proxy class.
     *
     * To define a proxy class, it performs the access checks as in
     * Class.forName (VM will invoke ClassLoader.checkPackageAccess):
     * 1. "getClassLoader" permission check if loader == null
     * 2. checkPackageAccess on the interfaces it implements
     *
     * To get a constructor and new instance of a proxy class, it performs
     * the package access check on the interfaces it implements
     * as in Class.getConstructor.
     *
     * If an interface is non-public, the proxy class must be defined by
     * the defining loader of the interface.  If the caller's class loader
     * is not the same as the defining loader of the interface, the VM
     * will throw IllegalAccessError when the generated proxy class is
     * being defined via the defineClass0 method.
     */
    private static void checkProxyAccess(Class<?> caller,
                                         ClassLoader loader,
                                         Class<?>... interfaces)
    {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader ccl = caller.getClassLoader();
            if (loader == null && ccl != null) {
                if (!ProxyAccessHelper.allowNullLoader) {
                    sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
            ReflectUtil.checkProxyPackageAccess(ccl, interfaces);
        }
    }

    /**
     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     */
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {

        // 判断接口的个数                                       
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // 代理类
        Class<?> proxyClass = null;

        /* 接口名称的集合用来作为代理类的缓存 */
        String[] interfaceNames = new String[interfaces.length];

        // 检查接口是否有重复的
        Set<Class<?>> interfaceSet = new HashSet<>();

        for (int i = 0; i < interfaces.length; i++) {
            /*
             * 验证类加载器对接口名称的解析是同一个对象
             * 因为不同类加载加载的类是不同的
             */

            // 获取接口的名字
            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");
            }

            /*
             * Verify that the Class object actually represents an
             * interface.
             */
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }

            /*
             * Verify that this interface is not a duplicate.
             */
            if (interfaceSet.contains(interfaceClass)) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }

            // 将接口加入到集合中
            interfaceSet.add(interfaceClass);

            interfaceNames[i] = interfaceName;
        }

        /*
         * 使用字符串代表代理接口作为代理类缓存的主键（而不是它们的类对象）
         * 已经足够了因为我们要求代理接口必须能根据给定的类加载器通过名字被解析，
         * 而且还有一个好处是，使用字符串代表类弥补了对类的隐式弱引用。
         */

        // 将数组转为字符串
        List<String> key = Arrays.asList(interfaceNames);

        /*
         * 根据类加载器找到或者创建代理类的缓存.
         */
        Map<List<String>, Object> cache;
        synchronized (loaderToCache) {
            cache = loaderToCache.get(loader);
            if (cache == null) {
                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 {
                Object value = cache.get(key);
                if (value instanceof Reference) {
                    proxyClass = (Class<?>) ((Reference) value).get();
                }
                if (proxyClass != null) {
                    // proxy class already generated: return it
                    return proxyClass;
                } else if (value == pendingGenerationMarker) {
                    // proxy class being generated: wait for it
                    try {
                        cache.wait();
                    } catch (InterruptedException e) {
                        /*
                         * The class generation that we are waiting for should
                         * take a small, bounded time, so we can safely ignore
                         * thread interrupts here.
                         */
                    }
                    continue;
                } else {
                    /*
                     * No proxy class for this list of interfaces has been
                     * generated or is being generated, so we will go and
                     * generate it now.  Mark it as pending generation.
                     */
                    cache.put(key, pendingGenerationMarker);
                    break;
                }
            } while (true);
        }

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

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (int i = 0; i < interfaces.length; i++) {
                int flags = interfaces[i].getModifiers();
                if (!Modifier.isPublic(flags)) {
                    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, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            {
                /*
                 * Choose a name for the proxy class to generate.
                 */
                long num;
                synchronized (nextUniqueNumberLock) {
                    num = nextUniqueNumber++;
                }
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
                /*
                 * Verify that the class loader hasn't already
                 * defined a class with the chosen name.
                 */

                /*
                 * 生成指定的代理类，可以看出这里的是二进制类型
                 * ProxyGenerator的源码看不到了
                 */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces);
                try {
                    // defineClass0是一个本地方法
                    proxyClass = defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    /*
                     * A ClassFormatError here means that (barring bugs in the
                     * proxy class generation code) there was some other
                     * invalid aspect of the arguments supplied to the proxy
                     * class creation (such as virtual machine limitations
                     * exceeded).
                     */
                    throw new IllegalArgumentException(e.toString());
                }
            }
            // 将其加入到所有生成的代理类的集合中，用于判断是否是代理类.
            proxyClasses.put(proxyClass, null);

        } finally {
            /*
             * We must clean up the "pending generation" state of the proxy
             * class cache entry somehow.  If a proxy class was successfully
             * generated, store it in the cache (with a weak reference);
             * otherwise, remove the reserved entry.  In all cases, notify
             * all waiters on reserved entries in this cache.
             */
            synchronized (cache) {
                if (proxyClass != null) {
                    cache.put(key, new WeakReference<Class<?>>(proxyClass));
                } else {
                    cache.remove(key);
                }
                cache.notifyAll();
            }
        }

        // 返回代理类
        return proxyClass;
    }

    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        // 安全检查
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, interfaces);
        }

        /*
         * 查找或者生成指定的代理类
         */
        Class<?> cl = getProxyClass0(loader, interfaces);

        /*
         * 调用指定了invocation handler的构造方法。
         */
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return newInstance(cons, ih);
                    }
                });
            } else {
                // 直接返回了代理对象
                return newInstance(cons, ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

    private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
        try {
            return cons.newInstance(new Object[] {h} );
        } catch (IllegalAccessException | InstantiationException e) {
            throw new InternalError(e.toString());
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString());
            }
        }
    }

    /**
     * Returns true if and only if the specified class was dynamically
     * generated to be a proxy class using the {@code getProxyClass}
     * method or the {@code newProxyInstance} method.
     *
     * <p>The reliability of this method is important for the ability
     * to use it to make security decisions, so its implementation should
     * not just test if the class in question extends {@code Proxy}.
     *
     * @param   cl the class to test
     * @return  {@code true} if the class is a proxy class and
     *          {@code false} otherwise
     * @throws  NullPointerException if {@code cl} is {@code null}
     */
    public static boolean isProxyClass(Class<?> cl) {
        if (cl == null) {
            throw new NullPointerException();
        }

        return proxyClasses.containsKey(cl);
    }

    /**
     * Returns the invocation handler for the specified proxy instance.
     *
     * @param   proxy the proxy instance to return the invocation handler for
     * @return  the invocation handler for the proxy instance
     * @throws  IllegalArgumentException if the argument is not a
     *          proxy instance
     */
    @CallerSensitive
    public static InvocationHandler getInvocationHandler(Object proxy)
        throws IllegalArgumentException
    {
        /*
         * Verify that the object is actually a proxy instance.
         */
        if (!isProxyClass(proxy.getClass())) {
            throw new IllegalArgumentException("not a proxy instance");
        }

        final Proxy p = (Proxy) proxy;
        final InvocationHandler ih = p.h;
        if (System.getSecurityManager() != null) {
            Class<?> ihClass = ih.getClass();
            Class<?> caller = Reflection.getCallerClass();
            if (ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(),
                                                    ihClass.getClassLoader()))
            {
                ReflectUtil.checkPackageAccess(ihClass);
            }
        }

        return ih;
    }

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