Retrofit2.0源码解析

首先介绍一下retrofit的简单用法

先去定义一个Java接口。

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

然后通过Retrofit类的create生成GitHubService接口的实例。

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

Call从创建的GitHubService可以向远程Web服务器发出同步或异步HTTP请求。

Call<List<Repo>> repos = service.listRepos("octocat");

retrofit源码解析

上面代码是retrofit官网的一段代码，从代码中可以看出，首先我们需要定义一个接口，接着通过Retrofit.Builder().build()构建Retrofit实例，然后通过retrofit对象的create方法获得一个接口实例，再调用GitHubService的listRepos()方法返回一个Call对象，最后通过Call对象进行http请求。

首先，看一下Retrofit的构建流程：

Builder()和 build()源码：

public static final class Builder {
    private okhttp3.Call.Factory callFactory;
    private BaseUrl baseUrl;
    private List<Converter.Factory> converterFactories = new ArrayList<>();
    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    private Executor callbackExecutor;
    private boolean validateEagerly;
    public Builder() {
      converterFactories.add(new BuiltInConverters());
    }
    public Builder client(OkHttpClient client) {
      return callFactory(checkNotNull(client, "client == null"));
    }
    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }
    public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      if (httpUrl == null) {
        throw new IllegalArgumentException("Illegal URL: " + baseUrl);
      }
      return baseUrl(httpUrl);
    }
    public Builder baseUrl(final HttpUrl baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      List<String> pathSegments = baseUrl.pathSegments();
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      return baseUrl(new BaseUrl() {
        @Override public HttpUrl url() {
          return baseUrl;
        }
      });
    }
    public Builder baseUrl(BaseUrl baseUrl) {
      this.baseUrl = checkNotNull(baseUrl, "baseUrl == null");
      return this;
    }
    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }
    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      adapterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }

    public Builder callbackExecutor(Executor executor) {
      this.callbackExecutor = checkNotNull(executor, "executor == null");
      return this;
    }

    public Builder validateEagerly(boolean validateEagerly) {
      this.validateEagerly = validateEagerly;
      return this;
    }

public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));

      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
  }

构建时：

baseUrl：必须指定，作为API的基本URL地址，
client（）：设置所使用的HTTP客户端请求，如果不设置，则默认直接new OkHttpClient()，如果你需要对okhttpclient进行详细的设置，需要构建OkHttpClient对象，然后传入；
callFactory()：这是指定一个自定义调用工厂来创建调用实例，默认使用okhttp3.Call.Factory，
validateEagerly()：验证您在构建Retrofit实例时提供的配置。这将检查您的界面注释有效的Retrofit注释，检查参数和方法参数，如果它们与设置的注释一致，也检查可能不正确的方法返回类型（不同于Call<T>）
callbackExecutor()：这个是用来将回调传递到UI线程了，利用platform对象，对平台进行判断，判断主要是利用Class.forName("")进行查找，如果是Android平台：会自定义一个Executor对象，并且利用Looper.getMainLooper()实例化一个handler对象，在Executor内部通过handler.post(runnable)。
addConverterFactory（）：添加转换器完成数据转换，默认情况下，Retrofit只能够反序列化Http体为OkHttp的ResponseBody类型，并且只能够接受ResponseBody类型的参数作为@body，添加转换器对象后，将返回的responseBody转化为对象等，还能用于一般注解的参数的转化，例如@Body标识的对象做一些操作。

这里有6个序列化第三方库:

Gson: com.squareup.retrofit:converter-gson
Jackson: com.squareup.retrofit:converter-jackson
Moshi: com.squareup.retrofit:converter-moshi
Protobuf: com.squareup.retrofit:converter-protobuf
Wire: com.squareup.retrofit:converter-wire
Simple XML: com.squareup.retrofit:converter-simplexml

addCallAdapterFactory（），主要的这个对象主要对Call进行转化，基本不去要设置，使用rxjava的时候一般会设置RxJavaCallAdapterFactory.create())，如果不设置的时候，retrofit会默认创建一个。
创建过程：

List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));

采用的是默认的ExecutorCallAdapterFactory，他的adapt方法里构建了一个回调执行器，实际请求成功后会传给callbackExecutor自身的回调，将原本call的回调转发至UI线程。

 public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

