java动态代理

java高级群329019348

 

1、java动态代理是通过实现InvovationHandler的invoke方法完成的。原理就是在代理类ProxyClass生成的时候把InvocationHandler当作入参传入到构造函数中，同时在静态模块中根据类名反射生成class。

 

下面一步一步揭开上述的流程。

 

 

IService service=new ServiceImp();
ProxyHandler proxyHandler=new ProxyHandler(service);
IService iService=(IService)Proxy.newProxyInstance(ServiceImp.class.getClassLoader(), ServiceImp.class.getInterfaces(),proxyHandler);

 

iService.doService();

  上述是我们的调用流程，ServiceImp实现了接口Iservice,第二行是产生一个ProxyHandler的实例，第三行是通过静态方法Proxy. newProxyInstance生成的Object强转为IService接口，第四行就是通过强转的接口来调用doService方法。

   下面来分析Proxy.newProxyInstance这个方法，源码中有这么一句

/*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

    看注释就知道这句是生成代理类的，继续往下追

 // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);

    不懂就看注释，其实就是将代理类和ClassLoader做了一个缓存，如果缓存中找不到，就通过ProxyClassFactory创建一个代理类，那么我们重点关注一下下面源码中有ProxyClassFactory实例的地方

 // create subKey and retrieve the possible Supplier<V> stored by that
        // subKey from valuesMap
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));

  在动态调试到这里的时候发现，paramer是需要代理的接口，而apply接口的实现类其中就有一个ProxyClassFactory，我们看一下apply内部的实现

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

  上面对需要代理的类进行了一系列的预判断，抛出了一系列的异常，其中一个就是代理的必须是接口。如果不是接口就会抛出异常，那代理的类是怎么生成的呢？我们继续往下看，

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces);

  通过上面的代码，就生成了class的二进制文件。 generateProxyClass的两个参数。第一个是代理的类的名字，第二个是接口，就是和我们手动创建一个类实现接口是一个意思。本来是想继续往下看的，结果再往下看无法看到源码了，那就手动调用一次看看输出的class二进制文件长的啥样。

 

byte[]classFile= ProxyGenerator.generateProxyClass("com.newService",new Class[]{IService.class});
		File file=new File("Test.class");
		try {

			file.createNewFile();//建立输出字节流

			FileOutputStream fos = new FileOutputStream(file);

			//用FileOutputStream 的write方法写入字节数组
			fos.write(classFile);
			System.out.println("写入成功");
		}catch (Exception e)
		{
			e.printStackTrace();
		}

     反编译后的class文件如下:

    

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com;

import com.mfuny.proxy.IService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class newService extends Proxy implements IService {
    private static Method m1;
    private static Method m0;
    private static Method m3;
    private static Method m2;

    public newService(InvocationHandler var1) throws  {
        super(var1);
    }

    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 void doService() 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);
        }
    }

    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("com.mfuny.proxy.IService").getMethod("doService", 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());
        }
    }
}

   可以看到在代理类继承了Proxy类，实现了代理的接口。在静态方法里面初始化了代理的类的方法。在doService方法里调用了基类的handler的invoke方法。

 

   至此，终于真相大白了。

   在总结一下java动态代理的特点：

   1、代理类必须是接口，不是接口的话会抛出异常

   2、通过ProxyGenerator.generateProxyClass(Object[]args)生成一个类 ,第一个是类名，第二个是接口数组，传入需要代理的接口数组。就会生成一个继承自java.lang.reflect.Proxy的代理类，代理类内部实现的接口都会调用基类Proxy内的handler进行invoke操作，基类内部的InvocationHandler怎么来的呢？是通过静态方法Proxy.newProxyInstance的第三个参数传入的