Retrofit2 源码解析

Dec 13 2015

公司里最近做的项目中网络框架用的就是Retrofit,用的多了以后觉得这个框架真的非常好用,然后抽了点时间debug了一下源码,觉得不光代码写的非常好,而且设计这个框架的思路都非常特别,收获很多,决定记录下来

本文的源码分析基于Retrofit 2.0,和Retrofit 1.0有较大的不同, 本文主要分为几部分:0、Retrofi 是什么,1、Retrofi怎么用,2、Retrofit的原理是什么,3、我的心得与看法

下面说的Retrofit全部指Retrofit 2

0 Retrofit是什么

来自Retrofit官网的介绍:

A type-safe HTTP client for Android and Java

简单的说它是一个HTTP请求工具,和Google开发的Volley功能上非常相似,这里有Volley的源码解析,但是使用上很不相似。Retrofit使用起来更简单,Volley使用上更加原始而且符合使用者的直觉,其实我觉得如果对自己Volley封装一下也可以像Retrofit那样的简单的使用

关于Volley的使用方法,请戳上面的Volley源码解析链接,这里就不赘述了

1 Retrofit怎么用

虽然Retrofit官网已经说明了,我还是要按照我的思路说一下它的使用方法

比如你要请求这么一个api:

https://api.github.com/repos/{owner}/{repo}/contributors

查看github上某个repo的contributors,首先你要这样建一个接口:

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

然后你还需要创建一个Retrofit对象:

public static final String API_URL = "https://api.github.com";

// Create a very simple REST adapter which points the GitHub API.
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl(API_URL)
    .addConverterFactory(GsonConverterFactory.create())
    .build();

再用这个Retrofit对象创建一个GitHub对象:

// Create an instance of our GitHub API interface.
GitHub github = retrofit.create(GitHub.class);

// Create a call instance for looking up Retrofit contributors.
Call<List<Contributor>> call = github.contributors("square", "retrofit");

最后你就可以用这个Githb对象获得数据了:

// Fetch and print a list of the contributors to the library.
call.enqueue(new Callback<List<Contributor>>() {
    @Override
    public void onResponse(Response<List<Contributor>> response) {
        for (Contributor contributor : response.body()) {
            System.out.println(contributor.login + " (" + contributor.contributions + ")");
        }
    }
    @Override
    public void onFailure(Throwable t) {
    }
});

这个使用方式看上去和Volley的方式完全不一样,使用Volley时你必须先创建一个Request对象,包括这个请求的Method,Url,Url的参数,以及一个请求成功和失败的Listener,然后把这个请求放到RequestQueue中,最后NetworkDispatcher会请求服务器获得数据。而Retrofit只要创建一个接口就可以了,太不可思议了!!

而我要说,其实这两种方式本质上是一样的,只是这个框架描述HTTP请求的方式不一样而已。因此,你可以发现上面的Github接口其实就是Retrofit对一个HTTP请求的描述

2 Retrofit的原理

Volley描述一个HTTP请求是需要创建一个Request对象,而执行这个请求呢,就是把这个请求对象放到一个队列中,让网络线程去处理。

Retrofit是怎么做的呢?答案就是Java的动态代理

动态代理

当开始看Retrofit的代码,我对下面这句代码感到很困惑:

// Create an instance of our GitHub API interface.
GitHub github = retrofit.create(GitHub.class);

我给Retrofit对象传了一个Github接口的Class对象,怎么又返回一个Github对象呢?进入create方法一看,没几行代码,但是我觉得这几行代码就是Retrofit的精妙的地方:

/** Create an implementation of the API defined by the {@code service} interface. */
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
public <T> T create(final Class<T> service) {
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
      eagerlyValidateMethods(service);
  }
  return (T) 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)
          throws Throwable {
        // If the method is a method from Object then defer to normal invocation.
        if (method.getDeclaringClass() == Object.class) {
          return method.invoke(this, args);
        }
        if (platform.isDefaultMethod(method)) {
          return platform.invokeDefaultMethod(method, service, proxy, args);
        }
        return loadMethodHandler(method).invoke(args);
      }
    });
}

看,create方法重要就是返回了一个动态代理对象。那么问题来了…

动态代理是个什么东西?

