前言

不知道,起这个名字算不算是标题党呢?不过如果小伙伴们可以耐心看下去,因为会觉得不算标题党~
这是一个系列文章,目的在于通过动态代理这个很基础的技术,进而深入挖掘诸如:动态生成class;Class文件的结构;用到动态代理的框架源码分析。
对于三部曲来说,我初步打算:

  • 上:从源码处看JDK实现的动态代理的方式。
  • 中:了解Class文件的结构,看懂.class文件。
  • 下:Retrofit中动态代理的源码实现。

对于这个系列的上篇来说,开篇我们先带着几个问题:

  • 1.、动态代理,所谓的“动态”,“代理”都在哪?
  • 2、动态代理如何生成 Class 文件?

自己一直很想好好了解一波动态代理,无论是从技术角度,还是工作角度。
因为作为Android开发,我们日常开发离不开拥有着动态代理思想的Retrofit。而且就冲这个很洋气的名字,学是必须得学的。就算饿死,死外边,从这跳下去,我也要学明白动态代理。

按照正常动态代理的套路,我们需要写一个接口,然后实现接口,然后巴拉巴拉写一堆...写这么多为了干啥?谁呀?咋滴了?不知道啊?

不知道小伙伴们百度动态代理的文章时,是什么感受,反正我是上述的感受。写几行demo,就说深入理解动态代理了?那我学会写demo岂不是资深开发了?所以我个人认为,如果脱离业务去聊技术,恐怕没办法去深入理解这个项技术。所以关于动态代理我们(MDove+一支彩笔)会想办法写成一篇系列文章。后续我(MDove)会结合Android的部分,写一写能真正用起来的效果~


个人理解

首先,先谈一谈我们对动态代理的理解。网上很多资源喜欢把动态代理和静态代理放在一起去对比。这里我们就先不这么来做了,个人感觉静态代理本身重的是一种思想,而本篇动态代理着重去思考它代码套路背后的流程,所以就不放在一起啦。如果有对静态代理感兴趣的小伙伴,可以直接自行了解吧~

关于动态代理,个人喜欢把动态和代理分开理解:

动态:可随时变化的。对应我们编程,可以理解为在运行期去搞事情。

代理:接管我们真正的事务,去代我们执行。在我们生活中有很多充当代理的角色,比如:租房中介。

接下来让我们通过一个:租客通过中介租房子的demo,来展开动态代理的过程。(demo结束之后,我们会从源码的角度,去理解动态代理)

由浅

Demo效果

demo的开始,我们依旧是按照动态代理的语法规则开始入手。简单交代一下demo的剧情~我们有一个租客,身上揣着5000元钱,来到一个陌生的城市里。他想租一个房子,但是人生地不熟的,所以他选择了一个房屋中介...结果中介收了他4500元钱,我们的租客被坑了...

编写代码之前,让我们先看一下效果。

坑坑坑

记住这个效果,接下来让我们一步步,看看租客是怎么被坑的~

开始编码

第一步,我们先把上当受骗的租客写出来,定义一个租客的接口

public interface IRentHouseProcessor {
    String rentHouse(String price);
}

接下来,便是实现InvocationHandler,编写我们动态代理的重头角色。

按照官方的docs文章,对InvocationHandler的解释:每个代理实例(Proxy,这里提到的Proxy代理实例是哪个?不要着急,往下看。)都有一个关联的调用处理程序(InvocationHandler)。在代理实例上调用方法时,方法会被调度到invoke中。

InvocationHandler是我们动态代理核心方法的一个核心参数。它的实例会在构建Proxy实例的时候以参数的形式传递进入,并在Proxy实例被调用的时候,将真正执行的方法,调度到自身的invoke方法里(形成代理)。后文从我们反编译的Proxy.class可以证实这个问题。

public class RentHouseProcessorHandler implements InvocationHandler {
    private Object target;

    public RentHouseProcessorHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Log.d(MainActivity.TAG, "-----------------------------");
        Log.d(MainActivity.TAG, "我是中介,有人找我租房子了,看看他能出多少钱:" + args[0]);
        Log.d(MainActivity.TAG, "我既然是中介,那我收他4000元的好处费,500块钱给你组个地下室,不过分吧?!!");
        Object result = method.invoke(target, new Object[]{"500"});
        Log.d(MainActivity.TAG, "赚了一大笔钱,美滋滋~");
        return result;
    }
}

