JAVA动态代理

Posted 2021-01-05 zhengwangzw

在学习spring aop时，实现的原理就是java动态代理，上一篇文章已经讲了静态代理，静态代理类是编译器确定的，而动态代理是运行时在JVM内存中生产的Class对象和对象实例，还是以一个例子说明，我们实际工程中有个需求：根据调用方请求的数据类型的不同，而使用不同的脚本抓取外部数据，比如外部数据有微博和腾讯视频，示例代码如下：

/**
 * 抓取外部数据的接口
 */
public interface IProvider {
    String getData(String datatype);
}

public class WeiboProvider implements IProvider {
    @Override
    public String getData(String datatype) {
        System.out.println("get weibo data...");
        return "weibo json string";
    }
}

public class ProviderHandler implements InvocationHandler {
    Object target;

    public Object bind(Object target){
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //检查参数
        checkArgs(args);
        Object obj =method.invoke(target, args);
        //打印日志
        System.out.println("print log...");
        return obj;
    }

    private void checkArgs(Object[] args) throws Throwable {
        if(args.length == 0|| args[0].equals(""))
            throw new Exception("args can not be empty..");
    }
}

public class ClientCaller {
    public static void main(String[] args) {
        ProviderHandler providerHandler = new ProviderHandler();
        IProvider iProvider = (IProvider) providerHandler.bind(new WeiboProvider());
        iProvider.getData("weibo.data");
    }
}

具体看就是创建一个Handler实现InvocationHandler接口，InvocationHandler接口有个invoke函数，这其中有三个对象要理清楚：

1.  WeiboProvider 对象  我们称之为被代理对象

2.  ProviderHandler 对象  我们称之为执行者对象

3.  Proxy对象 （通过ProviderHandler 对象bind方法生成的对象） 我们称之为代理对象

我们先来回忆一下为什么使用代理模式，是为了增强WeiboProvider 被代理对象的方法，因此我们就用Proxy对象来代理被代理对象的执行，Proxy不亲自来做这件事，而是交给执行者对象ProviderHandler 来实现增加的目录，执行前参数检查，执行后打印日志。

所以这里的关键点是

Proxy.newProxyInstance拿到的对象，然后调用接口getData()是怎样传导到执行者ProviderHandler的invoke方法的。

1.看newProxyInstance源码

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
           
        return cons.newInstance(new Object[]{h});
    }

我只留下了最关键的代码， 首先对invocationhandler做判空处理，然后复制interface类数组，这里就是[IProvider],   getProxyClass0函数非常关键，根据类加载器和接口对象在JVM缓存中生成一个类对象，getConstructor()根据Class类对象获取构造器，然后cons.newInstance实例化Proxy对象。

可能这个地方大家都会疑惑，生成的Proxy对象是怎样调用执行者的invoke函数的

这个地方通过这段代码将Proxy0的class字节码输出到文件

 byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", WeiboProvider.class.getInterfaces());
        String path = "C:/Users/zw/IdeaProjects/study/out/production/study/WeiboProxy.class";
        try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类class文件写入成功");
        } catch (Exception e) {
            System.out.println("写文件错误");
        }

反编译Proxy0如下：

public final class $Proxy0 extends Proxy implements IProvider {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    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})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 String getData(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } 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);
        }
    }

    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("aop.IProvider").getMethod("getData", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

这么一看瞬间明白了，

$Proxy0继承Proxy类，实现了IProvider接口，也有getData()函数，而getData函数调用则是执行者Handler的invoke方法，m3是通过反射拿到的Method对象，所以看getData调用invoke传递的
三个参数，第一个是Proxy对象，第二个是getData方法对象，第三个是参数。