看Retrofit代码之前我知道Java动态代理是一个很重要的东西,比如在Spring框架里大量的用到,但是它有什么用呢?

Java动态代理就是Java开发给了开发人员一种可能:当你要调用某个类的方法前,插入你想要执行的代码

比如你要执行某个操作前,你必须要判断这个用户是否登录,或者你在付款前,你需要判断这个人的账户中存在这么多钱。这么简单的一句话,我相信可以把一个不懂技术的人也讲明白Java动态代理是什么东西了。

为什么要使用动态代理

你看上面代码,获取数据的代码就是这句:

// Create a call instance for looking up Retrofit contributors.
Call<List<Contributor>> call = github.contributors("square", "retrofit");

上面github对象其实是一个动态代理对象,并不是一个真正的Githb接口的implements对象,当github对象调用contributors方法时,执行的是动态代理方法(你debug一下就知道了)

此时,动态代理发挥了它的作用,你看上去是调用了contributors方法,其实此时Retrofit把Github接口翻译成一个HTTP请求,也就是Retrofit中的MethodHandler对象,这个对象中包含了:

  • OkHttpClient:发送网络请求的工具
  • RequestFactory: 类似于Volley中的Request,包含了HTTP请求的Url、Header信息,MediaType、Method以及RequestAction数组
  • CallAdapter:HTTP请求返回数据的类型
  • Converter:数据转换器

嗯,简单来说,Retrofit就是在你调用Call<List<Contributor>> call = github.contributors("square", "retrofit");后为你生成了一个Http请求,然后,你调用call.enqueue方法时就发送了这个请求,然后你就可以处理Response的数据了,从原理上讲,就是这样的。如果要再往细节处说,就可以再说很多了

3 Retrofit的源码分析

想要弄清楚Retrofit的细节,先来看一下Retrofit源码的组成:

  1. 一个retrofit2.http包,里面全部是定义HTTP请求的注解,比如GETPOSTPUTDELETEHeadersPathQuery等等
  2. 余下的retrofit2包中十几个类和接口就是全部retrofit的代码了,代码真的很少,很简单,因为retrofit把网络请求这部分功能全部交给了okHttp了

Retrofit接口

我觉得你你必须要知道下面接口的含义

Callback<T>

这个接口就是retrofit请求数据返回的接口,只有两个方法

  • void onResponse(Response<T> response);
  • void onFailure(Throwable t);

Converter<F, T>

这个接口主要的作用就是将HTTP返回的数据解析成Java对象,主要由Xml、Gson、protobuf等等,你可以在创建Retrofit对象时添加你需要使用的Converter实现(看上面创建Retrofit对象的代码)

Call<T>

这个接口主要的作用就是发送一个HTTP请求,Retrofit默认的实现是OkHttpCall<T>,你可以根据实际情况实现你自己的Call类,这个设计和Volley的HttpStack接口设计的思想非常相似,子类可以实现基于HttpClientHttpUrlConnetction的HTTP请求工具,这种设计非常的插件化,而且灵活

CallAdapter<T>

上面说到过,CallAdapter中属性只有responseType一个,还有一个<R> T adapt(Call<R> call)方法,这个接口的实现类也只有一个,DefaultCallAdapter。这个方法的主要作用就是将Call对象转换成另一个对象,可能是为了支持RxJava才设计这个类的吧

Retrofit的运行

刚才讲到GitHub github = retrofit.create(GitHub.class);代码返回了一个动态代理对象,而执行Call<List<Contributor>> call = github.contributors("square", "retrofit");代码时返回了一个OkHttpCall对象,拿到这个Call对象才能执行HTTP请求

其中后一句代码执行了一个非常复杂的过程

当执行了contributors方法时,Retrofit其实是执行了动态代理的InvocationHandler对象,最后会创建一个MethodHandler对象,这个对象很重要

static MethodHandler<?> create(Retrofit retrofit, Method method) {
    CallAdapter<Object> callAdapter = (CallAdapter<Object>) createCallAdapter(method, retrofit);
    Type responseType = callAdapter.responseType();
    Converter<ResponseBody, Object> responseConverter =
        (Converter<ResponseBody, Object>) createResponseConverter(method, retrofit, responseType);
    RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);

    return new MethodHandler<>(retrofit.client(), requestFactory, callAdapter, responseConverter);
}

