Retrofit这个开源库出来也有一定年头了，记得之前还是在V1.0的版本的时候，之前在三月份也写过一个Retrofit的使用简析，那会儿正是1.0向2.0过渡的时候，所以新版本老版本对比了一下！时至今日，相关文章已经层出不穷了，今天主要是打开它的源码，了解一些细节的问题！
准备工作
基于版本：
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0'
相关问题：
1、Retrofit是使用注解确定对应的请求方式和参数的，那么具体的url是怎么产生出来的的呢？
2、我们定义的是一个接口，那么Retrofit又是怎么生成对应的实现类的呢？
3、网络请求V2.0开始统一使用OkHttp了，那么异步回调到主线程是如何实现的？
4、同一个方法，支持Call<T> 的返回类型，又可以支持Observable<T>的返回类型，这个又是如何实现的？
5、同一个方法，支持不同的转换（Gson、Jackson、Moshi、FastJson等等）,这个又是如何实现的呢？
带着这些问题，我们可以更好的进行相关的源码分析
第一部分 Retrofit && ServiceMethod的创建
从Retrofit的构建方法开始说起
new Retrofit.Builder()
.baseUrl("http://10.0.60.115:60321/1.0/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.client(new OkHttpClient.Builder()
.addInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
return chain.proceed(RequestUtils.createLoginJsonRequest(chain.request()));
}
})
.addNetworkInterceptor(
new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.HEADERS))
.build())
.build()
.create(LoginApi.class);
这里就是显而易见的builder模，通过Builder去构建我们需要的一些必要数据（比如说baseUrl,callAdapter,Conver等等），接下来看看Builder里面具体做了些什么！！
调用Retrofit内部的Builder的空参数构造方法！：
public Builder() {
this(Platform.get());
}
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());
}
在这里，又去调用了Platform.get()初始化了一个Platform,并把默认的转换器BuiltInConverters初始化并加入了集合中！！
那么问题来了，这个Platform是何方神圣，具体有撒作用？？顺藤摸瓜，这里开始介绍内部的第一个神秘嘉宾！！
Platform 初始化
private static final Platform PLATFORM = findPlatform();//初始化`Platform`的静态方法
Platform字面意思就是平台啦，所以Platform相当于一个抽象类，这个类里面有对应的实现类：Android iOS Java 8对应的是各种具体平台。
private static Platform findPlatform() {
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("org.robovm.apple.foundation.NSObject");
return new IOS();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
可以看到，在调用findPlatform()方法之后就回去判断初始化对应的具体平台，具体的实现类就是上面说到的三个，Android Java iOS，你没有看错，还有iOS的(这里是用的Swift)，啧啧。。
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);
}
}
}
各个不同的平台其实就是根据不同的环境初始化不同的MainThreadExecutor,像上面的Android平台当然就是获取主线程的Handler!!这里可以看到，在初始化Platform之后，通过Platform得到的ExecutorCallAdapterFactory的工厂的Executor其实就是运行在主线程的Executor！
Builder的默认构造函数基本上讲完了！其实就是通过对应的平台构建了一个具体的Platform，通过这个Platform构建出了对应平台的主线程队列的线程池，方便后面的方法回调到主线程中！这里基本上也可以回答第三个问题了，异步怎么回调到主线程的！
添加baseUrl
public Builder baseUrl(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);
}
this.baseUrl = baseUrl;
return this;
}
这里没撒说的，就是检测一下url的格式，然后完成赋值！
addConverterFactory && addCallAdapterFactory
/** Add converter factory for serialization and deserialization of objects. */
public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
/**
* Add a call adapter factory for supporting service method return types other than {@link
* Call}.
*/
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
这里忍不住必须说两句了，这两个方法套路是完全一样——适配器模式，CallAdapter是请求Call对应的适配器，CallAdapter.Factory是创建对应CallAdapter的抽象工厂！！ Converter是解析的转换器，这里提供了三种转换场景，responseBodyConverter、requestBodyConverter、stringConverter。Converter.Factory则是Convert的抽象工厂，这样利于我们的后期扩展，比如说外国人肯定没有写对应FastJson的Covert,但是它提供了工厂的嘛，我们继承这个抽象工厂，实现出来就好了！！
RxJavaCallAdapterFactory
在RxJavaCallAdapterFactory这个工厂中，又定义了两种 ,一种是SimpleCallAdapter另外一种是ResultCallAdapter,
//SimpleCallAdapter
@Override public <R> Observable<R> adapt(Call<R> call) {
Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) //
.flatMap(new Func1<Response<R>, Observable<R>>() {
@Override public Observable<R> call(Response<R> response) {
if (response.isSuccessful()) {
return Observable.just(response.body());
}
return Observable.error(new HttpException(response));
}
});
if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;
}
//ResultCallAdapter
@Override public <R> Observable<Result<R>> adapt(Call<R> call) {
Observable<Result<R>> observable = Observable.create(new CallOnSubscribe<>(call)) //
.map(new Func1<Response<R>, Result<R>>() {
@Override public Result<R> call(Response<R> response) {
return Result.response(response);
}
}).onErrorReturn(new Func1<Throwable, Result<R>>() {
@Override public Result<R> call(Throwable throwable) {
return Result.error(throwable);
}
});
if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;
}
通俗的说其实就是根据返回值类型判断返回的Observable是否需要处理一下对应的Response！！使用flatMap()将其包装为一个新的Observable返回！！
Retrofit在创建的build()方法：
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
//添加完之后再添加一个defaultCallAdapterFactory
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);
}
//这个方法是上面提到的platform里面的方法，通过这个方法，将主线程的线程池和ExecutorCallAdapterFactory关联起来了！！
CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
if (callbackExecutor != null) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}
return DefaultCallAdapterFactory.INSTANCE;
}
到这里，Builder的创建过程分析完毕，总结起来就是创建出具体的Platform,通过具体的Platform创建出主线程的线程池，然后构建出默认的ExecutorCallAdapterFactory,另外就是添加对应的CallAdapter.Factory(比如说RxJavaCallAdapterFactory 等)和Converter.Factory!
生成接口的代理对象
build()方法创建对应的Retrofit之后就是create(Class<T> service)的方法，这里就是生成对应的接口的代理类的方法！！
@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);
}
ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
可以看到，在调用create()方法之后，是通过Proxy生成对应的动态代理！这里就很好说咯，在对应的invoke()的方法中完成具体的请求！
如果Java的动态代理不清楚或者已经忘记了的亲们，这里先简单脑补一下，代理的对应方法最后都会交给InvocationHandler这个类，并通过invoke(Object proxy, Method method, Object... args)的方法去执行相关的逻辑，这里的Method是对应具体方法的信息摘要，反射对象，里面包含了method的名称，参数类型，包括注解那些反正是应有尽有啦！这个args就是具体的方法参数了！
接下来就要注意啦，在创建好了Retrofit之后，在生成动态代理之后，咱们的请求方法还没有构建出来呢！所以呢，接下来肯定就是构建相关的请求方法咯！！
但是明确看到，在返回动态代理之前我们看到这里有一个判断validateEagerly，而且对应的Builder 对外提供了一个设置的方法！
/**
* When calling {@link #create} on the resulting {@link Retrofit} instance, eagerly validate
* the configuration of all methods in the supplied interface.
*/
public Builder validateEagerly(boolean validateEagerly) {
this.validateEagerly = validateEagerly;
return this;
}
这个方法到底是来做撒的呢？英语好的应该都看明白了！我先绕个关子不讲了！！
直接到代理的invoke()方法中，这里有两个条件判断，第一个是判断返回的类型如果就是Object，那就撒都不搞了，直接执行！
第二个判断如果这个方法是Default的，这个主要是针对java8来说得呢！所以重点还是要跳过到最下面！
ServiceMethod serviceMethod = loadServiceMethod(method);
ServiceMethod的创建
继上面说过的Platform之后，ServiceMethod是我们开始讲解的第二个类了！这里开始创建出对应的ServiceMethod对象，到这个方法里面具体看看！
ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
举个例子，比如说我们在LoginApi这个接口里面定义了两个方法：
@POST("users")//https://api.bmob.cn/1/ 注册用户
Call<UserBean> registerUser( @Body UserBean bean);
@GET("getUserInfo")//https://api.bmob.cn/1/用户登陆
Observable<Result<UserBean>> login(@QueryMap Map<String,String> map);
那么当我们执行login()方法的时候，就会创建Retrofit，并且创建这个LoginApi的动态代理，然后调用login()方法，那么这里loadServiceMethod(Method method)中的method方法就是login()这个方法的对象。然后通过ServiceMethod.Builder去构建这个具体的ServiceMethod。
//ServiceMethod.Builder的构造方法
public Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
this.methodAnnotations = method.getAnnotations();//获取方法的对应注解@retrofit2.http.POST(value=files/{fileName})
this.parameterTypes = method.getGenericParameterTypes();//获取方法参数的类型
this.parameterAnnotationsArray = method.getParameterAnnotations();//获取方法参数的注解
}
接下来重点看看ServiceMethod.Builder.builder()的构建过程！这里算是Retrofit里面比较重要的一块了吧，因为它要开始拼接url、确定返回类型、明确CallAdapter和responseConverte！
public ServiceMethod build() {
//1、获取对应的callAdapter
callAdapter = createCallAdapter();
//2、获取对应的response的类型
responseType = callAdapter.responseType();
//3、创建response的转换器
responseConverter = createResponseConverter();
for (Annotation annotation : methodAnnotations) {
//4、根据方法的注解（GET POST）开始具体的解析
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];
........
//5、解析对应的方法参数注解
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
return new ServiceMethod<>(this);
}
-
1、获取对应的callAdapter
private CallAdapter<?> createCallAdapter() { //获取返回值的Type,后面会用到 Type returnType = method.getGenericReturnType(); ...... Annotation[] annotations = method.getAnnotations(); try { //调用retrofit的方法 return retrofit.callAdapter(returnType, annotations); } catch (RuntimeException e) { // Wide exception range because factories are user code. throw methodError(e, "Unable to create call adapter for %s", returnType); } } //callAdapter()方法最终调用nextCallAdapter()来确定具体的callAdapter public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) { .... int start = adapterFactories.indexOf(skipPast) + 1; for (int i = start, count = adapterFactories.size(); i < count; i++) { //get是抽象方法，由具体的factory去实现 CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this); if (adapter != null) { return adapter; } } ..... }
前面在说Retrofit的初始化的时候，就说了默认会添加ExecutorCallAdapterFactory，如果我们添加了RxJava支持了添加一个RxJavaCallAdapterFactory的话，那我们这里就有两个CallAdapter了，那么Retrofit是如何明确到底应该使用哪个Adapter的呢？（问题四）相关的答案都在get()的方法中！我们可以看看这两个Factory里面具体的get方法是怎么处理的！
//ExecutorCallAdapterFactory中
@Override
public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
//可以处理Call的返回类型
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);
}
};
}
//RxJavaCallAdapterFactory中
@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
Class<?> rawType = getRawType(returnType);
String canonicalName = rawType.getCanonicalName();
boolean isSingle = "rx.Single".equals(canonicalName);
boolean isCompletable = "rx.Completable".equals(canonicalName);
//可以处理 Observable rx.Single rx.Completable的类型
if (rawType != Observable.class && !isSingle && !isCompletable) {
return null;
}
....
}
答案很是清晰明了啊，不同的adapter在get()中处理不同的逻辑！
- 2、获取对应的response的类型
这里的response其实就是之前的获取到的returnType在获取到的里面的具体类型，比如说returnType是Call<UserInfo>,那么这里就获取到对应的UserInfo，相关方法封装放在Utils这个工具类中滴！！
-
3、创建response的转换器
private Converter<ResponseBody, T> createResponseConverter() { Annotation[] annotations = method.getAnnotations(); try { return retrofit.responseBodyConverter(responseType, annotations); } catch (RuntimeException e) { // Wide exception range because factories are user code. throw methodError(e, "Unable to create converter for %s", responseType); } } public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast, Type type, Annotation[] annotations) { checkNotNull(type, "type == null"); checkNotNull(annotations, "annotations == null"); int start = converterFactories.indexOf(skipPast) + 1; for (int i = start, count = converterFactories.size(); i < count; i++) { Converter<ResponseBody, ?> converter = converterFactories.get(i).responseBodyConverter(type, annotations, this); if (converter != null) { //noinspection unchecked return (Converter<ResponseBody, T>) converter; } } .... }
这里其实和前面的创建CallAdapter的原理是一致的！最后调用Retrofit的responseBodyConverter()方法，最后调用nextResponseBodyConverter()的方法，这里这个行为模式就是传说中的责任链模式吧！如果添加了多个，json解析的是要放最后面的，因为它是来者不拒的了！！
- 4、根据方法的注解（GET POST）开始具体的解析
到这里就要开始解析方法上的对应注解了！
比如说下面这个Get请求：
@GET("news/before/{date}")
Observable<DailyStories> getBeforeDailyStories(@Path("date") String date);
在通过parseMethodAnnotation()方法之后，会继续执行parseHttpMethodAndPath("GET", ((GET) annotation).value(), false)的方法！
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {
parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
} else if (annotation instanceof HEAD) {
parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
if (!Void.class.equals(responseType)) {
throw methodError("HEAD method must use Void as response type.");
}
} else if (annotation instanceof PATCH) {
parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
} else if (annotation instanceof POST) {
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
} else if (annotation instanceof PUT) {
parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
} else if (annotation instanceof OPTIONS) {
parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
} else if (annotation instanceof HTTP) {
HTTP http = (HTTP) annotation;
parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
} else if (annotation instanceof retrofit2.http.Headers) {
String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
if (headersToParse.length == 0) {
throw methodError("@Headers annotation is empty.");
}
headers = parseHeaders(headersToParse);
} else if (annotation instanceof Multipart) {
if (isFormEncoded) {
throw methodError("Only one encoding annotation is allowed.");
}
isMultipart = true;
} else if (annotation instanceof FormUrlEncoded) {
if (isMultipart) {
throw methodError("Only one encoding annotation is allowed.");
}
isFormEncoded = true;
}
}
在parseHttpMethodAndPath()中进行httpMethod、hasBody、relativeUrl、relativeUrlParamNames的赋值！
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
...
this.httpMethod = httpMethod;//GET
this.hasBody = hasBody;//false
...
this.relativeUrl = value;//news/before/{date}
this.relativeUrlParamNames = parsePathParameters(value);
}
最后一个parsePathParameters()需要我们着重看一下，到这就要进行相关{date}的替换了！
static Set<String> parsePathParameters(String path) {
//static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
Matcher m = PARAM_URL_REGEX.matcher(path);
Set<String> patterns = new LinkedHashSet<>();
while (m.find()) {
patterns.add(m.group(1));
}
return patterns;
}
因为{date}这一块是需要替换成方法参数里面对应的那个具体值的，这里通过relativeUrlParamNames()的方法，先将{date}取出存入了set集合中！！方便后面根据方法上对应的参数进行替换！！
解析对应的方法参数
接下来就是解析方法对应的参数的注解了：
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
if (Utils.hasUnresolvableType(parameterType)) {
throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
parameterType);
}
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
if (parameterAnnotations == null) {
throw parameterError(p, "No Retrofit annotation found.");
}
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
这里出现了一个新的类ParameterHandler，这也是第三个需要介绍的类了！
ParameterHandler
如图所示，ParameterHandler它是一个抽象类，有这么多具体的实现小弟来管理某个具体参数！里面还有一个抽象方法apply()需要每个子类去实现的。这个方法将在后面将具体参数封装到RequestBuilder里面。在上面举例的方法：
//parameterCount=1，parameterTypes[0]=String.class
getBeforeDailyStories(@Path("date") String date)
所以最后就是执行parseParameter(0,String,Path)，并且返回的就是ParameterHandler的对象！接下来具体看内部是怎么操作的。
private ParameterHandler<?> parseParameter(
int p, Type parameterType, Annotation[] annotations) {
ParameterHandler<?> result = null;
for (Annotation annotation : annotations) {
ParameterHandler<?> annotationAction = parseParameterAnnotation(
p, parameterType, annotations, annotation);
if (annotationAction == null) {
continue;
}
if (result != null) {
throw parameterError(p, "Multiple Retrofit annotations found, only one allowed.");
}
result = annotationAction;
}
if (result == null) {
throw parameterError(p, "No Retrofit annotation found.");
}
return result;
}
这里接着去调用parseParameterAnnotation()的方法，这也是ParameterHandler具体创建的方法！
private ParameterHandler<?> parseParameterAnnotation(
int p, Type type, Annotation[] annotations, Annotation annotation) {
...
} else if (annotation instanceof Path) {
...
gotPath = true;
Path path = (Path) annotation;
String name = path.value();
validatePathName(p, name);
Converter<?, String> converter = retrofit.stringConverter(type, annotations);
//创建出对应的PathParameterHandler！！
return new ParameterHandler.Path<>(name, converter, path.encoded());
} .......
return null; // Not a Retrofit annotation.
}
这里会根据不同的类型创建不同的Convert,比如说解析Path就是使用StringConver，并且会先调用validatePathName()的方法去判断之前的Set集合里面是否有这个值，如果有，那么就创建出一个ParameterHandler.Path的对象！
同理解析Body的时候就会去调用nextRequestBodyConverter()的方法最终确认对应的Convert,就这样，最后创建出了ParameterHandler.Body这个具体的ParameterHandler对象！并且相关方法的参数的注解也解析出来并封装到了parameterHandlers数组中！
ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
到了这里，ServiceMethod的初始化完成，那么每次都去辛辛苦苦的构建这些注解和参数是不是太累了？！所以必须把它缓存起来咯！这里也是上面提出的那个validateEagerly和eagerlyValidateMethods()问题的答案：如果我们需要尽快构建出每个方法的ServiceMethod,那么就将validateEagerly设置为true就好了！
第二部分 HTTP请求 响应 转换
经过上面一系列的准备工作，接下来就是开始相关的网络请求了！回到Retrofit的代理方法中:
//上面已经创建好对应的ServiceMethod了！
ServiceMethod serviceMethod = loadServiceMethod(method);
//初始化OkHttpCall
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
//执行具体的call
return serviceMethod.callAdapter.adapt(okHttpCall);
OkHttpCall
没有记错的话，OkHttpCall是我们要介绍的第四个对象了！也是比较重要的一个对象了，OkHttpCall 实现了 Call接口，内部持有okhttp3.Call的引用，所以可以理解为它是OkHttp的Call的代理对象！
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
这里构建出一个具体的OkHttpCall的对象!然后调用了serviceMethod.callAdapter.adapt(okHttpCall)这个方法，接下来着重分析这个方法做了些什么操作！
adapt()是CallAdapter里面的抽象方法，由具体的子类实现！如果我们返回的是Call类型的，那么由上面第一部分分析，ServiceMethod这里就是是用的ExecutorCallAdapterFactory！那么到ExecutorCallAdapterFactory中看看具体的实现逻辑！！
@Override
public <R> Call<R> adapt(Call<R> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
这里又返回了一个ExecutorCallbackCall的对象！这里的callbackExecutor就是在讲初始化Platform创建的！
当我们调用具体的方法时:
login.enqueue(new Callback<UserBean>() {
@Override
public void onResponse(Call<UserBean> call, Response<UserBean> response) {
}
@Override
public void onFailure(Call<UserBean> call, Throwable t) {
}
});
其实就是调用ExecutorCallbackCall里面的对应方法咯！
@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);
}
});
}
});
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
通过上面的方法就可以完全明白为什么enqueue的方法都是在主线程上的了！！
这里的delegate就是之前传入的OkHttpCall对象，所以这里又会去执行OkHttpCall里面的enqueue()方法，绕了半天，终于又回到了OkHttpCall里面了！
@Override
public void enqueue(final Callback<T> callback) {
....
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
//如果call没有创建那么就去创建！
call = rawCall = createRawCall();
} catch (Throwable t) {
failure = creationFailure = t;
}
}
}
....
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();
}
}
});
}
这个方法有点儿长，主要是判断有木有创建okhttp3.Call，没有就去创建，创建了就调用call的call.enqueue()方法，最后再将结果通过传入的Callback回调出去！
RequestBuilder
先说okhttp3.Call的创建：
call = rawCall = createRawCall();
这里调用了OkHttpCall里面的createRawCall()方法：
private okhttp3.Call createRawCall() throws IOException {
//首先创建出okhttp3.Request
Request request = serviceMethod.toRequest(args);
//通过request构建 okhttp3.Call
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
那么从这里开始，这些任务又回到了ServiceMethod这个类中了！所以说ServiceMethod完全服务于Http请求响应的相关过程！
/** Builds an HTTP request from method arguments. */
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的类，这也是第五个需要讲解的类了！看名字都知道它就是用来构建Request的Builder啦！,构建出Builder之后，注意这次是带上具体的参数过来的，所以它会进行参数的封装，构建出最终要去请求的url!!之前有说过对应的每个参数注解已经封装到ParameterHandler这个类中了，这里就需要遍历parameterHandlers这个数组，完成对每一个参数的具体赋值，赋值其实也很简单，就是依次调用各个ParameterHandler的apply(requestBuilder, arg)方法，apply()方法其实就是调用之前构建好的Convert将对应的参数（arg）解析成Request里面具体需要的对象！里面StringConvert居多！比如之前说到的@Body的情况(第一部分的结尾)！，因为Body你也可以传入一个Bean对象，所以不一定使用的是StringConvert，这里它会通过nextRequestBodyConverter()遍历寻找合适Convert。
比如说调用了GsonRequestBodyConverter中的convert方法完成相关解析：
@Override
public RequestBody convert(T value) throws IOException {
Buffer buffer = new Buffer();
Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
JsonWriter jsonWriter = gson.newJsonWriter(writer);
adapter.write(jsonWriter, value);
jsonWriter.close();
return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}
接着就是调用requestBuilder.build()的方法了！
Request build() {
//1.构建HttpUrl
HttpUrl url;
HttpUrl.Builder urlBuilder = this.urlBuilder;
if (urlBuilder != null) {
url = urlBuilder.build();
} else {
// No query parameters triggered builder creation, just combine the relative URL and base URL.
url = baseUrl.resolve(relativeUrl);
if (url == null) {
throw new IllegalArgumentException(
"Malformed URL. Base: " + baseUrl + ", Relative: " + relativeUrl);
}
}
2.构建RequestBody
RequestBody body = this.body;
if (body == null) {
// Try to pull from one of the builders.
if (formBuilder != null) {
body = formBuilder.build();
} else if (multipartBuilder != null) {
body = multipartBuilder.build();
} else if (hasBody) {
// Body is absent, make an empty body.
body = RequestBody.create(null, new byte[0]);
}
}
MediaType contentType = this.contentType;
if (contentType != null) {
if (body != null) {
body = new ContentTypeOverridingRequestBody(body, contentType);
} else {
requestBuilder.addHeader("Content-Type", contentType.toString());
}
}
return requestBuilder
.url(url)
.method(method, body)
.build();
}
到这里Request终于是构建好了！接下来是真正的去创建okhttp3.Call了！
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
这里其实最终使用的是Retrofit里面构建的okhttp3.Call.Factory
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
Response
最后终于到结果的位置了，这个Response也是我们要介绍的第六个对象了！它算是okhttp.Response的一个装饰类吧！也是最后返回给调用者使用的类！
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
// Remove the body's source (the only stateful object) so we can pass the response along.
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
int code = rawResponse.code();
if (code < 200 || code >= 300) {
try {
// Buffer the entire body to avoid future I/O.
ResponseBody bufferedBody = Utils.buffer(rawBody);
return Response.error(bufferedBody, rawResponse);
} finally {
rawBody.close();
}
}
if (code == 204 || code == 205) {
return Response.success(null, rawResponse);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
T body = serviceMethod.toResponse(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;
}
}
无论是同步或者异步的方法，最后总会通过parseResponse()的方法将okhttp3.Response包装为Response对象返回！！而具体的解析又会交给ServiceMethod里面的的toResponse()去处理！！
T toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}
其实就是调用之前确认好的responseConverter去解析对应的Body!
到这里，http请求完成，结果也被封装为指定的对象返回了！
总结
1、Call(接口)：向服务器发送请求并返回响应的调用；
2、CallAdapter(接口)：Call的适配器，将Call适配为不同的类型返回（Call、Observable）；
3、CallBack(接口)：顾名思义Call的回调,Call执行时的回调；
4、Converter(接口)：数据转换器，将一个对象转化另外一个对象；
5、CallAdapter.Factory(接口)：CallAdapter的工厂，通过get()方法获取CallAdapter,使用adapt()执行对应的Call请求；
6、Converter.Factory(抽象类) ： 数据转换器Converter的工厂；
-
responseBodyConverter：将ResponseBody转换为具体的对象。 -
requestBodyConverter： 将对应的Body，Part和PartMap注解转换为RequestBody(OkHttp3)，以便http请求的时候使用。 -
StringConverter：将Field，FieldMap值，Header，Path，Query,和QueryMap值转化为String，以便http请求的时候使用。
7、ParameterHandler ： 方法参数的处理类；
8、ServiceMethod ：请求方法的生成处理类，用于确定CallAdapter、ResponseConverter，生成具体的请求Request,解析对应的Response数据，算是一个灰常重要的类了；
9、Platform：确认不同运行环境的类；
10、OkHttpCall ：实现Call接口，是okhttp3.Call的代理类，获取传入的Call，通过Retrofit.callFactory执行Call请求，获取数据并使用ResponseConverter进行解析；
再回到之前说的那些问题上：
1、Retrofit是使用注解确定对应的请求方式和参数的，那么具体的url是怎么产生出来的的呢？
（ServiceMethod里面的相关处理）
2、我们定义的是一个接口，那么Retrofit又是怎么生成对应的实现类的呢？
（动态代理）
3、网络请求V2.0开始统一使用OkHttp了，那么异步回调到主线程是如何实现的？
（MainThreadExecutor）
4、同一个方法，支持Call<T>的返回类型，又可以支持Observable<T>
的返回类型，这个又是如何实现的？
（确定对应CallAdapter！）
5、同一个方法，支持不同的转换（Gson、Jackson、Moshi、FastJson等等）,这个又是如何实现的呢？
（确定对应的Convert！）
搞了这么久，学习到什么呢？从一开始的一脸懵逼到最后的暗自窃喜，这也算是一种进步吧！其中不得不提的是各种设计模式的使用，模块间解耦和扩展的思想！创建型的抽象工厂模式、Builder模式；结构性的代理模式、adapter模式、装饰者模式；行为性的责任链模式等等。。
---- Edit By Joe ----
