JDK动态代理分析

悠悠 2022-05-15 10:29 209阅读 0赞

**代理**：代理是一种模式，提供了对目标对象的间接访问方式，即通过代理访问目标对象。如此便于在目标实现的基础上增加额外的功能操作，前拦截，后拦截等，以满足自身的业务需求，同时代理模式便于扩展目标对象功能的特点也为多人所用，在不改动源文件代码的前提下在代码前后方增加相应的逻辑，例如：日志记录，异常统一捕获打印。  
**动态代理**：JDK提供相应API来实现动态代理功能，其中包括InvocationHandler(代理接口)、Proxy(生成动态代理类)  
下面来看动态代理的例子：  
需要在下面的业务方法添加时间耗时记录(不改动业务方法代码的前提下)

/** * 业务接口 */
    public interface BaseDao { 
        Object findById(Long id);
    }

/** * 业务接口实现类 */
    public class BaseDaoImpl implements BaseDao { 
        @Override
        public Object findById(Long id) { 
            System.out.println("查询ID：" + id);
            return new Object();
        }
    }

接下来编写需要在业务方法前后执行的逻辑代码，首先继承InvocationHandler，重写方法

/** * 生成的代理类最终会执行invoke方法 */
    public class TimeInvokeHandler implements InvocationHandler { 
        
        /** * 需要注入调用方法的对象，例子这里target为BaseDao的实现类 */
        private Object target;
        
        public TimeInvokeHandler(Object target) { 
            super();
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            System.out.println("*************************调用之前********************************");
            System.out.println("happened in class: " + proxy.getClass().getName());
            System.out.println("happened in method: " + method.getName());
            for (int i = 0; i < args.length; i++) { 
                System.out.println("arg[" + i + "]: " + args[i]);
            }
            Object res = method.invoke(target, args);//业务bean的方法，下面例子这里指findById()
            System.out.println("*************************调用之后********************************");
            return res;
        }
    }

编写测试类：

public class Test { 
        public static void main(String[] args) throws ParseException { 
            BaseDao target = new BaseDaoImpl();//生成bean
            TimeInvokeHandler handler = new TimeInvokeHandler(target);//注入业务bean
            /** * 被代理类：BaseDaoImpl * Proxy.newProxyInstance()返回代理类 * @loader 加载被代理类的"类加载器" * @interfaces 被代理类实现的接口 * @h 执行代理代码的类(InvocationHandler) */
            BaseDao dao = (BaseDao)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
            dao.findById(8L);//调用返回的代理类的方法
        }
    }

执行结果：

*************************调用之前********************************
    happened in class: com.sun.proxy.$Proxy0
    happened in method: findById
    arg[0]: 8
    查询ID：8
    *************************调用之后********************************

看到的现象：调用了InvocationHandler的invoke()方法，而不是直接调用findById()方法，实现了不改动代码的前提下为业务逻辑增加一些判断(记录统计，日志等)  
**原因**：注意上面的打印日志*happened in class: com.sun.proxy.$Proxy0*，这里的Proxy0就是main方法中的局部变量dao，就是newProxyInstance返回的代理对象，这个代理对象是newProxyInstance()方法中动态生成的的类的实例，这个动态类实现了BaseDao接口，所以可以转型为BaseDao。  
具体newProxyInstance()代码(只显示主要的)如下：

/** * @param loader 加载被代理类的"类加载器" * @param interfaces 被代理类实现的接口 * @param h 执行代理代码的类(InvocationHandler) */
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
            throws IllegalArgumentException { 
        Objects.requireNonNull(h);//参数h判空
    
        final Class<?>[] intfs = interfaces.clone();
    
        /* * 动态生成代理类的Class */
        Class<?> cl = getProxyClass0(loader, intfs);
    
        try { 
    	    //获取代理类的构造方法
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //调用构造方法(需要传入参数h)返回代理类的实例(就是上面例子的com.sun.proxy.$Proxy0)
            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(loader, intfs)*这行代码，生成了代理类的Class，该方法进去就是直接调用WeakCache的*get(K key, P parameter)*方法，先从缓存中查询是否已经生成了该代理类，没有则调用WeakCache的内部类Factory的*get()*方法，在get方法中**最终**调用Proxy的内部类ProxyClassFactory的*apply(ClassLoader loader, Class<>\[\] interfaces)\*方法，接下来进去该方法的源码(显示主要的)：

/** * 生成代理类的Class * @param loader 类加载器 * @param interfaces 代理类要实现的接口 */
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) { 
    
            
            String proxyPkg = null; // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
    		/* * Record the package of a non-public proxy interface so that the * proxy class will be defined in the same package. Verify that * all non-public proxy interfaces are in the same package. * 验证所有的不公共修饰的接口都要在同一包下，不然抛异常 */
            for (Class<?> intf : interfaces) { 
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) { 
                    accessFlags = Modifier.FINAL;
                    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) { 
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";//包名定义(use com.sun.proxy package)
            }
    
            /* * Choose a name for the proxy class to generate. */
            long num = nextUniqueNumber.getAndIncrement();//获取已生成代理类数量，并且+1返回
            String proxyName = proxyPkg + proxyClassNamePrefix + num;//包名+类名（"$Proxy"+num）
            //最终proxyName = "com.sun.proxy.$Proxy0";代理类名就是$Proxy0
    
            /* * Generate the specified proxy class. * 重要：生成代理类字节码的字节数组！ */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
            try { 
    	        //根据字节数组返回代理类的Class
    	        /** * 返回对象实例的Class * @param ClassLoader loader 类加载器 * @param String name 类名 * @param byte[] b 生成Class所需要的字节数组(对象实例字节数组，这里为代理类实例) * @param int off 字节数组起始位置 * @param int len 长度 */
                return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) { 
                /* * A ClassFormatError here means that (barring bugs in the proxy * class generation code) there was some other invalid aspect of the * arguments supplied to the proxy class creation (such as virtual * machine limitations exceeded). */
                throw new IllegalArgumentException(e.toString());
            }
        }

不难看出，关键的一行代码就是ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);，这行代码调用的java底层的方法，直接就返回了代理类的字节数组，根据字节数组就可以生成一个文件(class字节码文件)，下面就来实验一下，把字节素质写入本地的一个文件class，然后反编译为java文件，就能一探代理类的究竟：

