JAVA代理之JDK Proxy

写在前面

本篇博客是基于对动态代理，java的重写，多态特性了解的基础上对于源码的阅读，先提出几个问题
1.从静态代理变成动态代理需要解决两个问题，如何动态实现被代理类的接口并摘取接口中的方法，如果动态的为被代理方法添加附加逻辑
2.给出一个例子：

interface a {
	String get() throws Exception;
}

interface b {
	Object get() throws NullPointerException;
 }
}

如果我要代理即实现了a又实现了b的类的get方法，那么在代理类$Proxy0中基于a和b的get方法动态生成的get方法的描述是什么？怎么实现？
3.能否举出代理失败的例子？（两种？）
阅读建议：涉及的方法以及域比较多，前后是连贯的，抓住关联

重要的域

先从proxy类开始

//一个静态常量,后面会用到
private static final Class<?>[] constructorParams = { InvocationHandler.class };

//代理类的缓存
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

//InvocationHandler类型变量，注意它的访问权限为protected，也就是说子类可以为它赋值
protected InvocationHandler h;

newProxyInstance

/**
*loader:常常将被代理类的classloader传入
*interfaces：被代理类的接口集合
*h:代理辅助类，被代理方法的实际调用者
**/
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        //检查h是否为空，如果为空则抛出NullPointerException
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        //生成代理类
        Class<?> cl = getProxyClass0(loader, intfs);
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //反射获得代理类的构造函数，其中传入参数constructorParams是前面定义的静态常量，这也间接说明代理类的共同特点：g构造函数传入参数为InvocationHandler类型
            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;
                    }
                });
            }
            //反射会的代理类的实例
            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);
        }
    }

getProxyClass0

 	private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
       	//官方解释：如果在缓存中找到匹配loader和interfaces的代理类则直接返回，否则通过ProxyClassFactory新建一个
        return proxyClassCache.get(loader, interfaces);
    }

proxyClassCache在上述域中已经说明，它是属于WeakCache类型，传入了KeyFactory和ProxyClassFactory的实例作为参数进行了实例化，下面我们来看下get方法

get

 public V get(K key, P parameter) {
 		//确保interfaces不为空
        Objects.requireNonNull(parameter);
        //在这个方法中有很多缓存的操作，不懂，省略处理，以后填坑
        expungeStaleEntries();
        //省略
        while (true) {
            if (supplier != null) {
                //这句和代理类的生成有关
                V value = supplier.get();
        //省略
    }

上述注释的supplier.get()实现另一个方法的调用，在weakCache中有一个Factory静态内部类，它实现了supplier接口，因此supplier调用get实际是调用其子类Factory对象的get方法

get

public synchronized V get() { 
			//缓存操作不懂省略
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }
            V value = null;
            try {
            	//很明显可以发现下面的valueFactory.apply是用来生成代理类的
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } 
            //省略
        }
    }

valueFactory是上述在实例化weakCache时传入的ProxyClassFactory的对象的引用，下面查看它的apply方法

apply

 public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
 			//用来判断interfaces中是否重复的set
            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                Class<?> interfaceClass = null;
                try {
                	//用我们传入的classloader加载interface
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                //如果上述加载的interfaceclass和我们直接传入的intf不同，则说明传入的loader和interface不匹配，抛出异常
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                //判断是否为接口
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                //判断interfaces是否有重复
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
            //代理类的package值
            String proxyPkg = null;
            //代理类的访问权限 
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
            //遍历判断interfaces中是否有非public访问权限的interface，如果有的话，代理类所在的包必须和它一致
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                //如果不是公有权限
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    //下面三行代码用来获得intf所在包，例如若intf = InvacationHandler.class，pkg将等于java.lang.reflect.
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    //如果有多个非public的interface并且它们不在同一个包中，将抛出异常
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }
            //如果所有的interfaces都为public，那么代理类所在的包为com.sun.proxy.
            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
            /**下面两行代码用到两个ProxyClassFactory中的域，分别是 ：     
            /*1.private static final String proxyClassNamePrefix = "$Proxy";
            /*2.private static final AtomicLong nextUniqueNumber = new AtomicLong();
			**/
            long num = nextUniqueNumber.getAndIncrement();
            //例如proxyName为com.sun.proxy.$proxy0
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
            //核心逻辑的调用出现了
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
            	//defineClass0为本地方法，用来动态加载class文件
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

经过数次跳转，终于来到了核心代码地，即ProxyGenerator的generateProxyClass方法，sun的jdk中该部分代码不是开源，可以参考openJdk,接下来仅贴出主要代码

generateProxyClass

public static byte[] generateProxyClass(final String name, Class[] interfaces)  
 {
        ProxyGenerator gen = new ProxyGenerator(name, interfaces);
        final byte[] classFile = gen.generateClassFile();
        //中间省略
        return classFile;
    }

在介绍ProxyGenerator的其他方法之前先来看一下其中的一些域

