动态代理的两种方式 JDK 动态代理和 cglib 动态代理在上一篇中 动态代理 jdk 和 cglib 的区别 已经通过实例做了比较,那么动态代理的使用我们已经掌握了,但是知道了使用方法还远远不够,要想更深入了解,还得从源码读起,学习其根源才是我们学习的正确方式。
为了方便理解本文的重点,我们先说一下静态代理和动态代理的根本上的区别
静态代理是由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件(.class 文件),代理类和委托类的关系在运行前就确定了。
动态代理类的源码是在程序运行期间由 JVM 根据反射等机制动态的生成,所以不存在代理类的字节码文件 (.class 文件)。代理类和委托类的关系是在程序运行时确定。
我们先来看一个熟悉的 JDK 动态代理的例子
Car 接口
- package proxy;
- public interface Car {
- public void run();
- }
Car 实现类
- package proxy;
- public class CarImpl implements Car {
- public void run() {
- System.out.println("car running");
- }
- }
Car 代理类
- package proxy;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- //JDK动态代理代理类
- public class CarHandler implements InvocationHandler {
- //真实类的对象
- private Object car;
- //构造方法赋值给真实的类
- public CarHandler(Object obj) {
- this.car = obj;
- }
- //代理类执行方法时,调用的是这个方法
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- System.out.println("before");
- Object res = method.invoke(car, args);
- System.out.println("after");
- return res;
- }
- }
main 方法
- package proxy;
- import java.lang.reflect.Proxy;
- public class main {
- public static void main(String[] args) {
- CarImpl carImpl = new CarImpl();
- CarHandler carHandler = new CarHandler(carImpl);
- Car proxy = (Car) Proxy.newProxyInstance(main.class.getClassLoader(), //第一个参数,获取ClassLoader
- carImpl.getClass().getInterfaces(), //第二个参数,获取被代理类的接口
- carHandler); //第三个参数,一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
- proxy.run();
- }
- }
运行结果
- before
- car running
- after
我们知道 JDK 动态代理的核心在于 Proxy.newProxyInstance 方法上,也就是生成的代理类上,我们跟进去查看
- @CallerSensitive
- 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;
- }
- });
- }
- 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);
- }
- }
在这个方法里,我标注了两处注释,这两处源码编写者也为我们做了英文注释,我们来看一下
Look up or generate the designated proxy class.// 查找并生成指定的代理类的 class
Invoke its constructor with the designated invocation handler.// 使用我们实现的 InvocationHandler 作为参数调用构造方法来获得代理类的实例
其中第一处是生成 class 文件,也就是 java 动态生成 class 类,第二处是调用该 class 类的构造函数,并将我们的 carHandler 作为参数传进去。第二步我们都知道,就是一个普通的 java 类调用一下构造方法而已,我们关注的重点是 jdk 怎么动态生成的这个 class 文件。
我们跟进
- Class<?> cl = getProxyClass0(loader, intfs);
- private static Class<?> getProxyClass0(ClassLoader loader,
- Class<?>... interfaces) {
- // 代理的接口数量大于65535时抛出异常
- if (interfaces.length > 65535) {
- throw new IllegalArgumentException("interface limit exceeded");
- }
- // JDK对代理类进行了缓存,如果已经存在相应的代理类,则直接返回,否则才会通过ProxyClassFactory来创建代理
- return proxyClassCache.get(loader, interfaces);
- }
方法里我们根据注释可以知道,JDK 对代理类的接口做了个数限制,并且维护了一个代理类的缓存集合,如果有缓存就直接返回,否则就通过 ProxyClassFactory 去创建,在我们上面的实例中,并没有代理缓存,所以我们去看 ProxyClassFactory 类是怎么生成 class 的,ProxyClassFactory 是 Proxy 的一个静态内部类
- getProxyClass0(loader, intfs);
- private static final class ProxyClassFactory implements BiFunction < ClassLoader,
- Class < ?>[],
- Class < ?>>{
- // prefix for all proxy class names
- // 第1处注释
- private static final String proxyClassNamePrefix = "$Proxy";
- // 第2处注释
- // next number to use for generation of unique proxy class names
- 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) {
- /*
- * Verify that the class loader resolves the name of this
- * interface to the same Class object.
- */
- 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");
- }
- /*
- * Verify that the Class object actually represents an
- * interface.
- */
- if (!interfaceClass.isInterface()) {
- throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");
- }
- /*
- * Verify that this interface is not a duplicate.
- */
- if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
- throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());
- }
- }
- //第3处注释
- String proxyPkg = null; // package to define proxy class in
- int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
- //第4处注释
- /*
- * 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 + ".";
- }
- // 获取计数用来生成代理类的类名(proxy+num)
- /*
- * Choose a name for the proxy class to generate.
- */
- long num = nextUniqueNumber.getAndIncrement();
- // 第5处注释
- String proxyName = proxyPkg + proxyClassNamePrefix + num;
- // 第6处注释
- /*
- * Generate the specified proxy class.
- */
- byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
- try {
- 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());
- }
- }
- }
上面的代码中,标注了几处注释我们来一一解释
1.
变量是所有代理类的类名前缀 2.AtomicLong 同步类,用来实现生成代理类名字的计数器
- proxyClassNamePrefix
3.proxyPkg 变量是代理类的包名
4. 这一段逻辑是挨个循环得到代理类的路径
5. 生成类名,默认情况下,代理类的完全限定名为:com.sun.proxy.$Proxy0,com.sun.proxy.$Proxy1…… 依次递增
6. 这里才是真正的生成代理类的字节码的地方,通过方法。
- ProxyGenerator.generateProxyClass
我们跟进
方法
- ProxyGenerator.generateProxyClass
- 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;
- }
在这个类中,我们看到了熟悉的 FileOutputStream, 也就是在这里生成了新的 class 文件,生成了代理类。我们操作一下生成一下 class 文件,然后打开查看一下这个神秘的 class 文件
- package com.sun.proxy;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- import java.lang.reflect.Proxy;
- import java.lang.reflect.UndeclaredThrowableException;
- import proxy.Car;
- public final class $Proxy0
- extends Proxy
- implements Car
- {
- private static Method m1;
- private static Method m3;
- private static Method m2;
- private static Method m0;
- public $Proxy0(InvocationHandler paramInvocationHandler)
- {
- super(paramInvocationHandler);
- }
- public final boolean equals(Object paramObject)
- {
- try
- {
- return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
- }
- catch (Error|RuntimeException localError)
- {
- throw localError;
- }
- catch (Throwable localThrowable)
- {
- throw new UndeclaredThrowableException(localThrowable);
- }
- }
- public final void run()
- {
- try
- {
- this.h.invoke(this, m3, null);
- return;
- }
- catch (Error|RuntimeException localError)
- {
- throw localError;
- }
- catch (Throwable localThrowable)
- {
- throw new UndeclaredThrowableException(localThrowable);
- }
- }
- public final String toString()
- {
- try
- {
- return (String)this.h.invoke(this, m2, null);
- }
- catch (Error|RuntimeException localError)
- {
- throw localError;
- }
- catch (Throwable localThrowable)
- {
- throw new UndeclaredThrowableException(localThrowable);
- }
- }
- public final int hashCode()
- {
- try
- {
- return ((Integer)this.h.invoke(this, m0, null)).intValue();
- }
- catch (Error|RuntimeException localError)
- {
- throw localError;
- }
- catch (Throwable localThrowable)
- {
- throw new UndeclaredThrowableException(localThrowable);
- }
- }
- static
- {
- try
- {
- m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
- m3 = Class.forName("proxy.Car").getMethod("run", new Class[0]);
- m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
- m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
- return;
- }
- catch (NoSuchMethodException localNoSuchMethodException)
- {
- throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
- }
- catch (ClassNotFoundException localClassNotFoundException)
- {
- throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
- }
- }
- }
到这里大家估计就豁然开朗了,这个代理类有以下几个特点
1. 继承了 Proxy 类,实现了代理的接口(interface--Car),由于 java 不能多继承,这里已经继承了 Proxy 类了,不能再继承其他的类,所以 JDK 的动态代理不支持对实现类的代理,只支持接口的代理。
2. 提供了一个使用 InvocationHandler 作为参数的构造方法。
3. 生成静态代码块来初始化接口中方法的 Method 对象,以及 Object 类的 equals、hashCode、toString 方法。
4. 重写了 Object 类的 equals、hashCode、toString,它们都只是简单的调用了 InvocationHandler 的 invoke 方法,即可以对其进行特殊的操作,也就是说 JDK 的动态代理还可以代理上述三个方法。
5. 代理类实现代理接口的 run 方法中,只是简单的调用了 InvocationHandler 的 invoke 方法,我们可以在 invoke 方法中进行一些特殊操作,甚至不调用实现的方法,直接返回。
上面是 JDK 动态代理实现的基本框架代码,Spring AOP 的实现也是同理,当然具体的实现肯定比这个复杂得多,但是基本原理不外乎如是。所以理解基本原理对于理解其他的代码也是很有好处的。
来源: http://www.jianshu.com/p/71bd883744e6