让我们通过一张图来,仔细的理解一下invoke方法的每个参数的含义。

invoke方法的对应关系

1.1.3、代理开始

编辑好了我们demo故事中的角色,那就让我们开始动态代理之路吧:
首先,我们不使用代理,直接通过租客的实例调用自身实现的接口。这里没啥好说的~只是为了剧情需要,更好的理解流程。

RentHouseProcessorImpl dpImpl = new RentHouseProcessorImpl();
dpImpl.rentHouse("5000");
Log.d(TAG,"我准备找中介去组个房子。");

使用动态代理:

RentHouseProcessorHandler handler = new RentHouseProcessorHandler(dpImpl);
IRentHouseProcessor proxy = (IRentHouseProcessor) Proxy.newProxyInstance(
        dpImpl.getClass().getClassLoader(),
        dpImpl.getClass().getInterfaces(),
        handler);

String content = proxy.rentHouse("5000");
Log.d(TAG, content);

这一步执行完毕,就会得到我们开篇的那个效果。我们的租客本来身上揣了5000元钱,当找了代理之后,真正租房的过程变成了中介(代理)去完成,所以租房的过程变得并不透明(invoke中,进行了一些额外的操作),因此我们的租客被坑了。

这一步我们来解释一下上述提到的那个疑问:代理实例在哪?这个代理实例其实就是Proxy.newProxyInstance()的返回值,也就是IRentHouseProcessor proxy这个对象。这里有一个很严肃的问题?IRentHouseProcessor是一个接口,接口是不可能被new出来的。

所以说proxy对象是一个特别的存在。没错它就是:动态代理动态生成出来的代理实例。而这个实例被动态的实现了我们的IRentHouseProcessor接口,因此它可以被声明为我们的接口对象。

上述docs文档提到,当我们调用proxy对象中的接口方法时,实际上会调度到InvocationHandler方法中的invoke方法中(这个操作同样是在动态生成的Proxy对象中被调度过去的)。

当方法到invoke中,那么问题就出现了:invoke是我们自己重写的,那也就是说:我们拥有至高无上的权利!

所以在我们的租房这个故事中,中介就是在这个invoke方法中,黑掉了我们租户的钱!因为invoke方法中它拥有绝对的操作权限。想干什么就干什么,甚至不执行我们真正想要执行的方法,我们的租客也没办法怎么样。

1.2、入深:“代理”在哪?

接下来让我们走进源码,来解决第一个大问题:1、动态代理,所谓的“动态”,“代理”都在哪?

走到这,不知道小伙伴对动态代理的流程是不是有了一个清晰的认识。动态代理的过程还是套路性比较强的:实现一个InvocationHandler类,在invoke中接受处理proxy对象调度过来的方法(Method)信息,方法执行到此,我们就可以为所欲为的做我们想做的事情啦。而我们的代理类实例是由系统帮我们创建了,我们只需要处理invoke中被调度的方法即可。

接下来让我们了解一下这个被动态生成的代理类实例。“代理”是如何被创建出来的~

1.2.1、“代理”在哪里呀?

第一步,让我们通过动态代理最开始的方法,Proxy.newProxyInstance()入手。

下面的代码,省略了一些判空/try-catch的过程,如果觉得省略不当,可以自行搜索对应的源码。

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h) throws IllegalArgumentException {
    //省略:一些判空,权限校验的操作

    //[ 标注1 ]
    //想办法获取一个代理类的Class对象($Proxy0)
    Class<?> cl = getProxyClass0(loader, intfs);

    //省略:try-catch/权限检验

    //获取参数类型是InvocationHandler.class的代理类的构造方法对象($Proxy的构造方法的参数就是InvocationHandler类型)
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    final InvocationHandler ih = h;

    //省略:cons.setAccessible(true)过程

    //传入InvocationHandler的实例去,构造一个代理类的实例
    return cons.newInstance(new Object[]{h});
    }
}

[ 标注1 ]

这部分代码,我们可以看到,调用了一个参数是ClassLoader、以及接口类型数组的方法。并且返回值是一个Class对象。实际上这里返回的c1实际上是我们的代理类的Class对象。何以见得?让我们点进去一看究竟:

//从缓存中取代理类的Class对象,如果没有通过ProxyClassFactory->ProxyGenerator去生成
private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 如果存在实现给定接口的给定加载器定义的代理类,则只返回缓存副本; 否则,它将通过ProxyClassFactory创建代理类
    return proxyClassCache.get(loader, interfaces);
}

1.2.2、跳过缓存,看背后

上述getProxyClass0方法中,进来之后我们会发现,代码量及其的少。这里很明显是通过了一个Cache对象去想办法获取我们所需要的Class对象。这部分设计到了动态代理的缓存过程,其中用的思想和数据结构比较的多,暂时就先不展开了(篇幅原因,以及也不是我们本次文章重点关注的对象)。如果有感兴趣的小伙伴,可以自行搜索了解呦~

Cache的get过程,最终会转向ProxyClassFactory这个类,由这个类先生成需要的代理类的Class对象。

private static final class ProxyClassFactory 
                implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
    //代理类名称前缀
    private static final String proxyClassNamePrefix = "$Proxy";
    //用原子类来生成代理类的序号, 以此来确定唯一的代理类
    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) {
            //这里遍历interfaces数组进行验证:是否可以由指定的类加载进行加载;是否是一个接口;是否有重复
        }
        //生成代理类的包名
        String proxyPkg = null;
        //生成代理类的访问权限, 默认是public和final
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
        for (Class<?> intf : interfaces) {
            //[ 标注1 ]
            // 省略:验证所有非public的代理接口是否在同一个包中。不在则抛异常
            throw new IllegalArgumentException("non-public interfaces from different packages");
        }

        //省略部分代码:生成代理类的全限定名, 包名+前缀+序号, 例如:com.sun.proxy.$Proxy0
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        //!!接下来便进入重点了,用ProxyGenerator来生成字节码, 以byte[]的形式存放
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,
                                  interfaces, accessFlags);
        //省略try-catch,根据二进制文件生成相应的Class实例
        return defineClass0(loader, proxyName, proxyClassFile, 
                              0, proxyClassFile.length);
    }
}

[ 标注1 ]

这部分,可能省略的比较多,因为内容主要是一些判断。这部分的做的事情是:遍历所有接口,看一下是不是public。如果不是,需要看一些些接口是不是在同一个包下,如果不是抛异常。这个很容易理解,非public接口还不在同一个包下,这没得搞啊~

接下来,让我们重点看一下ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);也就是代理类生成的方法。ProxyGenerator类可以通过查看OpenJDK获取

1.2.3、构造代理Class

接下来我们需要注意的是generateProxyClass,这个方法便是:这个Class被构造出来的缘由:

private byte[] generateClassFile() {
    //首先为代理类生成toString, hashCode, equals等代理方法(组装成ProxyMethod对象)
    addProxyMethod(hashCodeMethod, Object.class);
    addProxyMethod(equalsMethod, Object.class);
    addProxyMethod(toStringMethod, Object.class);

    //省略:遍历每一个接口的每一个方法, 并且为其生成ProxyMethod对象(遍历,调用addProxyMethod()方法)。省略校验过程。

    //省略try-catch:组装要生成的class文件的所有的字段信息和方法信息
    //添加构造器方法(methods:MethodInfo类型的ArrayList)
    methods.add(generateConstructor());
    //遍历缓存中的代理方法
    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
        for (ProxyMethod pm : sigmethods) {
            //添加代理类的静态字段, 例如:private static Method m1;
            fields.add(new FieldInfo(pm.methodFieldName,
                        "Ljava/lang/reflect/Method;", ACC_PRIVATE | ACC_STATIC));
            //添加代理类的代理方法
            methods.add(pm.generateMethod());
        }
    }
    //添加代理类的静态字段初始化方法
    methods.add(generateStaticInitializer());

    //省略校验

    //通过class文件规则,最终生成我们的$Proxy.class文件
    //验证常量池中存在代理类的全限定名
    cp.getClass(dotToSlash(className));
    //验证常量池中存在代理类父类的全限定名, 父类名为:"java/lang/reflect/Proxy"
    cp.getClass(superclassName);
    //验证常量池存在代理类接口的全限定名
    for (int i = 0; i < interfaces.length; i++) {
        cp.getClass(dotToSlash(interfaces[i].getName()));
    }
    //接下来要开始写入文件了,设置常量池只读
    cp.setReadOnly();

    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    DataOutputStream dout = new DataOutputStream(bout);

    //省略try-catch:1、写入魔数
    dout.writeInt(0xCAFEBABE);
    //2、写入次版本号
    dout.writeShort(CLASSFILE_MINOR_VERSION);
    //3、写入主版本号
    dout.writeShort(CLASSFILE_MAJOR_VERSION);

    // 省略其他写入过程

    //转换成二进制数组输出
    return bout.toByteArray();
}