/**一个用来过渡处理(怎么处理？)所有method对象的hashmap，String的组成是Method对象的name加上参数列表（为什么这样标识),对于代理类而言每一个String标识对应的List中必须只有一个元素，否则方法就重复了**/
private Map<String, List<ProxyMethod>> proxyMethods = new HashMap<String,List<ProxyMethod>>();
//包含代理类所有method信息的集合
private List<MethodInfo> methods = new ArrayList<>();
//包含代理类所有field信息的集合
private List<FieldInfo> fields = new ArrayList<>();

generateClassFile

private byte[] generateClassFile() {
 		//step1:针对所有接口中的方法生成Method对象
        
        //首先向proxyMethods中添加Object的hashcode，equals，toString三个method对象
         addProxyMethod(hashCodeMethod, Object.class);
         addProxyMethod(equalsMethod, Object.class);
         addProxyMethod(toStringMethod, Object.class);
 
        //然后添加接口中的method对象
         for (int i = 0; i < interfaces.length; i++) {
             Method[] methods = interfaces[i].getMethods();
             for (int j = 0; j < methods.length; j++) {
                 addProxyMethod(methods[j], interfaces[i]);
             }
         }
         //对每一个String标识的List中的所有ProxyMethod的返回值类型进行兼容性处理（涉及到重写特性)(为什么要处理？怎么处理)
         for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
             checkReturnTypes(sigmethods);
         }
 
         //step2:向methods和fields中分别添加methodInfo和FieldInfo
         try {
         	//添加构造函数
             methods.add(generateConstructor());
             for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
                 for (ProxyMethod pm : sigmethods) {
                 	//对于每个method对象添加静态引用
                     fields.add(new FieldInfo(pm.methodFieldName,
                         "Ljava/lang/reflect/Method;",
                          ACC_PRIVATE | ACC_STATIC));
 
                     //添加在proxyMethods这个hashMap中走过一遭的的ProxyMethod的methodInfo
                     methods.add(pm.generateMethod());
                 }
             }
 			//添加静态初始化方法，例如：<clinit>,类在被加载的时候，为所有静态初始化的变量生成一个clinit方法，然后在里面执行赋值
             methods.add(generateStaticInitializer());
        //step3:漫长的拼class文件系列，不再展示
 

接下来是解释前面提出的过渡处理以及开头提出的问题2

addProxyMethod

//该方法一方面是向proxyMethods这个hashmap中添加不同标识的method对象，另一方面是针对相同的标识进行兼容性处理
private void addProxyMethod(Method m, Class fromClass) {
		//反射获得method的name,parameterTypes,returnType,exceptionTypes
         String name = m.getName();
         Class[] parameterTypes = m.getParameterTypes();
         Class returnType = m.getReturnType();
         Class[] exceptionTypes = m.getExceptionTypes();
 		//形成该m的sig（标识）即name+参数列表
         String sig = name + getParameterDescriptors(parameterTypes);
        //proxyMethods是上述提到的hashMap（key为sig）
         List<ProxyMethod> sigmethods = proxyMethods.get(sig);
         //如果在proxyMethods中能找到和m标识一样的ProxyMethod，例如：开头问题2中a和b的标识就是一样的
         if (sigmethods != null) {
             for (ProxyMethod pm : sigmethods) {
             	//并且返回类型相同
                 if (returnType == pm.returnType) {
                 	//兼容性处理：将pm的异常大小要小于等于pm和m中的最小值（重写特性），不需要向proxyMethods中添加m了
                     List<Class> legalExceptions = new ArrayList<Class>();
                     collectCompatibleTypes(
                         exceptionTypes, pm.exceptionTypes, legalExceptions);
                     collectCompatibleTypes(
                         pm.exceptionTypes, exceptionTypes, legalExceptions);
                     pm.exceptionTypes = new Class[legalExceptions.size()];
                     pm.exceptionTypes =
                         legalExceptions.toArray(pm.exceptionTypes);
                     return;
                 }
             }
         }
         //如果没有找到相同的标识，proxyMethods添加一个新的key-value键值对，value是一个list初始容量为3
         else {
             sigmethods = new ArrayList<ProxyMethod>(3);
             proxyMethods.put(sig, sigmethods);
         }
         //无论是在proxyMethods中与m有相同标识但是返回类型不同，还是没有相同标识，都要向proxyMethods对应key的list中添加m
         sigmethods.add(new ProxyMethod(name, parameterTypes, returnType,
                                        exceptionTypes, fromClass));
     }

经历该方法后，proxyMethods中某个key的list的ProxyMethod个数可能大于1（如果直接用来生成代理类，将会有重复的方法），这些ProxyMethod的name和参数列表相同，返回类型不同，接下来checkReturnTypes处理

checkReturnTypes

在前面是通过

  for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
      checkReturnTypes(sigmethods);
  }

这段代码来进入checkReturnTypes方法的

