从Proxy.newInstance出发

小说:为了鸡毛蒜皮的事都要发脾气,会不会出事?作者:石帝更新时间:2019-03-21字数:78826

而她又是你的亲,有你站们这边,再加上我们送她一颗树果实她总不会和我们为敌吧,当然最后还要经过我们的观察才行,如果不符合我们的要的话那么我们只能放弃了,毕竟和我们在一本身就是一件很危险的事情。

原创:无回应之处,便是绝境

“呵呵!”纪太虚说道:“罗喉老祖也是成名多年的老魔头,想从他手中夺过来罗刹环跟白骨舍利恐怕是不容易呢!”
悟空道:“大天尊,我也是没法的事,要炼天机棍,必要用五行之极才行,天下若有第二处,我又怎么会打起盘古主意?”

慕寻真偷偷的看了叶扬一眼说道:“你要是需要的话,我就帮你。不过这是我第一次,可能有些做的不好”。

写在前面

本篇博客是基于对动态代理,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);  
   }  
}  
}  

以上

编辑:通乙宗海

发布:2019-03-21 10:41:09

当前文章:http://leetaemin.cn/play/l8iveyb5lm.html

心理现象:心理饱和 暴力电影与“被欺负” 一个国家和社会的品味其实是由女人决定的 成长营:优秀的孩子也需要成长 一个人是怎样一步步变狭隘的 “婚姻是爱情坟墓”是肤浅的人的专利 你所谓的迷茫,说到底,就是懒! 又到层林尽染时,你觉得哪里的枫叶最漂亮?

77290 68671 98430 63828 67265 65430 48031 12044 62805 18246 47733 10780 53415 44200 84215 67135 35401 58519 35229 62405

我要说两句: (0人参与)

发布