// 封装构造方法
private MethodInfo generateConstructor() throws IOException {
    MethodInfo minfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V",ACC_PUBLIC);    
    DataOutputStream out = new DataOutputStream(minfo.code);
    code_aload(0, out);
    code_aload(1, out);

    out.writeByte(opc_invokespecial);
    out.writeShort(cp.getMethodRef(superclassName,"<init>", "(Ljava/lang/reflect/InvocationHandler;)V"));

    out.writeByte(opc_return);

    minfo.maxStack = 10;
    minfo.maxLocals = 2;
    minfo.declaredExceptions = new short[0];

    return minfo;
}

以上注释的内容,如果小伙伴们看过字节码格式的话,应该不陌生。这一部分内容就是去创建我们的代理类的Class字节码文件(字段/方法的描述符)。并通过ByteArrayOutputStream的作用,将我们手动生成的字节码内容转成byte[],并调用defineClass0方法,将其加载到内存当中。

如果对class文件结构感觉的小伙伴,可以查找一些相关的资料,或者《Java虚拟机规范》。当然也可以继续往下看:3、 Class 文件的格式。

末尾return方法,是一个native方法,我们不需要看实现,应该也能猜到,这里的内容是把我们的构造的byte[]加载到内存当中,然后获得对应的Class对象,也就是我们的代理类的Class。

private static native Class<?> defineClass0(ClassLoader var0, String var1, byte[] var2, int var3, int var4);

1.2.4、$Proxy0.class是什么样子?

OK,到这一步,我们的代理类的Class对象就生成出来了。因此我们Proxy.newProxyInstance()所返回出来的类也就很明确了。就是一个:拥有我们所实现接口类的所有方法结构的全新Class对象。也就是我们所说的代理类。

因为拥有我们接口的方法结构,所以可能调用我们的方法。不过着这个过程中,我们所调用的方法,被调度到InvocationHandler中的invoke方法里了。这一步,可能有小伙伴会问,为什么说我们的方法被调度到invoke之中了?要回答这个问题,我们需要看一下我们生成的Proxy代理类是什么样子的。

我总结了网上各种各样查看动态代理生成的.class文件的方法,贴一种成本最小的方式:
使用Eclipse,运行我们的动态代理的方法。运行之前,加上这么一行代码:

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 

当然这样运行大概率,ide会报错

Exception in thread "main" java.lang.InternalError: 
I/O exception saving generated file: java.io.FileNotFoundException: com\sun\proxy\$Proxy0.class (系统找不到指定的路径。)

那怎么办呢?很简单,在src同级的建三级的文件夹分别是:com/sun/proxy。然后运行,就可以看到我们的$Proxy0.class啦。然后我们把它拖到AndroidStudio当中,查看反编译之后的结果:

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

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

    public final String rentHouse(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 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 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 {
            m3 = Class.forName("proxy.IRentHouseProcessor").getMethod("rentHouse", new Class[]{Class.forName("java.lang.String")});
            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]);
            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的代码,为什么会被调度到invoke方法中就很清晰了吧?

1.3、入深:“动态”在哪?

我们走完上诉1.2的过程,其实“动态”在哪这个问题的答案已经很明确了吧?ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);方法之中JDK本身就直接帮我们动态的构建了我们所需要的$Proxy0类。

1.4、动态代理如何生成 Class 文件?

这个问题的答案,我们也可以从上诉的过程之中找到答案。在对应生成$Proxy的过程中,我们往DataOutputStream之中写入我们class文件所规定的内容;此外写入了我们字段/方法的描述符。然后通过DataOutputStram将我们的内容转成二进制数组。最后交由我们的native方法,去将此class文件加载到内存之中。

结语

小伙伴们一步步追了下来,不知道有没有对动态代理的过程有了比较清晰的认识。
接下来的内容,会针对动态代理进行实际应用场景的编写;以及对Retrofit动态代理相关内容的分析。