/**checkReturnTypes方法是专门进行兼容性处理，对于需要实现的接口中有重复的方法（如前面问题2的a,b），为了对实现这些接口的类都进行代理，代理类必须生成一个同时对它们进行重写了的方法，也就是说动态生成的这个方法，在每个接口看来都是对它内部抽象方法的重写，真相就是：代理类方法的返回类型必须是interfaces中所有重复方法返回类型的中的一个，并且这个返回类型是其他重复方法返回类型的子类（例如：参照开头interface a,b，代理类的get方法的返回类型是String）**/
 static void checkReturnTypes(List<ProxyMethod> methods) {
 	   //如果proxyMethods中该标识的list元素小于2，那就不需要处理了
       if (methods.size() < 2) {
           return;
       }
       //用来记录已经处理的所有返回类型中，已经兼容其它返回类型的返回类型（例如：参照开头interface a,b，在处理了它们的重复get方法之后，代理类方法返回类型为String）
       LinkedList<Class<?>> uncoveredReturnTypes = new LinkedList<>();
   //continue的跳转标签
   nextNewReturnType:
       for (ProxyMethod pm : methods) {
           Class<?> newReturnType = pm.returnType;
           //如果某个Proxymethod的返回类型是基本类型（int,char,long,double等),就直接抛出异常，因为基本类型和其它返回类型都不兼容
           if (newReturnType.isPrimitive()) {
               throw new IllegalArgumentException(
                   "methods with same signature " +
                   getFriendlyMethodSignature(pm.methodName,
                                              pm.parameterTypes) +
                   " but incompatible return types: " +
                   newReturnType.getName() + " and others");
           }
           boolean added = false;
           //遍历uncoveredReturnTypes
           ListIterator<Class<?>> liter = uncoveredReturnTypes.listIterator();
           while (liter.hasNext()) {
               Class<?> uncoveredReturnType = liter.next();
               //如果pm的返回类型是uncoveredReturnType的父类，那么uncoveredReturnType也兼容pm，直接continue
               if (newReturnType.isAssignableFrom(uncoveredReturnType)) {
                   assert !added;
                   continue nextNewReturnType;
               }
               //如果pm的返回类型是uncoveredReturnType的子类，那么pm代替uncoveredReturnType兼容其它已经处理的returntype
               if (uncoveredReturnType.isAssignableFrom(newReturnType)) {
                   if (!added) {
                       liter.set(newReturnType);
                       added = true;
                   } 
                   //uncoveredReturnType中可能也有多个returnType，它们之间不兼容，当下面分支执行的时候，就说明pm的返回类型同时兼容uncoveredReturnType中的某些returnType，那么在uncoveredReturnType中这些returnType就可以移除了
                   else {
                       liter.remove();
                   }
               }
           }
           //向uncoveredReturnTypes中添加不兼容的类，
           if (!added) {
               uncoveredReturnTypes.add(newReturnType);
           }
       }
       //如果uncoveredReturnTypes中返回类型多于1个，也就是说：不存在一个返回类型兼容其它所有的，那么代理类中对于该方法也就无法重写了，抛出异常
       if (uncoveredReturnTypes.size() > 1) {
           ProxyMethod pm = methods.get(0);
           throw new IllegalArgumentException(
               "methods with same signature " +
               getFriendlyMethodSignature(pm.methodName, pm.parameterTypes) +
               " but incompatible return types: " + uncoveredReturnTypes);
       }
   }

表述的比较拗口，下图展示checkReturnTypes方法

最后LinedList就是兼容所有类型的类

$proxy0代码

public final class $Proxy0 extends Proxy implements a,b{  
//根据方法生成的静态的域 
private static Method m1;  
private static Method m0;  
private static Method m3;  
private static Method m2;  
 
//类加载时，会在clinit方法中进行初始化 
static {  
   try {  
    m1 = Class.forName("java.lang.Object").getMethod("equals",  
      new Class[] { Class.forName("java.lang.Object") });  
    m0 = Class.forName("java.lang.Object").getMethod("hashCode",  
      new Class[0]);  
    m3 = Class.forName("my.java.reflect").getMethod("get",  
      new Class[0]);  
    m2 = Class.forName("java.lang.Object").getMethod("toString",  
      new Class[0]);  
   } catch (NoSuchMethodException nosuchmethodexception) {  
    throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
   } catch (ClassNotFoundException classnotfoundexception) {  
    throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
   }  
}  
//还记得Proxy类中InvocationHandler h的访问权限为protected吗？这个时候赋值
public $Proxy0(InvocationHandler invocationhandler) {  
   super(invocationhandler);  
}  
  
@Override  
public final boolean equals(Object obj) {  
   try {  
    return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))  
      .booleanValue();  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}  
  
@Override  
public final int hashCode() {  
   try {  
    return ((Integer) super.h.invoke(this, m0, null)).intValue();  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}  
  
public final String get() {  
   try {  
    return (String)super.h.invoke(this, m3, null);  
   } catch (Error e) {  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}  
  
@Override  
public final String toString() {  
   try {  
    return (String) super.h.invoke(this, m2, null);  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}  
}  

以上