@Override public void enqueue(final Callback<T> callback) {
      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(final Call<T> call, final Response<T> response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancelation
                callback.onFailure(call, new IOException("Canceled"));
              } else {
                callback.onResponse(call, response);
              }
            }
          });
        }
        @Override public void onFailure(final Call<T> call, final Throwable t) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(call, t);
            }
          });
        }
      });
    }

然后接下来retrofit如何通过retrofit.create()实现我们指定接口的实例呢？

其实原理就是动态代理，我们先看一下retrofit.create()方法：

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

private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        loadMethodHandler(method);
      }
    }
  }

  MethodHandler loadMethodHandler(Method method) {
    MethodHandler handler;
    synchronized (methodHandlerCache) {
      handler = methodHandlerCache.get(method);
      if (handler == null) {
        handler = MethodHandler.create(this, method);
        methodHandlerCache.put(method, handler);
      }
    }
    return handler;
  }

从上面的代码可以看出，create方法就是返回了一个Proxy.newProxyInstance动态代理对象，通过Proxy.newProxyInstance产生的代理类，在最后会调用MethodHandler里面的invoke方法。MethodHandler还缓存在一个Map中：

private final Map<Method, MethodHandler> methodHandlerCache = new LinkedHashMap<>();

说明etrofit的网络请求带有缓存功能，
当我们调用接口中的任何方法，都会调用Proxy中的invoke()方法,最后再调用loadMethodHandler(method).invoke(args)，在这个方法中可以拿到传入的参数，注解等。

然后，我们看下MethodHandler.create(this, method)方法:

static MethodHandler create(Retrofit retrofit, Method method) {
    CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
    Type responseType = callAdapter.responseType();
    if (responseType == Response.class || responseType == okhttp3.Response.class) {
      throw Utils.methodError(method, "'"
          + Types.getRawType(responseType).getName()
          + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    Converter<ResponseBody, ?> responseConverter =
        createResponseConverter(method, retrofit, responseType);
    RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
    return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
        responseConverter);
  }

首先 是一个CallAdapter<?>对象，这个callAdapter最终拿到的是我们在构建retrofit里面时adapterFactories时添加的，即为：new ExecutorCallbackCall<>(callbackExecutor, call)，ExecutorCallbackCall的作用就是将原本call的回调转发至UI线程，
接下来通过callAdapter.responseType()返回的是我们方法的实际类型，例如:Call<User>,则返回User类型，然后对该类型进行判断。
接着得到一个Converter<ResponseBody, ?>的对象responseConverter ，也是根据我们构建retrofit时,addConverterFactory添加的ConverterFactory对象来寻找一个合适的返回，默认的是由BuiltinConverters创建的Converter对象，仅仅支持返回值的实际类型为ResponseBody。
再然后由RequestFactoryParser.parse()方法解析注解标签了，进入该方法，可以看到解析得到一个Converter<?, String>对象或Converter<?, RequestBody>对象，然后传递给RequestAction，在RequestAction中，进行各种各样的实现。各个标签的解析都会生成一个RequestAction对象，保存在数组中，最后RequestFactoryParser调用toRequestFactory方法，将数据都保存在RequestFactory中。

最后就new 了一个MethodHandler对象返回，将CallAdapter, Converter, RequestFactory都传递给MethodHandler中。在通过loadMethodHandler(method).invoke(args)，调用invoke方法，

private MethodHandler(okhttp3.Call.Factory callFactory, RequestFactory requestFactory,
      CallAdapter<?> callAdapter, Converter<ResponseBody, ?> responseConverter) {
    this.callFactory = callFactory;
    this.requestFactory = requestFactory;
    this.callAdapter = callAdapter;
    this.responseConverter = responseConverter;
  }
Object invoke(Object... args) {
    return callAdapter.adapt(
        new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));
  }

返回的一个OkHttpCall<>对象。所以在我们最后真正发起网络请求的时候，比如调用Call.enqueue()其实是调用ExecutorCallbackCall.equeue()方法，该方法又会调用OkHttpCall.enqueue()。

Retrofit整体主要是围绕着converter，CallAdapter设计的整个框架，用到了动态代理，工厂，适配器模式，java注解等技术，耦合性低、扩展性强、灵活性高。