Retrofit源码解析

Retrofit源码结构

Retrofit： 通过注解，把一个Java接口转化成一个http 请求，底层网络请求基于okhttp

从Retrofit源码结构可以看出，Retrofit 源码分成两部分



一部分是包retrofit2.http里面的，在Java接口方法中使用，用来控制http行为的注解。

一部分是retrofit2里面的，负责把REST API转化成Java接口。

Retrofit和okhttp的关系

retrofit依赖okhttp库，retrofit 所有的网络请求都是由okhttp处理，可以说retrofit是对okhttp封装了，让其使用更加简单方便。

okhttp 准确来说是一个Java库，没有Android中主线程和工作线程的概念，Android有两个限制，第一不能再主线程中直接请求网络，第二不能在工作线程中直接更新UI，所以，如果我们在Android中直接使用okhttp，需要用到Handler来传递请求结果。而如果使用retrofit，则不需要我们去创建线程执行网络请求，也不需要使用Handler把请求结果从工作线程传递到主线程。retrofit直接在主线程中发起异步请求，最后收到请求结果也是在主线程中，非常方便。

主要类和方法

Retrofit：retrofit框架的入口类，主要有两个功能：

1、通过内部类Builder配置构建Retrofit实例。Builder主要配置选项：

1. client(OkHttpClient client) ：设置一个配置好的OkHttpClient实例，不配置的话retrofit会默认new一个。
2. baseUrl(String baseUrl) ：设置API地址。
3. addConverterFactory(Converter.Factory factory) ：设置一个数据转化工厂，比如把Json和实体类之间的转化。
4. addCallAdapterFactory(CallAdapter.Factory factory)：设置一个适配器工厂，方便和其他库配合使用，如RxJava。

另外，如果我们没有设置执行任务的线程池的话，Retrofit会根据不同的平台，得到默认的线程池。

if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}

Android 中默认的线程池：

static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}

@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}

static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());

@Override public void execute(Runnable r) {
handler.post(r);
}
}
}

从上面代码可以看到，先会创建一个在主线程中的Handler，然后默认线程池执行的任务都是在Android的主线程中执行的，这也是在Retrofit异步回调中我们能直接在里面更新UI的原因。

另外，Retrofit根据不同使用平台，会默认添加一个CallAdapterFactory

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

Android 中添加的是ExecutorCallAdapterFactory：

2、通过Retrofit的create方法，实现描述http请求的Java接口。

// 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");

我们在使用Retrofit时，首先要通过Retrofit实例来得到一个请求接口的实例(github)，然后调用这个实例的一个方法（contributors）构造一个Call对象。这个过程主要是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);
}
ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}

当调用接口里面方法的时候（github.contributors(“square”, “retrofit”) ），会执行InvocationHandler里面的内容，通过反射，得到调用的method相关信息，然后构造ServiceMethod和OkHttpCall的实例，在Android中通过ExecutorCallAdapterFactory 把 OkHttpCall 进行转换 ExecutorCallbackCall：

return new CallAdapter<Call<?>>() {
@Override public Type responseType() {
return responseType;
}

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

最后我们得到的Call对象实际上是ExecutorCallbackCall实例。得到Call实例之后，就可以通过call.enqueue进行网络请求，我们看看ExecutorCallbackCall中的enqueue方法：

@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("callback == null");

delegate.enqueue(new Callback<T>() {
@Override public void onResponse(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 cancellation.
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
}
});
}

@Override public void onFailure(Call<T> call, final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(ExecutorCallbackCall.this, t);
}
});
}
});
}

在ExecutorCallbackCall中的enqueue里面，又调用delegate.enqueue方法，这个delegate，其实是OkHttpCall对象，也就是调用OkHttpCall中的enqueue方法。

首先构造一个okhttp中的Request对象：

private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}

可以看出，是通过ServiceMethod的toRequest方法得到的：

Request toRequest(Object... args) throws IOException {
RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
contentType, hasBody, isFormEncoded, isMultipart);

@SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;

int argumentCount = args != null ? args.length : 0;
if (argumentCount != handlers.length) {
throw new IllegalArgumentException("Argument count (" + argumentCount
+ ") doesn't match expected count (" + handlers.length + ")");
}

for (int p = 0; p < argumentCount; p++) {
handlers[p].apply(requestBuilder, args[p]);
}

return requestBuilder.build();
}

其中构造RequestBuilder的参数都是ServiceMethod 从Java接口中的注解解析出来的。

ServiceMethod： 从这个类的方法结构可以看出，这个类主要作用是把方法的注解解析成变量保存起来。