import sun.misc.ProxyGenerator;//导入ProxyGenerator
    
    public class Test { 
        public static void main(String[] args) throws FileNotFoundException, IOException { 
            byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class<?>[]{ BaseDao.class});
            new FileOutputStream(new File("d:/$Proxy0.class")).write(data);//在D盘新建一个文本文件，重命名为$Proxy0.class
        }
    }

然后反编译\*$Proxy0.class\*得到以下代码：

//可以看到，代理类继承了Proxy实现了传入参数的接口
    public final class $Proxy0 extends Proxy implements BaseDao { 
    	//实现接口的方法都是被定义在全局变量中,例Method m1,m2......
    	private static Method m1;
    	private static Method m2;
    	private static Method m3;
    	private static Method m0;
    	
    	//构造方法，需要传入InvocationHandler参数，参数存放在Proxy中的全局变量h
    	//上面最开始的Test类中我传入了TimeInvokeHandler
    	public $Proxy0(InvocationHandler arg0) throws  { 
          super(arg0);
       }
    	//重写equals方法，调用了代理方法invoke
    	public final boolean equals(Object arg0) throws  { 
          try { 
             return ((Boolean)super.h.invoke(this, m1, new Object[]{ arg0})).booleanValue();
          } catch (RuntimeException | Error arg2) { 
             throw arg2;
          } catch (Throwable arg3) { 
             throw new UndeclaredThrowableException(arg3);
          }
       }
    	//重写toString方法，调用了代理方法invoke
    	public final String toString() throws  { 
          try { 
             return (String)super.h.invoke(this, m2, (Object[])null);
          } catch (RuntimeException | Error arg1) { 
             throw arg1;
          } catch (Throwable arg2) { 
             throw new UndeclaredThrowableException(arg2);
          }
       }
    	//BaseDao的接口实现,调用了h.invoke()方法，就是最开始编写的TimeInvokeHandler的invoke方法
    	//方法中的this就是代理类实例本身
    	public final Object findById(Long arg0) throws  { 
          try { 
             return (Object)super.h.invoke(this, m3, new Object[]{ arg0});
          } catch (RuntimeException | Error arg2) { 
             throw arg2;
          } catch (Throwable arg3) { 
             throw new UndeclaredThrowableException(arg3);
          }
       }
    	//重写hashCode方法，调用了代理方法invoke
    	public final int hashCode() throws  { 
          try { 
             return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
          } catch (RuntimeException | Error arg1) { 
             throw arg1;
          } catch (Throwable arg2) { 
             throw new UndeclaredThrowableException(arg2);
          }
       }
    	//方法初始化
    	static { 
    		try { 
    			m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{ Class.forName("java.lang.Object")});
    			m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
    			m3 = Class.forName("com.aoomiao.test.BaseDao").getMethod("findById",
    					new Class[]{ Class.forName("java.lang.Long")});
    			m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
    		} catch (NoSuchMethodException arg1) { 
    			throw new NoSuchMethodError(arg1.getMessage());
    		} catch (ClassNotFoundException arg2) { 
    			throw new NoClassDefFoundError(arg2.getMessage());
    		}
    	}
    }

到达这里之后代理就不难理解了，值得注意的是代理类上面所出现的四个方法equals()、toString()、findById()、hashCode()这四个方法都是被代理了，调用这些方法都是去执行我们生成代理时传入参数InvocationHandler实例的\*invoke()\*方法，如果你的接口有多个方法，生成的代理类都会实现这些方法，换言之，接口的方法都会被代理  
生成动态代理过程:

*  继承InvocationHandler接口，重写invoke()方法，编写需要植入的代码
 *  newProxyInstance(ClassLoader loader,Class<>\[\] interfaces,InvocationHandler h)生成代理类
 *  getProxyClass0(loader, intfs)生成代理类的Class
 *  Class获取构造器，传入参数h，实体化代理类对象并返回
 *  返回的代理类可以被转型为实现的接口，然后调用接口的方法就是调用代理的方法h.invoke()