Retrofit2 动态代理下的分析

Retrofit2 目前已经越来越主流稳定了，它终于完全抛弃了其它的网络库而是使用了OkHttp3作为依赖，功能也更加插件化了。经常听到动态代理这个词而不知所云，现在知识水平高了，分析一下，以飨(xiǎng)读者。

如果用一个词来概括Retrofit的话，那么“拼装”就是最准确的，它借鉴了以前服务器编程中的动态代理技术，通过接口在运行时生成字节码；接着通过注解拼装HTTP请求；最后包装了OkHttp，实现了对Rx、线程的adaption。

本文主要是过程(practice)，而不是教程(tutorial)，所以希望各位下载代码实践。

本文基于retrofit:2.0.0-beta3与jdk1.8.0_05进行分析

你将学到

1. 代理的一些简介
2. 定义的接口在动态代理使用前与使用后的对比
3. Retrofit如何完成interface(方法，注解与泛型)到Okhttp请求对象的转换(待填坑)
4. Retrifit如何使用Okhttp并在回调时进行线程切换，已经另开文章写

准备工具

1. 对字节码进行分析的反编译工具

2. 对字节码保存的字节码保存工具类，用这个可以导出class文件，当然你也可以在jvm

    ProxyUtils.saveProxyClass("123.class", "Github", new Class[] { GitHub.class });

3. Retrofit2的源码，注意它是基于maven的，最好用Idea导入

    git clone --depth=1 https://github.com/square/retrofit.git

4. 还不知道Retrofit怎么用？先看看Retrofit解析JSON数据吧

1. 什么是代理

代理是一种设计模式，分为静态代理与动态代理。

没有代理前，调用是这样的：

• 调用者
• 业务细节实现

使用后，它们的调用顺序是这样的：

• 调用者
• 业务逻辑（一般是抽象方法或者是接口）
• 业务细节实现

通过在中间加了一层代理，将业务逻辑与实现细节分离，方便了上层开发者。

1.1. 举例

1.1.1. 办手续

我需要去有关部门办很多手续，但是不想来回跑，于是找到了一家中介。

我 <-- 次性提供中介要求的几个证件 --> 中介
中介 <-- 进行繁琐的填表跑腿工作 --> 有关部门

通过代理，我不用了解跑腿的细节，就可以完成业务，这个就是代理的优点，面向业务而忽略细节。当然这个是有代价的（比如需要交跑腿费），在编码中，代理类加大了编码量。

1.1.2. 上外网

我需要访问国外的网站，但是速度很慢，于是找到了一个服务商。

我 <-- 一键配置pac --> 中转服务器
中转服务器 <-- 进行繁琐的开发、运维工作 --> 外网

通过代理，我只用复制一个pac，就可以完成业务，而不用去想怎么与防火墙斗智斗勇，同样这个是需要代价的

1.2. 理论

1.2.1. 静态代理

通过用户手动编码或者在编译时自动生成。

在 AppCompatActivity 中的AppCompatDelegate 抽象类就是静态代理，而抽象类的实例化是在静态语句块 static{} 区中根据版本号实现的，这样写可以避免 Activity 本身的业务过于冗余，同时将抽象类（也可能是接口）与实现类相分离，这样上层开发者可以专注于业务，而不用管具体的实现。

AppCompatActivity - 委任 - 委任实现

在Android中的IPC访问中，如果需要跨进程访问方法，需要使用AIDL通信，当调用者调用远程方法时，调用的是 Stub 类，也就是远程进程的桩，接着这个桩通过 ASHMEM(匿名共享内存) 进行转发，最后方法的实现还是在远程服务器中。

调用者  - Stub接口(由AIDL生成) - 远程服务

上面的 stub, delegate 都是静态代理，本身是抽象类的，让调用者实现了面向接口业务编程。

1.2.2. 动态代理

动态代理是java中的字节码生成技术。通过接口生成代理类，并将代理类的实现交给 InvocationHandler 作为具体的实现。

1. Retrofit中为了简化复杂的网络请求，通过动态代理的去处理解析与拼装。
2. 希望给某个方法在执行的过程中添加权限控制或者打log，这时我们可以用动态代理生成后在handler中装饰多余的业务，从而保存原有的方法专注于业务本身（即AOP编程），例子在这里。
3. 在运行时“欺上瞒下”，比如360的插件化技术的实现