上面代码就是创建一个MethodHandler对象,一个MethodHandler对象中包含了4个对象

0. OkHttpClient

这个是Retrofit默认生成的

1. RequestFactory:

通过RequestFactoryParser.parse(method, responseType, retrofit);生成,主要作用就是解析整个Http请求的所有数据

主要原理就是解析一个接口,比如上面的Github接口,结果就是得到整个Http请求全部的信息,还会通过@Path@Query注解拼接Url

不细讲了,全部代码都在retrofit.RequestFactoryParser类中

2. CallAdapter

获取CallAdapter的代码如下:

private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {
  Type returnType = method.getGenericReturnType();
  if (Utils.hasUnresolvableType(returnType)) {
    throw Utils.methodError(method,
      "Method return type must not include a type variable or wildcard: %s", returnType);
  }
  if (returnType == void.class) {
    throw Utils.methodError(method, "Service methods cannot return void.");
  }
  Annotation[] annotations = method.getAnnotations();
  try {
    return retrofit.callAdapter(returnType, annotations);
  } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);
  }
}

你可以在创建Retrofit对象时,添加你想要的CallAdapter,而获取CallAdapter的方式也是从Retrofit对象中获取

默认的DefaultCallAdapter几乎没有上面作用,基本和动画里面的LinearInterpolator差不多

3. Converter

获得Converter对象和上面的原理几乎一样

private static Converter<ResponseBody, ?> createResponseConverter(Method method,
  Retrofit retrofit, Type responseType) {
  Annotation[] annotations = method.getAnnotations();
  try {
    return retrofit.responseBodyConverter(responseType, annotations);
  } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw Utils.methodError(e, method, "Unable to create converter for %s", responseType);
  }
}

创建这4个对象的目的就是为了执行下面这句代码

Object invoke(Object... args) {
  return callAdapter.adapt(new OkHttpCall<>(client, requestFactory, responseConverter, args));
}

这个也就是github.contributors("square", "retrofit");返回的Call对象

最后你调用Call对象的execute()enqueue(Callback<T> callback)方法,就能发送一个Http请求了

只不过前一种方式是同步的,后一种是异步的,也就是说Retrofit提供了同步和异步两种HTTP请求方式

你可能会觉得我只要发送一个HTTP请求,你要做这么多事情不会很“慢”吗?不会很浪费性能吗?

我觉得,首先现在手机处理器主频非常高了,解析这个接口可能就花1ms可能更少的时间(我没有测试过),面对一个HTTP本来就需要几百ms,甚至几千ms来说不值得一提;而且Retrofit会对解析过的请求进行缓存,就在Map<Method, MethodHandler<?>> methodHandlerCache这个对象中

如何在Retrofit中使用RxJava

由于Retrofit设计的扩张性非常强,你只需要改变一下CallAdapter就可以了

Retrofit retrofit = new Retrofit.Builder()
.baseUrl(“https://api.github.com“)
.addConverterFactory(ProtoConverterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();

上面代码创建了一个Retrofit对象,支持Proto和Gson两种数据格式,并且还支持RxJava

4 最后

Retrofit非常巧妙的用注解来描述一个HTTP请求,将一个HTTP请求抽象成一个Java接口,然后用了Java动态代理的方式,动态的将这个接口的注解“翻译”成一个HTTP请求,最后再执行这个HTTP请求

Retrofit的功能非常多的依赖Java反射,代码中其实还有很多细节,比如异常的捕获、抛出和处理,大量的Factory设计模式(为什么要这么多使用Factory模式?)

Retrofit中接口设计的恰到好处,在你创建Retrofit对象时,让你有更多更灵活的方式去处理你的需求,比如使用不同的Converter、使用不同的CallAdapter,这也就提供了你使用RxJava来调用Retrofit的可能

我也慢慢看了PicassoRetrofit的代码了,收获还是很多的,也更加深入的理解面向接口的编程方法,这个写代码就是好的代码就是依赖接口而不是实现最好的例子

好感谢开源的世界,让我能读到大牛的代码。我一直觉得一个人如果没有读过好的代码是不太可能写出好代码的。什么是好的代码?像PicassoRetrofit这样的就是好的代码,扩展性强、低耦合、插件化