Retrofit解析
本次源码解析基于2.9.0，如有描述错误，请大佬们评论指出。
一、Retrofit的作用
Retrofit基于okhttp，简化了okhttp请求接口的操作，而且适配Rxjava和kotlin的协程，但目前还没有适配kotlin的Flow，如果要适配，自己封装也是可以的。
先看看早期直接使用okhttp请求 构造请求+解析响应+使用okhttp的线程池执行（当然okhttp也有同步调用），一堆操作很是麻烦，如果加上loading显示/隐藏、线程切换代码会更加复杂，retrofit+rxjava的经典搭配适应潮流就出现了。
retrofit适配的返回值 支持协程的话，小伙伴可能会懵逼了，注解啥的都好说，这个都好处理，它怎么拿到方法上的suspend，其实retrofit不需要拿suspend这个修饰符，因为java压根没有suspend，编译之后显真身，suspend在kotlin看来就只是一个挂起函数标志，在编译成java字节码后偷偷摸摸多了个用于回调的接口Continuation。
先来看看retrofit用法
//就是创建我们的retrofit客户端
public class HttpManager {
private Retrofit mRetrofit;
private Map<Class<?>, Object> mMap = new HashMap<>();
private static class SingletonInstance {
private static final HttpManager INSTANCE = new HttpManager();
}
public static HttpManager getInstance() {
return SingletonInstance.INSTANCE;
}
private HttpManager() {
mRetrofit = new Retrofit.Builder()
.client(自定义的okhttpClient） //不写的话，retrofit也会默认创建
.baseUrl("https://xxxx.xxxx.cn")
.addConverterFactory(ScalarsConverterFactory.create())//转换为String对象
.addConverterFactory(GsonConverterFactory.create())//转换为Gson对象
//接口返回值适配
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
}
public <T> T create(Class<T> cls) {
if (!mMap.containsKey(cls)) {
T t = mRetrofit.create(cls);
mMap.put(cls, t);
}
return (T) mMap.get(cls);
}
}
Q: 那个Call直接可以enqueue，那个observeable在subscribe后数据就可以接收，协程挂起恢复后就直接返回了，有点厉害，咋实现？
拿简单的observable来说，我们会使用create方法创建一个Observable,然后需要自己管理数据的发射，retrofit操作的Observable估计也要自行处理数据的发射？？？是这样么？后文解释。
Q: 方法上有注解，请求参数也有注解，返参还有泛型，这个怎么处理？
方法上有注解，请求参数也有注解，拿到method后解析注解，这个不难，拿到这些注解后，构建Request，如果是post的话，还要构造RequestBody，要注明MediaType，返回值是Call、Observable等决定是走默认的还是rxjava，或者协程，返回值上的泛型也很关键，在okhttp的rawResponse拿到后，要解析响应,需要预先选择合适的解析器解析数据。
二、从Retrofit+Observable请求post接口熟悉流程
2.1、post请求编写
这里没有为协程专门搞个什么CallAdapterFactory哦，因为协程走默认的DefaultCallAdapterFactory。 这个默认的在创建Retrofit对象时添加进去的。
2.2、 retrofit的创建--->Retrofit的build方法
public Retrofit build() {
.....
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) { //没有就默认可以给你创建OkhttpClient
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) { //回调的线程池，安卓默认就是主线程切换
callbackExecutor = new MainThreadExecutor();
}
//添加默认的 new DefaultCallAdapterFactory(callbackExecutor)
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(new DefaultCallAdapterFactory(callbackExecutor)
List<Converter.Factory> converterFactories = new ArrayList<>( 1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
//添加一些默认的转换器
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
converterFactories.addAll(new OptionalConverterFactory());
return new Retrofit(....);
}
//android的回调的主线程池
static final class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(Runnable r) {
handler.post(r);
}
}
如果没看retrofit的build方法，在debug时，发现我们明明只添加了两个转换器和一个RxjavaCallAdapter，为啥会多出来一些不认识的转换器，那是因为retrofit在创建时，偷偷摸摸给你添加了一些默认的。多贴心呐。 记住：callFactory就是OkHttpClient。
2.3、 经典retrofit的动态代理---->create方法
create方法的返回值是我们自定义的Api接口对象，所以可以直接调用Api的方法---废话。
InvocationHandler的invoke方法的返回值是Object，Api接口类里面方法的返回值可能是Call、Observable、Object，采用Object做返回值就都可以支持了。
来看看loadServiceMethod
private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
//用一个支持并发安全的Map缓存Method了
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) { //首次请求，肯定都会先去解析注解
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
返回值是个ServiceMethod，他的子类有好几个。 其中以Rxjava和Call方式请求都是返回的CallAdapted.
协程返回的是SuspendForBody或者SuspendForResponse.
来看看parseAnnotations
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//先创建RequestFactory，然后创建HttpServiceMethod
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
........
返回值是Void以及不能解析的返回值类型判断
.....
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
2.4、 RequestFactory创建---->解析方法注解以及方法参数
很关键的RequestFactory.parseAnnotations(...)返回RequestFactory，它里面含有太多信息
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
return new Builder(retrofit, method).build();
}
//方法参数处理器数组
ParameterHandler<?>[] parameterHandlers
RequestFactory build() {
for (Annotation annotation : methodAnnotations) {
//解析方法上的注解
parseMethodAnnotation(annotation);
}
//hasBody isFormEncoded relativeUrl isFormEncoded isMultipart gotPart
//那我们的post这里肯定是有body的哈，不是表单提交，这里不是很重要的细节，不写
......
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
parameterHandlers[p] =
//解析参数
parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
}
.....
return new RequestFactory(this);
}
来看看解析方法上的注解parseMethodAnnotation(annotation)
这里就以例子@POST("app/courses/behaviour")参考，解析方法上的注解获取请求方式以及短路径
private void parseMethodAnnotation(Annotation annotation) {
//判断方法上注解的类型 DELETE GET HEAD PATCH PUT OPTIONS HTTP POST retrofit2.http.Headers
//Multipart FormUrlEncoded)
//这里只保留POST
if (annotation instanceof DELETE) {
....
} else if (annotation instanceof POST) {
//这里就是处理这个 @POST("app/courses/behaviour")
this.httpMethod ="POST";
this.hasBody = true;
String value=((POST) annotation).value();
if (value.isEmpty()) {
return;
}
.......
//保存短路径
this.relativeUrl = value;
this.relativeUrlParamNames = parsePathParameters(value);
}
......
}
来看解析方法参数--->parseParameter
先讲讲我们的Body类
fun getCourse(@Body info: CourseInfo): Observable 参数用@Body注解，设计了ParameterHandler这个类 这里拎出Body这个类，它要构造RequestBody，需选择xxxRequestBodyConverter才能构建成功。
private @Nullable ParameterHandler<?> parseParameter(....) {
ParameterHandler<?> result = null;
if (annotations != null) {
for (Annotation annotation : annotations) {
ParameterHandler<?> annotationAction =
//解析方法参数的注解
parseParameterAnnotation(p, parameterType, annotations, annotation);
.......
result = annotationAction;
}
}
if (result == null) {
if (allowContinuation) {
try { //判断是不是走协程，使用Continuation.class类判断
//这个判断有点粗糙
if (Utils.getRawType(parameterType) == Continuation.class) {
isKotlinSuspendFunction = true;
return null;
}
} catch (NoClassDefFoundError ignored) {
}
}
.....
}
return result;
}
上面👆就解释了，Retrofit怎么判断是走协程的，是通过判断参数里面有没有一个Continuation类型，是的话，就走协程。下面在参数里面添加了Continuation，但是我希望他走Rxjava，但不幸的事，它认为应该走协程，那就奔溃了。后文解释。 方来了，这个parseParameterAnnotation方法有400+行，一个方法400+行呐。但我们只看需要的 这里以注解是Field和Body为例。
@Nullable
private ParameterHandler<?> parseParameterAnnotation(
int p, Type type, Annotation[] annotations, Annotation annotation) {
//annotation instanceof Url/Path/Query/QueryName/QueryMap/Header/HeaderMap等太多，删除
//以Field和Body类讲解
if (annotation instanceof Url) {
.....
} else if (annotation instanceof Field) {
.....
//省略部分逻辑
Converter<?, String> converter = retrofit.stringConverter(type, annotations);
return new ParameterHandler.Field<>(name, converter, encoded);
} else if (annotation instanceof Body) {
//body类型 肯定就不是表单类型了
......
Converter<?, RequestBody> converter;
converter = retrofit.requestBodyConverter(type, annotations, methodAnnotations);
//requestBody转换器存在于请求参数处理器中
return new ParameterHandler.Body<>(method, p, converter);
}
return null; // Not a Retrofit annotation.
}
Field注解： 来看看retrofit.stringConverter(type, annotations)方法
请求url（baseUrl+relativeUrl拼接）、头字段的处理
Request.Builder get() {
HttpUrl url;
HttpUrl.Builder urlBuilder = this.urlBuilder;
if (urlBuilder != null) {
url = urlBuilder.build();
} else {
url = baseUrl.resolve(relativeUrl);
}
RequestBody body = this.body;
......
MediaType contentType = this.contentType;
if (contentType != null) {
if (body != null) {
body = new ContentTypeOverridingRequestBody(body, contentType);
} else {
headersBuilder.add("Content-Type", contentType.toString());
}
}
return requestBuilder.url(url).headers(headersBuilder.build()).method(method, body);
}
解析okhttp3的rawResponse为Retrofit的Response
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
int code = rawResponse.code();
if (code < 200 || code >= 300) {
try {
// 使用okio读取的
ResponseBody bufferedBody = Utils.buffer(rawBody);
return Response.error(bufferedBody, rawResponse);
} finally {
rawBody.close();
}
}
if (code == 204 || code == 205) {
rawBody.close();
return Response.success(null, rawResponse);
}
ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
try {
//之前保存的响应体转换器去转换ResponseBody
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
catchingBody.throwIfCaught();
throw e;
}
}
Q: 协程请求的接口方法声明上没有Call，它是怎么选择DefaultCallAdapterFactory的呢？
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method) {
//先创建RequestFactory
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction; //true
......
Annotation[] annotations = method.getAnnotations();
Type adapterType;
if (isKotlinSuspendFunction) {
Type[] parameterTypes = method.getGenericParameterTypes();
//找那个Continuation<？super ExtendItem>参数，取的是ExtendItem的下界
Type responseType = Utils.getParameterLowerBound(0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
.....
//获取返回值的类型，，这里偷偷摸摸加东西了，Call.class-->看来要走DefaultCallAdapterFactory
adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
//而且给方法注解加多一个SkipCallbackExecutor类型的注解
annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
} else {
adapterType = method.getGenericReturnType();
}
//创建CallAdapter 区分是走默认的还是Rxjava那一套
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method, adapterType, annotations);
//校验响应类型是不是okhttp的Response，是的话直接throw Exception
//检验响应类型是不是retrofit的Response，是的话，没带泛型，直接throw Exception
//校验请求如果是head请求且返回值是Void类型，不满足的就直接throw Exception
.....
//创建转换器
Converter<ResponseBody, ResponseT> responseConverter = createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
//非协程的部分
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
//协程的返回值是Response<XXX>类型
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForResponse<>(requestFactory, callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
//协程的返回值是xxx类型-->我们这里就是ExtendItem类型，所以走这里
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForBody<>(requestFactory, callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter, continuationBodyNullable);
}
}
requestFactory.isKotlinSuspendFunction在创建RequestFactory时，走协程的话会设置为true。
上面依次创建requestFactory、callAdapter，响应转换器responseConverter，最后创建SuspendForBody(HttpServiceMethod的子类)。--->callFactory就是OkhttpClient。
这个地方细节有点多，suspend编译之后，参数加了个Continuation，但是CallAdapter只有2种，协程走的是默认的DefaultCallAdapterFactory，而且为了不跟retrofit的Call请求方式起冲突了，偷偷摸摸的在我们代码里面下毒了。
Type adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
Annotation[] annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
Utils.ParameterizedTypeImpl就是ParameterizedType的子类，这里rawType就是Call，responseType就是ExtendItem
static final class ParameterizedTypeImpl implements ParameterizedType {
.....
ParameterizedTypeImpl(@Nullable Type ownerType, Type rawType, Type... typeArguments) {
this.ownerType = ownerType;
this.rawType = rawType;
this.typeArguments = typeArguments.clone();
}
@Override
public Type getRawType() {
return rawType;
}
.......
}
从Contiuation参数上获取到响应类型是ExtendItem类型，然后再经过封装，将响应类型的getRawType返回Call，这点很关键，这下就决定能走DefaultCallAdapterFactory了。
再来看看ensurePrensent方法：偷偷摸摸给方法加上一个新的注解SkipCallbackExecutor返回，然后给CallAdapter创建使用。贴心呐。
SkipCallbackExecutor 表示跳过线程切换到主线程，协程才不用Retrofit的主线程切换MainThreadExecutor，是用户通过协程调度器实现。
最后，我们看看suspend实际处理的样子： 创建callAdapter 之前也讲过的
看看DefaultCallAdapterFactory的get方法，有用到SkipCallbackExecutor注解。 看那个getRawType(returnType)，只要是Call.class就能返回非null的CallAdapter，所以Retrofit封装响应类型的rawType为Call是有用的。
同时基于SkipCallbackExecutor注解的判断，导致CallAdapter的adapt方法直接将入参的call原样返回了。
响应体的转换器准备
private final List<Converter.Factory> converterFactories = new ArrayList<>();
private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
前面讲过的，他会尝试converFactories，我们这里是ExtendItem类型，那么它的转换器，只可能是GsonResponseBodyConverter了
Retrofit的java代码跟协程代码融合的地方-->SuspendForBody的invoke方法
final @Nullable Object invoke(Object[] args) {
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
//之前SuspendForBody的CallAdapter啥事没干，入参是Retrofit中的Call，因没有处理线程切换的操作，返参还是Retrofit中的Call，看后面的图哈。
Call<ResponseT> call = callAdapter.adapt(call, args)
Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];
try {
return isNullable ? KotlinExtensions.awaitNullable(call, continuation)
: KotlinExtensions.await(call, continuation);
} catch (Exception e) {
return KotlinExtensions.suspendAndThrow(e, continuation);
}
}
Retrofit的call创建好后，因我们的返回值是ExtendItem，不是可空的，所以就丢给KotlinExtensions.await方法，开始协程处理。
suspend fun <T : Any> Call<T>.await(): T {
//支持可取消的协程
return suspendCancellableCoroutine { continuation ->
continuation.invokeOnCancellation {
//取消接口请求
cancel()
}
//走okhttp的异步接口请求
enqueue(object : Callback<T> {
override fun onResponse(call: Call<T>, response: Response<T>) {
if (response.isSuccessful) {
val body = response.body()
if (body == null) {
val invocation = call.request().tag(Invocation::class.java)!!
val method = invocation.method()
val e = KotlinNullPointerException("Response from " +method.declaringClass.name + '.' +method.name +" was null but response body type was declared as non-null")
continuation.resumeWithException(e)
} else {
continuation.resume(body)
}
} else {
continuation.resumeWithException(HttpException(response))
}
}
override fun onFailure(call: Call<T>, t: Throwable) {
continuation.resumeWithException(t)
}
})
}
}
从java调用转到kotlin调用，java的第一个参数是Call，这里是Call的拓展方法await，然后java第二个参数，给suspendCancellableCoroutine接收，这个await方法就是回调转成挂起函数的经典模板。这个模板代码一行都没精简过哈。
Q: 那协程请求完后切换到主线程在哪里执行的呢？
看代码，关注下lifecycleScope的launch是否有主线程调度器，
val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
get() = lifecycle.coroutineScope
val Lifecycle.coroutineScope: LifecycleCoroutineScope
get() {
while (true) {
val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl?
if (existing != null) {
return existing
}
val newScope = LifecycleCoroutineScopeImpl( this,
//协程上下文在这里
SupervisorJob() + Dispatchers.Main.immediate)
if (mInternalScopeRef.compareAndSet(null, newScope)) {
newScope.register()
return newScope
}
}
}
协程上下文：SupervisorJob() + Dispatchers.Main.immediate，从这里看出他是个Supervisor，主从作用域，它取消了，不会影响父协程，非常的可以。
调度器是这个Dispatchers.Main.immediate，还能说啥，协程的调度通过协程拦截器拦截Continuation实现。
kotlin的代码debug不好整，大家大致看下。
五、后续
我们看到用retrofit+协程写个接口请求，还要显式的try catch，真的是，有点，哎，看后续Retrofit支持Kotlin的Flow不，不支持的话，可以考虑自己整个试试。
