本文分析基于retrofit:2.3.0
1、概述
Retrofit对于Android开发人员是一个较熟悉的网络请求框架，其简洁的使用方式，一度备受开发者的喜爱。我在去年年尾的时候的时候，也将Retrofit应用到新项目的开发，以取代原有的网络请求框架，不得不说Retrofit使用起来太方便了，短短的几行代码就可以搞定繁琐的网络请求。
在刚开始使用Retrofit的时候，我一度很好奇Retrofit是怎么做到如此的简洁的，如何将我们定义的接口转换为一个实际的网络请求的呢？
public interface ApiService {
@GET("json_it")
Call<String> test();
}
Retrofit retrofit = new Retrofit.Builder()
.addConverterFactory(ScalarsConverterFactory.create())
.baseUrl("http://blog.csdn.net/")
.build();
Call<String> call = retrofit.create(ApiService.class).test();
call.enqueue(new Callback<String>() {
@Override
public void onResponse(Call<String> call, Response<String> response) {
}
@Override
public void onFailure(Call<String> call, Throwable t) {
}
});1、可以配置不同HTTP client来实现网络请求，如okhttp、httpclient等；
2、支持同步、异步和RxJava
3、超级解耦等
本篇博文目标：结合源码，探究Retrofit如何将我们定义的接口转换为一个实际的网络请求的并拿到响应结果的。
预备知识：JDK动态代理、注解相关、OkHttp原理探究、Okio原理探究
如果你对以上预备知识都比较熟悉，那么你直接阅读源码将会比较轻松。
2、Retrofit整体执行流程
注意：上图只是简单的表述了Retrofit的整体流程思路，其具体的流程要比上图复杂的多。
a、JDK动态代理：
与静态代理相比较，动态代理的显著优点就是可以减少开发者自定义的Java文件的数量，因为动态代理为我们生成了所需的Java字节码文件【注意：动态代理是在运行时为我们生成Java字节码文件的，非编译时】。
JDK动态代理支持接口或类[必须实现某接口] ---- 生成的代理类是Proxy子类，同时会实现我们的接口中的所有方法，关键是我们实现的InvocationHandler，因为我们通过接口[开发者自定义的接口]调用动态代理生成的类中的方法都会被转发给InvocationHandler。这也是为什么我们仅仅定义一个接口文件就可以通过Retrofit去调用接口的原因，Retrofit的核心代码就是其实现的InvocationHandler。
Retrofit实现了自己的InvocationHandler，并在invoke方法中实现了主要的逻辑，接口方法的主要信息[注解信息、参数信息、方法名等]都包含在了Method参数中。
@Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
......}b、ServiceMethod
主要有两个方法：toRequest和toResponse。
toRequest：根据上一步得到的信息构建一个OkHttp请求；
toResponse：根据我们设置的Converter【比如scalars】返回响应信息。
c、OkHttpCall
该类是Retrofit封装的OkHttp请求类，其主要作用是根据ServiceMethod的toRequest方法生成的OkHttp Request来生成OkHttp的RealCall。同时，利用ServiceMethod的toResponse方法返回我们需要的响应信息，比如接口返回的JOSN串。很显然ServiceMethod类是OkHttpCall的工具辅助类。
d、CallAdapter
看到Call肯定就知道是和请求相关
e、Converter
将响应解析成我们需要的形式，比如如果我们使用了Scalars，则会返回给我们JSON String串.
2.1、源码解析
解析将按照如下三部分进行：
//------------------------------第一部分--------------------------------------
Retrofit retrofit = new Retrofit.Builder()
.addConverterFactory(ScalarsConverterFactory.create())
.baseUrl("http://blog.csdn.net/")
.build();
//------------------------------第二部分（主要）------------------------------
Call<String> call = retrofit.create(ApiService.class).test();
//------------------------------第三部分--------------------------------------
call.enqueue(new Callback<String>() {
@Override
public void onResponse(Call<String> call, Response<String> response) {
}
@Override
public void onFailure(Call<String> call, Throwable t) {
}
});2.1.1、第一部分（创建Retrofit）
a、new Retrofit.Builder()
Builder(Platform platform) {
this.platform = platform;
// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
}
public Builder() {
this(Platform.get());
}
b、
.addConverterFactory(ScalarsConverterFactory.create())
.baseUrl("http://blog.csdn.net/")
.build();public Retrofit build() {
if (baseUrl == null) {//必须设置baseUrl，否则抛出异常
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {//默认支持OkHttp
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();//Executor子类，稍后会看一下它的源码
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
// Make a defensive copy of the converters.
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
if (callbackExecutor == null) throw new AssertionError();
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);
}
}
}2.1.2、第二部分（主要工作部分）
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, @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);
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
invoke方法内部的代码是整个Retrofit的核心代码，我们对接口方法（比如test方法）的调用[retrofit.create(ApiService.class).test()]，实际都被转发给了InvocationHandler并最终调用了invoke方法的呀。
先解释一下上述的代码，首先判断是不是普通的Java类的动态代理调用，如果是，则直接返回method.invoke(this,args)了。否则，继续往下走。platform.isDefaultMethod这句代码不用管，因为如果是Android平台，该方法永远返回false。最核心的地方来了：
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
虽然说就这几句，但这只是表面的，因为背后还是很多代码呢
a、ServiceMethod
ServiceMethod类是OkHttpCall的工具辅助类，因为前期的准备和后期的响应解析都需要ServiceMethod完成。下面看下其构造过程：
ServiceMethod<Object, Object> serviceMethod =(ServiceMethod<Object, Object>) loadServiceMethod(method);
这行代码的主要工作的是通过Method构造一个ServiceMethod，看一下loadServiceMethod：
ServiceMethod<?, ?> loadServiceMethod(Method method) {
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder<>(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
this.methodAnnotations = method.getAnnotations();
this.parameterTypes = method.getGenericParameterTypes();
this.parameterAnnotationsArray = method.getParameterAnnotations();
}
public ServiceMethod build() {
callAdapter = createCallAdapter();
responseType = callAdapter.responseType();
......
responseConverter = createResponseConverter();
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
......
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
......
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
......
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
......
return new ServiceMethod<>(this);
}
在本例中，CallAdapter通过Retrofit的一个工厂类，最终为我们返回了一个实现的内部类：
new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};b、OkHttpCall
OkHttpCall是具体OkHttp最近的一层，因为Retrofit是通过OkHttpCall来向OkHttp发起真正的请求。该类的构造很简单：
OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
this.serviceMethod = serviceMethod;
this.args = args;
}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;
}继续看OkHttpCall之enqueue，该方法在后面会用到，此处贴出来，方便后面查看，不想看的可以略过:
@Override public void enqueue(final Callback<T> callback) {
......
okhttp3.Call call;//真正的OkHttp3.Call终于出现了
Throwable failure;
synchronized (this) {
......
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
call = rawCall = createRawCall();//关键代码
} catch (Throwable t) {
failure = creationFailure = t;
}
}
}
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
//OkHttp异步请求
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
throws IOException {
Response<T> response;
try {
response = parseResponse(rawResponse);//解析响应
} catch (Throwable e) {
callFailure(e);
return;
}
callSuccess(response);
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callFailure(Throwable e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callSuccess(Response<T> response) {
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
c、返回最终可以直接调用的Call
return serviceMethod.callAdapter.adapt(okHttpCall);new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
}; Call<String> call = retrofit.create(ApiService.class).test();
这个对象是Call的子类，有人可能就好奇了，OkHttpCall是Call的子类，怎么又来了一个Call的子类，好晕。其实Retrofit之所以提供这个子类，多了一层，完全是因为这个callbackExecutor，这个callbackExecutor是什么呢？其实就是前面提到的MainThreadExecutor，它可以从执行线程切换到UI线程。ExecutorCallBackCall就是为了在执行OkHttpCall之后，再次切回UI线程的。
2.1.3、第三部分（发送请求）
看下ExecutorCallBackCall的enqueue方法：
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
delegate.enqueue(new Callback<T>() {//这里的delegate就是okHttpCall
@Override public void onResponse(Call<T> call, final Response<T> response) {
callbackExecutor.execute(new Runnable() {//切回UI线程
@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);
}
});
}
});
}
以上可以看到，最终结果回调的时候就且回了UI线程。
完事！
扫一扫
2493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
