Retrofit是用在网络请求中非常常用的一个库，这里从2.5.0版本
的源码去分析一下它的工作机制。看看它实际做了什么事情以及和okhttp的关系。由于本人水平有限，不喜勿喷。
使用介绍
直接上代码，下面是Retrofit最简单的使用方法
public interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
//创建Retrofit对象
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
//生成接口的动态代理类
GitHubService service = retrofit.create(GitHubService.class);
//调用接口方法生成返回值对象
Call<List<Repo>> repos = service.listRepos("octocat");
//异步请求方法，加入队列返回结果
repos.enqueue(new Callback<List<Repo>>() {
@Override
public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
}
@Override
public void onFailure(Call<List<Repo>> call, Throwable t) {
}
});
以上就是Retrofit的最简单的异步调用，流程大概分为
1. 首先要定义请求的接口，用注解说明请求方法类型和接口参数
2. 用Builder模式创建Retrofit对象，这里可以添加baseUrl、添加数据解析类(Converter)、数据转换类（CallAdapter）等
3. 用动态代理生成1步骤中定义的接口的代理类
4. 调用接口方法生成Call对象，将Call对象加入队列，等待结果回调。
我一般看源码是从离用户最近的调用开始看的，这里就是4步骤中的enqueue方法，但是点进去之后发现enqueue是一个接口方法，所以可以确定是一个实现类调用了这边，这里走不通。往上走看create方法
public <T> T create(final Class<T> service) {
//1. 验证是否是接口类型
Utils.validateServiceInterface(service);
//2. 这里是一个用于提前测试调用性能的方法，可以观察极端情况下的调用时间等
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//3. 用动态代理生成类实例
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override public Object invoke(Object proxy, Method method, @Nullable 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 loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
}
这里的代码大概可以分为三部分
- 验证传入的类是否为接口类，并且是不能有继承的接口，否则会抛出异常
- 字面意思是急切的验证方法，这里主要用于测试，在接口声明的方法很多时可能会影响性能，可以提前发现问题
- 返回一个service实例，也就是接口实例，这里面用到了动态代理的方法来产生实例
动态代理
我们先说一下动态代理是什么，Proxy.newProxyInstance是生成动态代理的方法，这个要传入三个参数，第一个是类加载器，第二个是要生成动态代理的类，第三个是一个回调。动态代理有什么特点呢？就是动态代理类所有方法的调用都会回调到第三个参数的回调invoke方法里面，包括继承的方法等（hashCode、equals、toString等）。
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
我们再看看invoke方法
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
这个方法的参数包括代理对象，调用方法，方法参数，说白了就是方法里面的所有信息都会回调到这里。一般用动态代理是为了对调用方法作某种统一处理，比如信息验证、Log打印等，Retrofit用动态代理是为了统一处理注解，生成okhttp的Call对象。我们看动态代理里面的代码
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
//1. 这个是一个和平台相关的类
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
// 2.如果方法是Object的方法，让它走正常调用流程
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
// 默认方法的处理
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
// 3. 其实核心的代码是这一句
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
所有在Interface里面定义的接口请求都会经过上面的拦截，这里面大概也可以分为三部分
- 首先要知道Retrofit可以用在Android和Java，
Platform是一个和平台相关的类，它的子类有Android和Java8，Platform主要就是处理和平台相关的逻辑的。 - 这部分代码主要是防止对Object类的方法的干扰，包括
toString、hashCode、equals等，让这些方法该怎么样就怎么样。 - 这行代码才是真正做事情的，返回的是你在接口定义的方法的返回值，
invoke是ServiceMethod类中的一个抽象方法，要看实现类
ServiceMethod<?> loadServiceMethod(Method method) {
//从缓存中取得ServiceMethod实例
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
//如果缓存不存在就去生成，然后放进缓存
if (result == null) {
//生成ServiceMethod对象
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
loadServiceMethod的逻辑很简单，方法传入的是从动态代理获得的Method，里面的逻辑从缓存取得ServiceMethod对象，如果没有缓存则生成一个
ServiceMethod
ServiceMethod是一个抽象类，它相对于是一个中间人的作用，是用户调用和真正实现的一个中介，这里面会把网络请求需要的参数和回调准备好给Okhtt使用，并且把网络请求结果返回给用户。
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//处理注解生成RequestFactory
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(method,
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw methodError(method, "Service methods cannot return void.");
}
//生成ServiceMethod对象
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
这是生成ServiceMethod对象的方法，参数是Retrofit和Method对象，这个方法把生成ServiceMethod的工作委托给了HttpServiceMethod类，其中的RequestFactory.parseAnnotations(retrofit, method)是用来解析注解的地方，RequestFactory保存了解析后的参数，然后把这个对象往下传递，具体的流程可以自己去看一下。
HttpServiceMethod
继续往下走，HttpServiceMethod是 ServiceMethod的唯一的子类，所以它就是干事情的地方，到这里我们大概就知道了在动态代理最后调用的invoke方法就是HttpServiceMethod方法。
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
//生成 CallAdapter方法
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
Type responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw methodError(method, "'"
+ Utils.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
throw methodError(method, "HEAD method must use Void as response type.");
}
//生成转换器
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
//生成okhttpClient
okhttp3.Call.Factory callFactory = retrofit.callFactory;
//生成ServiceMethod实例并返回到
return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
}
这是生成ServiceMethod对象的方法，因为HttpServiceMethod是ServiceMethod的子类，这个方法里面生成了几个重要的参数
1. callAdapter用于对请求结果进行包装的类，它可以说是Retrofit最核心的设计，下面会进行分析
2. responseConverter用于数据解析的类，比如你可以指定想要的数据是Gson、xml、String等，它也是Retrofit的核心设计
3. callFactory实际上就是OkHttpClient对象
4. RequestFactory用于保存注解解析后的值，已经在 ServiceMethod创建出来了。
上面这四个参数中的前三个默认值在Retrofit的build方法中赋值的，这四个参数各司其职，实际上这里已经为网络请求准备好了所有的条件，这里直接看invoke方法。
@Override ReturnT invoke(Object[] args) {
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
invoke方法代码非常简单，用了适配者模式，适配者模式通常是把一种对象适配成另一种对象，或者相同对象之间的转换。这里就是把OkHttpCall对象通过callAdapter转换成接口的返回值（我们定义的是Retrofit的Call对象）并且返回。这里我们可以先去分析OkHttpCall类，通过它我们大概就知道这个适配到底是用来干什么的。
OkHttpCall
OkHttpCall是Call接口的子类，上一个步骤中创建的2、3、4参数都会传递到这里来，而Call就是我们在步骤1中定义的Call<List<Repo>>的对象，OkHttpCall里面定义了调用Okhttp进行网络请求的方法，有异步请求enqueue方法和同步请求execute方法，我们在步骤4中就是通过enqueue方法得到请求结果的，我们具体看看enqueue方法
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
//okhttp里面的Call对象
okhttp3.Call call;
Throwable failure;
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
//1.生成okhttp的Call对象
call = rawCall = createRawCall();
} catch (Throwable t) {
throwIfFatal(t);
failure = creationFailure = t;
}
}
}
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
//2.执行okhttp的请求
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
//3.得到结果
response = parseResponse(rawResponse);
} catch (Throwable e) {
throwIfFatal(e);
callFailure(e);
return;
}
try {
//4.把成功的请求结果回调出去
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
callFailure(e);
}
private void callFailure(Throwable e) {
try {
//把失败的请求结果回调出去
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
上面的代码的核心大概可以分为4部分
1. 生成okhttp3.Call对象，注意这个Call和Retrofit的Call不是同一个类，这里是把保存了注解参数的requestFactory转换成okhttp的call对象，详细的转换过程这里不分析
private okhttp3.Call createRawCall() throws IOException {
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
2. 这部分实际上是okhttp的使用，通过生成的okhttp3.Call对象进行异步的网络请求
3. 通过parseResponse方法对结果进行转换，根据你定义的返回类型解析成相应的数据类型，比如Json格式，xml格式等
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
...
try {
//通过responseConverter转换得到请求结果
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
// If the underlying source threw an exception, propagate that rather than indicating it was
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}
上面已经说到responseConverter是一个数据解析类，这里就是对请求结果进行解析的地方。
4. 把请求成功和失败的结果回调出去。
CallAdapter
到这里已经进行请求，数据已经解析，并且解析后的结果已经回调出去了，似乎不需要再处理什么了，但是这段代码里面的适配到底是做什么的呢？我们找到callAdapter的实例就能知道这个适配做了什么
@Override ReturnT invoke(Object[] args) {
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
追踪callAdapter还是来到了Retrofit的bulid方法
public Retrofit build() {
...
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
//calladapter的默认实现
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
...
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
这里面的默认实现是根据不同平台来处理的，我们之间看Android类里面的实现
@Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
if (callbackExecutor == null) throw new AssertionError();
//默认的callAdapter
ExecutorCallAdapterFactory executorFactory = new ExecutorCallAdapterFactory(callbackExecutor);
return Build.VERSION.SDK_INT >= 24
? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
: singletonList(executorFactory);
}
@Override public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
//适配者中的adapter方法，call就是OkHttpCall
@Override public Call<Object> adapt(Call<Object> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
这段代码是从callAdapterFactories获得callAdapter的方法，里面的返回值ExecutorCallbackCall就是用来适配的callAdapter对象，里面的adapt方法就是适配OkHttpCall里面的那个方法
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
//调用OkHttpCall里面的enqueue方法，取得结果
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);
}
});
}
});
}
callbackExecutor的实现类在Platform的 Android子类中，它会把结果通Handler把结果发送回主线程。callbackExecutor的默认实现如下
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
但是CallAdapter在默认情况下是用来线程切换的，但是它不仅仅是线程切换，它的适配者设计机制是可插拔的，允许不同的执行机制来执行http调用，比如转换的Rxjava的Observable, Flowable, Single, Completable , Maybe 对象，这里是现今一些流行库流行库的支持。如果官方的CallAdapter不能满足你的要求，你可以自定义一个CallAdapter，比如自定义一个LiveData类型的CallAdapter。
总结
根据上面的分析，其实Retrofit只是对okhttp的封装，Retrofit把注解的参数解析后交给okhttp去处理的，Retrofit拿到请求结果后进行数据转换，Retrofit封装的核心是CallAdapter和Converter，这两个转换可以让我们可以灵活的处理数据。
