Proxy.newProxyInstance实现动态代理

    @CallerSensitive
    public static Object newProxyInstance(ClassLoader var0, Class<?>[] var1, InvocationHandler var2) throws IllegalArgumentException {
        // 判断InvocationHandler是否为空，动态代理方法在执行时，会调用var2里面的invoke方法去执行
        Objects.requireNonNull(var2);
        // 生成一个实现参数interfaces（new Class<?>[] { clazz）里面所有接口，继承了Proxy的代理类的字节码；然后用参数里面的clazz.getClassLoader()加载这个代理类
        Class[] var3 = (Class[])var1.clone();
        // 对传入的接口var1进行安全检查checkProxyAccess
        SecurityManager var4 = System.getSecurityManager();
        if (var4 != null) {
            checkProxyAccess(Reflection.getCallerClass(), var0, var3);
        }
		// 动态代理的核心，生成一个新类var5
        Class var5 = getProxyClass0(var0, var3);
		// 将这个新类完善
        try {
            if (var4 != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), var5);
            }
            // 通过反射，获取构造函数对象
	// private static final Class<?>[] constructorParams = new Class[]{InvocationHandler.class};
            final Constructor var6 = var5.getConstructor(constructorParams);
            if (!Modifier.isPublic(var5.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        var6.setAccessible(true);
                        return null;
                    }
                });
            }
         // 使用代理类父类的构造函数Proxy(InvocationHandler handler)来创造一个代理类的实例；将我们自定义的InvocationHandler 的子类传入；
		// 生成代理类实例
            return var6.newInstance(var2);
        } catch (InstantiationException | IllegalAccessException var8) {
            throw new InternalError(var8.toString(), var8);
        } catch (InvocationTargetException var9) {
            Throwable var7 = var9.getCause();
            if (var7 instanceof RuntimeException) {
                throw (RuntimeException)var7;
            } else {
                throw new InternalError(var7.toString(), var7);
            }
        } catch (NoSuchMethodException var10) {
            throw new InternalError(var10.toString(), var10);
        }
    }

举个栗子

InvocationHandler handler = new ServiceHandler(clazz);
Object  proxy = Proxy.newProxyInstance(clazz.getClassLoader(), new Class<?>[] { clazz }, handler);

其中clazz需要实现一个接口，动态生成的代理类 $Proxy0.class，实现这个接口。这个接口就是提供一个自己的类到proxy之间的桥梁。并且继承Proxy。执行InvocationHandler对象的invoke()方法的时候就是执行父类中的invoke方法；