动态代理的过程

动态代理借助java的反射特性，通过易写的接口与注解，帮助用户自动生成实际的对象，接口中方法真正的调用交给InvocationHandler。

Input	interface
↓	↓
Proxy.newProxyInstance	对接口进行包装，内部方法由handler委任
↓	↓
Output	interface(with InvocationHandler)

当用户调用生成接口中的方法时，实际上调用了InvocationHandler中的invoke方法

现在我们将动态代理前的接口文件，与代理后的运行生成的反编译后的文件进行对比

生成前

官方的示例接口

public interface GitHub {
  @GET("/repos/{owner}/{repo}/contributors") Call<List<Contributor>> contributors( @Path("owner") String owner, @Path("repo") String repo);
}

官方对接口的调用

Call<List<Contributor>> call = github.contributors("square", "retrofit");

代理生成中

它在Retrofit中的create中作为参数传入，通过调用下面方法读取接口信息并在运行时生成字节码并用classloader加载

Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
  new InvocationHandler() {
    private final Platform platform = Platform.get();

    @Override public Object invoke(Object proxy, Method method, Object... args)
         .....
         //开始处理注解并拼装成OkHttp的call
      return loadMethodHandler(method).invoke(args);
    }
  });
}

生成后

这是动态代理生成后用工具dump出并反编译的class（下面省略了Object自带的方法，以及大量的异常捕捉）

public final class Github extends Proxy implements SimpleService.GitHub {
  private static Method m0;//自带的hashCode方法
  private static Method m1;//自带的equals方法
  private static Method m2;//自带的toString
  private static Method m3;//真正的接口中的方法

  static {
    try {
    //省略Object自带方法的初始化
      m0,m1,m2 = ...
      //接口中真正的方法
      m3 = Class.forName("com.example.retrofit.SimpleService$GitHub")
          .getMethod("contributors",
              new Class[] { Class.forName("java.lang.String"), Class.forName("java.lang.String") });
    } catch (Throwable e) {
      throw new NoSuchMethodError(e.getMessage());
    } catch (Throwable e2) {
      throw new NoClassDefFoundError(e2.getMessage());
    }
  }

  public Github(InvocationHandler invocationHandler) {
    super(invocationHandler);
  }

    //这里的参数实际上就是用户输入的"square", "retrofit"
  public final Call contributors(String str, String str2) {
    RuntimeException e;
    try {
    //this.h是InvocationHandler，也就是上文重写的Handler
    //可以看出实际调用的是handler的`invoke`方法
      return (Call) this.h.invoke(this, m3, new Object[] { str, str2 });
    } catch (Throwable e) {
      throw e;
    } 
  }

  ....Object自带方法的代理...
}

可以看出InvocationHandler是最重要的修饰，Handler中的invoke进行了实际处理，而这些是我们重写过的，至于具体怎么处理的，这些坑后续再补。

动态代理的原理

代理生成的过程使用了sun包中的闭源方法，反编译大致看了一下，先把接口通过ProxyGenerator.generateProxyClass()根据Class文件的规范拼装生成了byte[]字节码，接着用native方法defineClass0()转换为对象，可以看出动态代理本质上是生成大量样板代码的过程。相比于静态代理，动态代理可以减少编写代理类（比如XXXImpl）的工作量。

动态代理（反射）是否降低了性能？

不会，经过测试。retrofit构造与动态代理加起来的时间只有 0.65ms，相对于 16ms ，相比于网络请求，完全不是一个数量级。如果你是强迫症的话，可以让它单例化。

Refference

1. https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/
2. http://a.codekk.com/detail/Android/Caij/%E5%85%AC%E5%85%B1%E6%8A%80%E6%9C%AF%E7%82%B9%E4%B9%8B%20Java%20%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86
3. http://docs.oracle.com/javase/tutorial/reflect/
4. http://tutorials.jenkov.com/java-reflection/generics.html

1. http://www.ibm.com/developerworks/cn/java/j-jtp08305.html
2. http://www.jianshu.com/p/a56c61da55dd