jdk动态代理源码剖析
2017-04-07 16:39
381 查看
摘要
相比于静态代理,动态代理避免了开发人员编写各个繁锁的静态代理类,只需简单地指定一组接口及目标类对象就能动态的获得代理对象。
代理模式
使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用分派到目标对象上反射执行,还可以在分派过程中添加”前置通知”和后置处理(如在调用目标方法前校验权限,在调用完目标方法后打印日志等)等功能。
使用动态代理的五大步骤
1.通过实现InvocationHandler接口来自定义自己的InvocationHandler;
2.通过Proxy.getProxyClass获得动态代理类
3.通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class)
4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入
5.通过代理对象调用目标方法
动态代理的使用
例1(方式一)
输出:
Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象,其方法签名为:newProxyInstance(ClassLoader loader,Class
输出结果一样.
下面以newProxyInstance方法为切入点来剖析代理类的生成及代理方法的调用
(为了篇幅整洁去掉了次要的代码)
这段代码就是对代理类对象的创建,就是对例1中34~38行封装,其中getProxyClass0就是生成代理类的方法
getProxyClass0方法剖析
其中代理缓存是使用WeakCache实现的,如下
具体的缓存逻辑这里暂不关心,只需要关心ProxyClassFactory是如何生成代理类的,ProxyClassFactory是Proxy的一个静态内部类,实现了WeakCache的内部接口BiFunction的apply方法:
(下面介绍一下怎么定位到生成代理的类是ProxyClassFactory)
跟踪: proxyClassCache.get(loader, interfaces);方法:
有以上代码分析可得:调用了Factory实例的get()方法:
可以看到核心代码为:valueFactory.apply(key, parameter);
那么valueFactory是谁呢?
通过Proxy类我们又知道:WeakCache 的初始化为:
所以最终的valueFactory.apply(key, parameter)方法,其实是调用的ProxyClassFactory类的apply方法:
看看ProxyClassFactory是怎样生成代理类的?
而生成代理类字节码文件又主要通过ProxyGenerate的generateProxyClass(proxyName,interfaces)
saveGeneratedFiles这个属性的值从哪里来呢:
GetBooleanAction实际上是调用Boolean.getBoolean(propName)来获得的,而Boolean.getBoolean(propName)调用了System.getProperty(name),所以我们可以设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到本地文件来查看。
这里要注意,当把这个属性设置为true时,生成的class文件及其所在的路径都需要提前创建,否则会抛出FileNotFoundException异常。如:在jdk1.7及以上则不会出现这种情况(1.7以前的自己验证),如果出现以下异常:
则:即我们要在运行当前main方法的路径下创建com/sun/proxy目录,并创建一个$Proxy0.class文件,才能够正常运行并保存class文件内容。
层层调用后,最终generateClassFile才是真正生成代理类字节码文件的方法,注意开头的三个addProxyMethod方法是只将Object的hashcode,equals,toString方法添加到代理方法容器中,代理类除此之外并没有重写其他Object的方法,所以除这三个方法外,代理类调用其他方法的行为与Object调用这些方法的行为一样不通过Invoke
addProxyMethod方法剖析
InvocationHandler的作用
在动态代理中InvocationHandler是核心,每个代理实例都具有一个关联的调用处理程序(InvocationHandler)。对代理实例调用方法时,将对方法调用进行编码并将其指派到它的调用处理程序(InvocationHandler)的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中,而invoke方法根据传入的代理对象,方法和参数来决定调用代理的哪个方法
invoke方法签名:invoke(Object Proxy,Method method,Object[] args)
$Proxy0.class
来看看例1(MyProxy)的代理类是怎样的?
以上就是对代理类如何生成,代理类方法如何被调用的分析!在很多框架都使用了动态代理如Spring,HDFS的RPC调用等等!!
博客引用:http://www.cnblogs.com/MOBIN/p/5597215.html
http://blog.csdn.net/mhmyqn/article/details/48474815
相比于静态代理,动态代理避免了开发人员编写各个繁锁的静态代理类,只需简单地指定一组接口及目标类对象就能动态的获得代理对象。
代理模式
使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用分派到目标对象上反射执行,还可以在分派过程中添加”前置通知”和后置处理(如在调用目标方法前校验权限,在调用完目标方法后打印日志等)等功能。
使用动态代理的五大步骤
1.通过实现InvocationHandler接口来自定义自己的InvocationHandler;
2.通过Proxy.getProxyClass获得动态代理类
3.通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class)
4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入
5.通过代理对象调用目标方法
动态代理的使用
例1(方式一)
public class MyProxy { public interface IHello{ void sayHello(); } static class Hello implements IHello{ public void sayHello() { System.out.println("Hello world!!"); } } //自定义InvocationHandler static class HWInvocationHandler implements InvocationHandler{ //目标对象 private Object target; public HWInvocationHandler(Object target){ this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------插入前置通知代码-------------"); //执行相应的目标方法 Object rs = method.invoke(target,args); System.out.println("------插入后置处理代码-------------"); return rs; } } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc eption, InstantiationException { //生成$Proxy0的class文件 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); //获取动态代理类 Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class); //获得代理类的构造函数,并传入参数类型InvocationHandler.class Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class); //通过构造函数来创建动态代理对象,将自定义的InvocationHandler实例传入 IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello())); //通过代理对象调用目标方法 iHello.sayHello(); } }
输出:
------插入前置通知代码------------- Hello world!! ------插入后置处理代码-------------
Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象,其方法签名为:newProxyInstance(ClassLoader loader,Class
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //生成$Proxy0的class文件 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); IHello ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), //加载接口的类加载器 new Class[]{IHello.class}, //一组接口 new HWInvocationHandler(new Hello())); //自定义的InvocationHandler ihello.sayHello(); }
输出结果一样.
下面以newProxyInstance方法为切入点来剖析代理类的生成及代理方法的调用
(为了篇幅整洁去掉了次要的代码)
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { if (h == null) { //如果h为空直接抛出异常,所以InvocationHandler实例对象是必须的 throw new NullPointerException(); } //对象的拷贝,暂不知道这里拷贝下的意义是啥? final Class<?>[] intfs = interfaces.clone(); //一些安全的权限检查 final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } //产生代理类 Class<?> cl = getProxyClass0(loader, intfs); //获取代理类的构造函数对象 //参数constructorParames为常量值:private static final Class<?>[] constructorParams = { InvocationHandler.class }; final Constructor<?> cons = cl.getConstructor(constructorParames); final InvocationHandler ih = h; //根据代理类的构造函数对象来创建代理类对象 return newInstance(cons, ih); }
这段代码就是对代理类对象的创建,就是对例1中34~38行封装,其中getProxyClass0就是生成代理类的方法
getProxyClass0方法剖析
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { //接口数不得超过65535个 if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } //代理类缓存,如果缓存中有代理类了直接返回,否则将由ProxyClassFactory创建代理类 return proxyClassCache.get(loader, interfaces); }
其中代理缓存是使用WeakCache实现的,如下
/** * a cache of proxy classes */ private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
具体的缓存逻辑这里暂不关心,只需要关心ProxyClassFactory是如何生成代理类的,ProxyClassFactory是Proxy的一个静态内部类,实现了WeakCache的内部接口BiFunction的apply方法:
(下面介绍一下怎么定位到生成代理的类是ProxyClassFactory)
跟踪: proxyClassCache.get(loader, interfaces);方法:
/** * Look-up the value through the cache. This always evaluates the * {@code subKeyFactory} function and optionally evaluates * {@code valueFactory} function if there is no entry in the cache for given * pair of (key, subKey) or the entry has already been cleared. * * @param key possibly null key * @param parameter parameter used together with key to create sub-key and * value (should not be null) * @return the cached value (never null) * @throws NullPointerException if {@code parameter} passed in or * {@code sub-key} calculated by * {@code subKeyFactory} or {@code value} * calculated by {@code valueFactory} is null. */ public V get(K key, P parameter) { Objects.requireNonNull(parameter); expungeStaleEntries(); Object cacheKey = CacheKey.valueOf(key, refQueue); // lazily install the 2nd level valuesMap for the particular cacheKey ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey); if (valuesMap == null) { ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>()); if (oldValuesMap != null) { valuesMap = oldValuesMap; } } // create subKey and retrieve the possible Supplier<V> stored by that // subKey from valuesMap Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); Supplier<V> supplier = valuesMap.get(subKey); Factory factory = null; //这段代码初始化了supplier 对象为Factory对象的一个 //所以当运行supplier.get();方法的时候,实际是调用的Factory对象的get()方法 while (true) { //首次运行supplier 为null,if不成立 if (supplier != null) { // supplier might be a Factory or a CacheValue<V> instance //这里调用的是Factory对象的get()方法 V value = supplier.get(); if (value != null) { return value; } } // else no supplier in cache // or a supplier that returned null (could be a cleared CacheValue // or a Factory that wasn't successful in installing the CacheValue) // lazily construct a Factory if (factory == null) { //首次运行后初始化factory 对象 factory = new Factory(key, parameter, subKey, valuesMap); } if (supplier == null) { //首次运行,初始化supplier对象 supplier = valuesMap.putIfAbsent(subKey, factory);//首次获取,这里supplier对象为null if (supplier == null) { // successfully installed Factory supplier = factory; } // else retry with winning supplier } else { if (valuesMap.replace(subKey, supplier, factory)) { // successfully replaced // cleared CacheEntry / unsuccessful Factory // with our Factory supplier = factory; } else { // retry with current supplier supplier = valuesMap.get(subKey); } } } }
有以上代码分析可得:调用了Factory实例的get()方法:
@Override public synchronized V get() { // serialize access // re-check Supplier<V> supplier = valuesMap.get(subKey); if (supplier != this) { // something changed while we were waiting: // might be that we were replaced by a CacheValue // or were removed because of failure -> // return null to signal WeakCache.get() to retry // the loop return null; } // else still us (supplier == this) // create new value V value = null; try { value = Objects.requireNonNull(valueFactory.apply(key, parameter)); } finally { if (value == null) { // remove us on failure valuesMap.remove(subKey, this); } } // the only path to reach here is with non-null value assert value != null; // wrap value with CacheValue (WeakReference) CacheValue<V> cacheValue = new CacheValue<>(value); // try replacing us with CacheValue (this should always succeed) if (valuesMap.replace(subKey, this, cacheValue)) { // put also in reverseMap reverseMap.put(cacheValue, Boolean.TRUE); } else { throw new AssertionError("Should not reach here"); } // successfully replaced us with new CacheValue -> return the value // wrapped by it return value; }
可以看到核心代码为:valueFactory.apply(key, parameter);
那么valueFactory是谁呢?
//可以看到valueFactory是WeakCache 类的一个私有的成员变量,通过下面的构造方法来初始化 private final BiFunction<K, P, V> valueFactory; /** * Construct an instance of {@code WeakCache} * * @param subKeyFactory a function mapping a pair of * {@code (key, parameter) -> sub-key} * @param valueFactory a function mapping a pair of * {@code (key, parameter) -> value} * @throws NullPointerException if {@code subKeyFactory} or * {@code valueFactory} is null. */ public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) { this.subKeyFactory = Objects.requireNonNull(subKeyFactory); this.valueFactory = Objects.requireNonNull(valueFactory); }
通过Proxy类我们又知道:WeakCache 的初始化为:
/** * a cache of proxy classes */ private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
所以最终的valueFactory.apply(key, parameter)方法,其实是调用的ProxyClassFactory类的apply方法:
看看ProxyClassFactory是怎样生成代理类的?
private static final class ProxyClassFactory implements BiFunction<classloader, class<?="">[], Class<!--?-->> { //统一代理类的前缀名都以$Proxy开关 private static final String proxyClassNamePrefix = "$Proxy"; //使用唯一的编号给作为代理类名的一部分,如$Proxy0,$Proxy1等 private static final AtomicLong nextUniqueNumber = new AtomicLong(); @Override public Class<!--?--> apply(ClassLoader loader, Class<!--?-->[] interfaces) { Map<class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class<!--?--> intf : interfaces) { //验证指定的类加载器(loader)加载接口所得到的Class对象(interfaceClass)是否与intf对象相同 Class<!--?--> interfaceClass = null; try { interfaceClass = Class.forName(intf.getName(), false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } //验证该Class对象是不是接口 if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } // 验证该接口是否重复了 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } //声明代理类所在包 String proxyPkg = null; /*验证你传入的接口中是否有非public接口,只要有一个接口是非public的,那么这些接口都必须在同一包中 这里的接口修饰符直接影响到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成 的代理类的路径,往下看!!*/ for (Class<!--?--> intf : interfaces) { int flags = intf.getModifiers(); if (!Modifier.isPublic(flags)) { String name = intf.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) { /*如果都是public接口,那么生成的代理类就在com.sun.proxy包下如果报java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c lass (系统找不到指定的路径。)的错误,就先在你项目中创建com.sun.proxy路径*/ proxyPkg = ReflectUtil.PROXY_PACKAGE + "."; } //将当前nextUniqueNumber的值以原子的方式的加1,所以第一次生成代理类的名字为$Proxy0.class long num = nextUniqueNumber.getAndIncrement(); //代理类的完全限定名,如com.sun.proxy.$Proxy0.calss, String proxyName = proxyPkg + proxyClassNamePrefix + num; //生成代理类字节码文件 byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces); try { return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { throw new IllegalArgumentException(e.toString()); } } }
而生成代理类字节码文件又主要通过ProxyGenerate的generateProxyClass(proxyName,interfaces)
public static byte[] generateProxyClass(final String var0, Class[] var1) { ProxyGenerator var2 = new ProxyGenerator(var0, var1); //生成代理类字节码文件的真正方法 final byte[] var3 = var2.generateClassFile(); //保存文件 // 这里根据参数配置,决定是否把生成的字节码(.class文件)保存到本地磁盘,我们可以通过把相应的class文件保存到本地,再反编译来看看具体的实现,这样更直观 if(saveGeneratedFiles) { AccessController.doPrivileged(new PrivilegedAction() { public Void run() { try { FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class"); var1.write(var3); var1.close(); return null; } catch (IOException var2) { throw new InternalError("I/O exception saving generated file: " + var2); } } }); } return var3; }
saveGeneratedFiles这个属性的值从哪里来呢:
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();
GetBooleanAction实际上是调用Boolean.getBoolean(propName)来获得的,而Boolean.getBoolean(propName)调用了System.getProperty(name),所以我们可以设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到本地文件来查看。
这里要注意,当把这个属性设置为true时,生成的class文件及其所在的路径都需要提前创建,否则会抛出FileNotFoundException异常。如:在jdk1.7及以上则不会出现这种情况(1.7以前的自己验证),如果出现以下异常:
Exception in thread "main" java.lang.InternalError: I/O exception saving generated file: java.io.FileNotFoundException: com/sun/proxy/$Proxy0.class (No such file or directory) at sun.misc.ProxyGenerator$1.run(ProxyGenerator.java:336) at sun.misc.ProxyGenerator$1.run(ProxyGenerator.java:327) at java.security.AccessController.doPrivileged(Native Method) at sun.misc.ProxyGenerator.generateProxyClass(ProxyGenerator.java:326) at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:672) at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:592) at java.lang.reflect.WeakCache$Factory.get(WeakCache.java:244) at java.lang.reflect.WeakCache.get(WeakCache.java:141) at java.lang.reflect.Proxy.getProxyClass0(Proxy.java:455) at java.lang.reflect.Proxy.newProxyInstance(Proxy.java:738) at com.mikan.proxy.ProxyTest.main(ProxyTest.java:15) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)
则:即我们要在运行当前main方法的路径下创建com/sun/proxy目录,并创建一个$Proxy0.class文件,才能够正常运行并保存class文件内容。
层层调用后,最终generateClassFile才是真正生成代理类字节码文件的方法,注意开头的三个addProxyMethod方法是只将Object的hashcode,equals,toString方法添加到代理方法容器中,代理类除此之外并没有重写其他Object的方法,所以除这三个方法外,代理类调用其他方法的行为与Object调用这些方法的行为一样不通过Invoke
private byte[] generateClassFile() { /addProxyMethod系列方法就是将接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods), 其中方法签名作为key,proxyMethod作为value*/ /*hashCodeMethod方法位于静态代码块中通过Object对象获得,hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]), 相当于从Object中继承过来了这三个方法equalsMethod,toStringMethod*/ this.addProxyMethod(hashCodeMethod, Object.class); --> this.addProxyMethod(equalsMethod, Object.class); this.addProxyMethod(toStringMethod, Object.class); int var1; int var3; //获得所有接口中的所有方法,并将方法添加到代理方法中 for(var1 = 0; var1 < this.interfaces.length; ++var1) { Method[] var2 = this.interfaces[var1].getMethods(); for(var3 = 0; var3 < var2.length; ++var3) { this.addProxyMethod(var2[var3], this.interfaces[var1]); } } Iterator var7 = this.proxyMethods.values().iterator(); List var8; while(var7.hasNext()) { var8 = (List)var7.next(); checkReturnTypes(var8); //验证具有相同方法签名的的方法的返回值类型是否一致,因为不可能有两个方法名相同,参数相同,而返回值却不同的方法 }; //接下来就是写代理类文件的步骤了 Iterator var11 try { //生成代理类的构造函数 this.methods.add(this.generateConstructor()); var7 = this.proxyMethods.values().iterator(); while(var7.hasNext()) { var8 = (List)var7.next(); var11 = var8.iterator(); while(var11.hasNext()) { ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next(); /将代理字段声明为Method,10为ACC_PRIVATE和ACC_STATAIC的与运算,表示该字段的修饰符为private static 所以代理类的字段都是private static Method XXX*/ this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10)); //生成代理类的代理方法 this.methods.add(var4.generateMethod()); } } //为代理类生成静态代码块,对一些字段进行初始化 this.methods.add(this.generateStaticInitializer()); } catch (IOException var6) { throw new InternalError("unexpected I/O Exception"); } if(this.methods.size() > '\uffff') { //代理方法超过65535将抛出异常 throw new IllegalArgumentException("method limit exceeded"); } else if(this.fields.size() > '\uffff') { //代理类的字段超过65535将抛出异常 throw new IllegalArgumentException("field limit exceeded"); } else { //这里开始就是一些代理类文件的过程,此过程略过 this.cp.getClass(dotToSlash(this.className)); this.cp.getClass("java/lang/reflect/Proxy"); for(var1 = 0; var1 < this.interfaces.length; ++var1) { this.cp.getClass(dotToSlash(this.interfaces[var1].getName())); } this.cp.setReadOnly(); ByteArrayOutputStream var9 = new ByteArrayOutputStream(); DataOutputStream var10 = new DataOutputStream(var9); try { var10.writeInt(-889275714); var10.writeShort(0); var10.writeShort(49); this.cp.write(var10); var10.writeShort(49); var10.writeShort(this.cp.getClass(dotToSlash(this.className))); var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy")); var10.writeShort(this.interfaces.length); for(var3 = 0; var3 < this.interfaces.length; ++var3) { var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName()))); } var10.writeShort(this.fields.size()); var11 = this.fields.iterator(); while(var11.hasNext()) { ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next(); var12.write(var10); } var10.writeShort(this.methods.size()); var11 = this.methods.iterator(); while(var11.hasNext()) { ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next(); var13.write(var10); } var10.writeShort(0); return var9.toByteArray(); } catch (IOException var5) { throw new InternalError("unexpected I/O Exception"); } } }
addProxyMethod方法剖析
private void addProxyMethod(Method var1, Class var2) { String var3 = var1.getName(); //方法名 Class[] var4 = var1.getParameterTypes(); //方法参数类型数组 Class var5 = var1.getReturnType(); //返回值类型 Class[] var6 = var1.getExceptionTypes(); //异常类型 String var7 = var3 + getParameterDescriptors(var4); //方法签名 Object var8 = (List)this.proxyMethods.get(var7); //根据方法签名却获得proxyMethods的Value if(var8 != null) { //处理多个代理接口中重复的方法的情况 Iterator var9 = ((List)var8).iterator(); while(var9.hasNext()) { ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next(); if(var5 == var10.returnType) { /*归约异常类型以至于让重写的方法抛出合适的异常类型,我认为这里可能是多个接口中有相同的方法,而这些相同的方法抛出的异常类 型又不同,所以对这些相同方法抛出的异常进行了归约*/ ArrayList var11 = new ArrayList(); collectCompatibleTypes(var6, var10.exceptionTypes, var11); collectCompatibleTypes(var10.exceptionTypes, var6, var11); var10.exceptionTypes = new Class[var11.size()]; //将ArrayList转换为Class对象数组 var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes); return; } } } else { var8 = new ArrayList(3); this.proxyMethods.put(var7, var8); } ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null)); /*24~27行的意思就是如果var8为空,就创建一个数组,并以方法签名为key,proxymethod对象数组为value添加到proxyMethods*/ }
InvocationHandler的作用
在动态代理中InvocationHandler是核心,每个代理实例都具有一个关联的调用处理程序(InvocationHandler)。对代理实例调用方法时,将对方法调用进行编码并将其指派到它的调用处理程序(InvocationHandler)的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中,而invoke方法根据传入的代理对象,方法和参数来决定调用代理的哪个方法
invoke方法签名:invoke(Object Proxy,Method method,Object[] args)
$Proxy0.class
来看看例1(MyProxy)的代理类是怎样的?
public final class $Proxy0 extends Proxy implements IHello { //继承了Proxy类和实现IHello接口 //变量,都是private static Method XXX private static Method m3; private static Method m1; private static Method m0; private static Method m2; //代理类的构造函数,其参数正是是InvocationHandler实例,Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的 public $Proxy0(InvocationHandler var1) throws { super(var1); } //接口代理方法 public final void sayHello() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } //以下Object中的三个方法 public final boolean equals(Object var1) throws { try { return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final int hashCode() throws { try { return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue(); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } 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); } } //对变量进行一些初始化工作 static { try { m3 = Class.forName("com.mobin.proxy.IHello").getMethod("sayHello", new Class[0]); 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]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
以上就是对代理类如何生成,代理类方法如何被调用的分析!在很多框架都使用了动态代理如Spring,HDFS的RPC调用等等!!
博客引用:http://www.cnblogs.com/MOBIN/p/5597215.html
http://blog.csdn.net/mhmyqn/article/details/48474815
相关文章推荐
- JDK动态代理源码及源码剖析之为什么只能代理接口
- 深入剖析JDK动态代理源码实现
- 动态代理-JDK 源码剖析(二):源码剖析
- 动态代理-JDK 源码剖析(一):简单示例
- 【动态代理】从源码实现角度剖析JDK动态代理
- 关于java中jdk中接口动态代理模式Proxy的剖析
- 基于jdk动态代理的实现与源码解析
- spring源码学习之【准备】jdk动态代理例子
- Java--JDK动态代理核心源码解析
- 读JDK动态代理源码(Proxy类)
- 做一个合格的程序猿之浅析Spring AOP源码(十三) jdk的动态代理和cglib的代理
- spring源码学习【准备】之jdk动态代理和cglib动态代理的区别和性能
- JDK动态代理实现原理(源码解读)
- Java动态代理详解,以及底层JDK源码实现分析(基于Java8)。
- jdk的动态代理源码解析
- 读JDK动态代理(源码)有感
- 动态代理及JDK动态代理源码分析
- MyBatis Mapper 接口如何通过JDK动态代理来包装SqlSession 源码分析
- jdk 动态代理源码分析