动态代理 2-JDK动态代理之Proxy源码

实例
- InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。
源码
几个相关的问题
生成的代理类

实例

public interface Person {
    void getMoney();
}
public class Student implements Person{
    @Override
    public void getMoney() {
        System.out.println("捐款 50");
    }
}

public class ProxyStudy {
    public static void main(String[] args) {
        Person student = new Student();
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object p, Method method, Object[] args) throws Throwable {
                System.out.println("代理：" + method.getName());
                Object result = method.invoke(student, args);
                return result;
            }
        };
        Person o = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[]{Person.class}, h);
        o.getMoney();
    }
}

输出：

代理：getMoney
捐款 50

InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。

源码

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /*
         * Look up or generate the designated proxy class.
         */
         //生成代理类
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //获取代理类实例，将 InvocationHandler 传入进去。
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

安全管理器检查与代理权限检查
判断接口的长度是否大于65535，大于不可往下进行。然后从WeakCache缓存中获取代理类,如果找不到则通过proxyClassFactory生成代理类。生成代理类的class过程如下：
1. 验证传入的interface是否可被传入的classloader装载
2. 验证传入的是否是一个接口,如果不是一个接口，直接抛出IllegalArgumentException异常
3. 判断传入的是否重复，这里是通过一个IdentityHashMap往里面put接口的class类，如果返回值不为null表示这个接口已经注册过了(如果第一次put会返回null，按照传统的做法是先get是否为null,如果不为null再put,这行代码很妙省去了这个步骤)，IdentityHashMap也是map的一种，不过它与我们普通的HashMap最大的不同在于它不会通过equals方法和hashCode方法去判断key是否重复,而是通过==运算符
4. 拼接代理类的名字固定为：com.sun.proxy.$Proxy+原子自增序号，为了防止并发调用，在生成代理类名字的时候，采用了AtomicLong的getAndIncrement方法去原子递增代理类的序列号，这个方法是原子的，所以不会产生并发问题。这里也就是我们为什么看到最后的代理类是$Proxy0的原因(生成的代理类的序号是从0开始的)
5. 调用ProxyGenerator.generateProxyClass方法来生成代理的class类(过程较为复杂、通过一些jvm指令去生成字节码,包括遍历方法类型、返回值、参数类型等)
6. 通过defineClass将上一步产生的class字节码生成class文件，该方法也是一个native方法，需要传入类的classloader来进行装载生成的类字节码进而生成class
通过反射获取构造器constractor创建一个反射实例,这个过程进行了强制构造器的private私有化反射

几个相关的问题
为什么动态代理需要传入classLoader?

主要原因有以下几个：
1. 需要校验传入的接口是否可被当前的类加载器加载,假如无法加载，证明这个接口与类加载器不是同一个，按照双亲委派模型，那么类加载层次就被破坏了
2. 需要类加载器去根据生成的类的字节码去通过defineClass方法生成类的class文件，也就是说没有类加载的话是无法生成代理类的
为什么动态代理需要传入接口和只能代理接口？

代理类继承了 Proxy 类，所以也就决定了只能对接口进行代理。
需要接口去通过ProxyGenerator类来生成代理类的字节码，在生成的过程中，需要遍历接口中的方法，包括方法签名、参数类型、返回类型从而生成新的代理类，而代理类也需要继承原始接口的方法，所以接口必须要传。

如果同一个接口创建多次代理会怎么样？

在获取代理对象的时候首先会从缓存(WeakCache)里面取，如果取不到才会通过代理工厂去创建，所以如果创建多个代理类的话，最终只会产生一个代理类。

生成的代理类

通过以下代码生成代理类

public static void generatorProxyClass(){
    byte[] classFile = ProxyGenerator.generateProxyClass("StuProxy$Proxy0", Student.class.getInterfaces());
    String path = "out/production/JavaDemo/设计模式/代理模式/StuProxy$Proxy0.class";
    try(FileOutputStream fos = new FileOutputStream(path)) {
        fos.write(classFile);
        fos.flush();
        System.out.println("代理类class文件写入成功");
    } catch (Exception e) {
        System.out.println("写文件错误");
    }
}

代理类

public final class StuProxy$Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;
 /**
  *注意这里是生成代理类的构造方法，方法参数为InvocationHandler类型，看到这，是不是就有点明白
  *为何代理对象调用方法都是执行InvocationHandler中的invoke方法，而InvocationHandler又持有一个
  *被代理对象的实例，不禁会想难道是....？ 没错，就是你想的那样。
  *
  *super(paramInvocationHandler)，是调用父类Proxy的构造方法。
  *父类持有：protected InvocationHandler h;
  *Proxy构造方法：
  *    protected Proxy(InvocationHandler h) {
  *         Objects.requireNonNull(h);
  *         this.h = h;
  *     }
  *
  */
    public StuProxy$Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    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 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 void getMoney() throws  {
        try {
            //这里调用了 InvocationHandler 的 invoke 方法。
            super.h.invoke(this, m3, (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);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("设计模式.代理模式.Person").getMethod("getMoney");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）

实例

InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。

源码

几个相关的问题

生成的代理类