Java动态代理原理详细解析

动态代理简介

在Java设计模式中，代理模式是其中一种，代理模式又分为静态代理，动态代理，两者之间的区别就是动态代理是在运行时生成代理对象的字节码，所以相比较静态代理而言，会更灵活.但动态代理有一个限制，传入的class必须是接口类型，不支持传入非接口类型.

动态代理Demo

动态代理在业务场景中有两种使用方式，一种是代理实现某个接口的类，另外一种是直接代理接口.
这是第一种

public interface IReal {
	public void sayHello();
}
//==============================
public class RealInvocastionHandler implements InvocationHandler{
	
	public IReal ireal;
	
	public RealInvocastionHandler(IReal ireal) {
		super();
		this.ireal = ireal;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		System.out.println("method before");
		method.invoke(ireal,null);
		System.out.println("method after"); 

		return null;
	}

}

public class ProxyDemo2 {

	public static void main(String[] args) {
		RealImpl impl = new RealImpl();
		RealInvocastionHandler realInvocastionHandler = new RealInvocastionHandler(impl);
		IReal iReal = (IReal) Proxy.newProxyInstance(ProxyDemo2.class.getClassLoader(),new Class[]{IReal.class}, realInvocastionHandler);
		iReal.sayHello();
	}
}

输出：
method before
RealImpl sayHello
method after

这是第二种

		IReal iReal = (IReal) Proxy.newProxyInstance(ProxyDemo1.class.getClassLoader(),new Class[]{IReal.class}, new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.print(method.getName());
				return null;
			}
		});
		iReal.sayHello();

输出：
sayHello

动态代理导出字节码解释

只要增加一行代码：System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);
反编译生成的字节码如下：

public final class $Proxy0 extends Proxy implements IReal {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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);
        }
    }

    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);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("proxy.IReal").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

动态代理原理

从生成的代理类$Proxy0.class中，代理类继承了Proxy类，实现了IReal接口.忽略其他方法，具体看sayHello方法，

   super.h.invoke(this, m3, (Object[])null);

super.h是invocationhandler对象，这个可以从Proxy类中得知，接着调用invoke方法,super.h这个对象就是demo1传入的RealInvocastionHandler或者demo2的匿名内部类InvocationHandler. m3是sayHello的method对象

m3 = Class.forName("proxy.IReal").getMethod("sayHello");

这个代理类对象的结构也恰好说明了，为什么传入的class类型要一定是接口，因为代理类已经继承 了Proxy类，Java又不支持多继承，所以只能是接口.到这里基本也就解释了代理类的运行逻辑原理.
不过还有一个重要的问题没解决，就是代理类如何生成的.
从newProxyInstance()方法跟进去，最终会跟到ProxyGenerator的generateProxyClass方法，看一下这个方法的逻辑

 public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if (var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                            Files.createDirectories(var3);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class");
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }

        return var4;
    }

saveGeneratedFiles变量的意思是判断是否需要生成字节码文件到目录下，取值是

 private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));

这里也解释了，加入System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);这行代码之后就能保存字节码.接着看generateClassFile方法

 private byte[] generateClassFile() {
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

        int var3;
        Class var4;
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);
            }
        }

        Iterator var11 = this.proxyMethods.values().iterator();

        List var12;
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            checkReturnTypes(var12);
        }

        Iterator var15;
        try {
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();

            while(var11.hasNext()) {
                var12 = (List)var11.next();
                var15 = var12.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                    this.methods.add(var16.generateMethod());
                }
            }

            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }

        if (this.methods.size() > 65535) {
            throw new IllegalArgumentException("method limit exceeded");
        } else if (this.fields.size() > 65535) {
            throw new IllegalArgumentException("field limit exceeded");
        } else {
            this.cp.getClass(dotToSlash(this.className));
            this.cp.getClass("java/lang/reflect/Proxy");
            var1 = this.interfaces;
            var2 = var1.length;

            for(var3 = 0; var3 < var2; ++var3) {
                var4 = var1[var3];
                this.cp.getClass(dotToSlash(var4.getName()));
            }

            this.cp.setReadOnly();
            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
            DataOutputStream var14 = new DataOutputStream(var13);

            try {
                var14.writeInt(-889275714);
                var14.writeShort(0);
                var14.writeShort(49);
                this.cp.write(var14);
                var14.writeShort(this.accessFlags);
                var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
                var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
                var14.writeShort(this.interfaces.length);
                Class[] var17 = this.interfaces;
                int var18 = var17.length;

                for(int var19 = 0; var19 < var18; ++var19) {
                    Class var22 = var17[var19];
                    var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
                }

                var14.writeShort(this.fields.size());
                var15 = this.fields.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                    var20.write(var14);
                }

                var14.writeShort(this.methods.size());
                var15 = this.methods.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                    var21.write(var14);
                }

                var14.writeShort(0);
                return var13.toByteArray();
            } catch (IOException var9) {
                throw new InternalError("unexpected I/O Exception", var9);
            }
        }
    }

这个方法内部具体生成字节流的方式也不是很懂，class文件有自己的文法，这里贴一小段代码

  public final void sayHello() throws ;
    Code:
       0: aload_0
       1: getfield      #16                 // Field java/lang/reflect/Proxy.h:Ljava/lang/reflect/InvocationHandler;
       4: aload_0
       5: getstatic     #50                 // Field m3:Ljava/lang/reflect/Method;
       8: aconst_null
       9: invokeinterface #28,  4           // InterfaceMethod java/lang/reflect/InvocationHandler.invoke:(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;
      14: pop
      15: return
      16: athrow
      17: astore_1
      18: new           #42                 // class java/lang/reflect/UndeclaredThrowableException
      21: dup
      22: aload_1
      23: invokespecial #45                 // Method java/lang/reflect/UndeclaredThrowableException."<init>":(Ljava/lang/Throwable;)V
      26: athrow
    Exception table:
       from    to  target type
           0    16    16   Class java/lang/Error
           0    16    16   Class java/lang/RuntimeException
           0    16    17   Class java/lang/Throwable

generateClassFile()返回了class文件的字节流，根据java类加载的原理，其实是可以直接加载字节流.
不过java并没有在java层去加载，而是在native层，用jni来调用类加载的方法.在ProxyClassFactory类中的apply方法的这段代码就说明了这个事情.

 /*
             * 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());
            }
           

 private static native Class<?> defineClass0(ClassLoader loader, String name,
                                                byte[] b, int off, int len);

那为什么要在native层做类加载，不在java层做呢,这里有什么原因呢，而defineClass0没有方法注释，就只能猜想一下，动态生成的这个类的字节流只存在于内存中，java自带的加载器无法加载.我们找一段这样的解释佐证一下这个猜想.

AppClassLoader应用类加载器,又称为系统类加载器,负责在JVM启动时,加载来自在命令java中的classpath或者java.class.path系统属性或者CLASSPATH操作系统属性所指定的JAR类包和类路径.

打印下demo中的类加载器的类型

System.out.println(ProxyDemo1.class.getClassLoader().getClass().getName());

输出：sun.misc.Launcher$AppClassLoader.
所以不能用java层的加载方式了，否则就要报异常ClassNotFoundException