Android中Retrofit2框架源码解析
一、Retrofit简介
1、阐述
Retrofit是一个基于Restful的HTTP网络请求框架(实际上内部真正网络请求是交由OkHttp去实现的),换句话说Retrofit实际上是一个负责网络请求接口的封装。
2、功能
基于OkHttp遵循RestfulAPI设计风格
通过注解配置网络请求参数
支持同步(execute)和异步(enqueue)请求
支持多种数据的解析(Gson,Json,XML,Protobuf)
支持RxJava和Kotlin协程(近期加入)
支持多平台,包括有Android、Java8、Guava、Scala等
3、优点
功能强大,支持同步和异步,支持多种数据解析序列化格式、支持RxJava和Kotlin协程
简洁易用,通过注解配置网络请求参数,采用了大量设计模式简化使用
扩展性好,通过动态代理模式实现高度解耦。
4、注意
- Retrofit是一个Restful的HTTP网络请求框架的封装,因其本质是委托OkHttp去实现网络请求的,而Retrofit仅仅负责网络请求接口的封装。

APP应用通过Retrofit框架发起网络请求,实际上先利用Retrofit接口层(通过注解)封装请求参数,然后通过解析注解信息获取请求参数信息,组装这些请求参数(包括请求方式Header、 Url等),将这些组装后的参数按照OkHttp请求的规则,委托给OkHttp去完成真正的网络请求。
最后在服务端返回响应数据后,OkHttp把原始数据交由Retrofit, Retrofit通过开始设置的解析器来解析返回的数据。
5、与其他网络库的对比

二、Retrofit基本使用
1、添加必要的gradle依赖
由于Retrofit网络框架是把请求的实现委托给OkHttp框架实现的,所以需要加了OkHttp的库依赖
implementation 'com.squareup.retrofit2:retrofit:2.5.0'
implementation 'com.squareup.okhttp3:okhttp:3.13.1'
2、定义一个网络请求的接口,方法带请求注解
注意: API的声明定义必须是以接口形式注册的,此外这个接口有一些特殊要求,这个接口不能继承其他的接口。否则内部会抛出非法异常,Retrofit将 Http请求 抽象成 Java接口:采用 注解 描述网络请求参数 和配置网络请求参数
interface AccountApi {//请求API必须以接口形式定义且这个接口不能继承其他的接口
@FormUrlEncoded
@POST(value = "v1/api/login")
fun createLogin(@Field(value = "username")username: String, @Field(value = "password") password: String): Call<UserWrapper>
}
3、请求注解说明

注意: 网络请求的注解类型主要分为三种:
1、网络请求方式的注解

@GET、@POST、@PUT、@DELETE、@HEAD、@PATH、@OPTIONS、@HTTP 分别对应着HTTP中的请求方式: GET、POST、PUT、DELETE、HEAD、PATH、OPTIONS(HTTP中还有TRACE、CONNECT请求方式未提供支持)
此外,其中的@HTTP注解是一个特殊的注解,支持全链路URL请求,可以支持配置method、path(可以为全链路链接)、hasBody的三个注解参数,可以定制化满足需求。
//一种特殊方式,使得在Retrofit中DELETE请求方式支持Body @HTTP(method = "DELETE", path = "test/test/test", hasBody = true) fun cancelLike(@Body map: Map<String, String>): Call<JsonElement>
2、标记注解

@FormUrlEncoded
: 表示发送form-encoded的数据,每个key-value需要使用@Field
来注解key.@Multipart
: 表示发送form-encoded的数(适用于文件上传的接口)3、请求参数注解

4、创建Retrofit实例
fun getClient(baseUrl: String): Retrofit {
return Retrofit.Builder()
.baseUrl(baseUrl)//配置baseUrl,一般为restful api的前缀URL
.addConverterFactory(GsonConveterFactory.create())//配置数据解析器
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())//配置是否使用RxJavaCallAdapterFactory,如果不配置默认会使用DeafultCallAdapterFactory
.build()
}
通过
addCoverterFactory
方法配置数据格式解析器.目前可支持: Gson、JackSon、XML、Protobuf、Moshi、Scalas等通过网络请求适配器,目前可支持: Guava(GuavaCallAdapterFactory)、RxJava(RxJavaCallAdapterFactory)、RxJava2、Scala、Java8、Kotlin以及默认的CallAdapter
5、创建网络接口实例
val accountApi: AccountApi = getClient(BASE_ACCOUNT_URL).create(AccountApi::class.java)
6、调用接口实例方法,对发送的请求进行封装,拿到Call实例
val okHttpCall: Call<UserWrapper> = accountApi.createLogin("mikyou", "123456")
7、执行发送网络请求(异步call.enqueue & 同步call.execute)
//发送异步请求
okHttpCall.enqueue(object: Callback<UserWrapper> {
override fun onResponse(call: Call<UserWrapper>, asyncRes: Response<UserWrapper>) {
println("异步请求的数据: ${asyncRes.body()?.toString()}")
}
override fun onFailure(call: Call<UserWrapper>, t: Throwable) {
//handle error
}
}
//发送同步请求
val syncRes = okHttpCall.execute()
三、Retrofit本质流程
一般从网络通信过程如下图:
- 其实Retrofit的本质和上面是一样的套路
- 只是Retrofit通过使用大量的设计模式进行功能模块的解耦,使得上面的过程进行得更加简单 & 流畅
实际上,Retrofit也是类似这样的流程:
四、Retrofit源码分析
大致流程:

1、Retrofit使用例子
//1、定义Github Service API
public interface Github {
@GET("/repos/{owner}/{repo}/contributors")
Call<List<Contributor>> contributors(@Path("owner") String owner, @Path("repo") String repo);
}
public static void main(String[] args) {
//2、创建Retrofit实例
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
//配置CallAdapterFactory
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
//配置CoverterAdapterFactory数据解析器
.addConverterFactory(GsonConverterFactory.create())
.build();
//3、调用retrofit.create创建Github实例(内部借助动态代理生成代理类来创建代理类实例对象)
Github github = retrofit.create(Github.class);
//4、调用代理类请求API的方法,返回一个Call实例,实际上返回的一个是OkHttpCall实例
Call<List<Contributor>> call = github.contributors("square", "retrofit");
//5、最后调用Call的enqueue方法进行异步请求,如果是同步请求就调用Call的execute方法;实际上就是对应调用OkHttpCall的enqueue方法或execute方法
call.enqueue(new Callback<List<Contributor>>() {
@Override
public void onResponse(Call<List<Contributor>> call, Response<List<Contributor>> response) {
List<Contributor> contributors = response.body();
if (contributors != null) {
for (Contributor contributor : contributors) {
System.out.println(contributor.login + " (" + contributor.contributions + ")");
}
}
}
@Override
public void onFailure(Call<List<Contributor>> call, Throwable t){
//handle on error
}
});
//同步请求
Response<List<Contributor>> response = call.execute();
}
2、定义一个API对应的抽象Service接口
抽象接口类似Restful API风格,使用注解方式配置请求方式、请求URL、请求参数、Path等
public interface GitHub {
@GET("/repos/{owner}/{repo}/contributors")
Call<List<Contributor>> contributors(@Path("owner") String owner, @Path("repo") String repo);
}
3、然后,创建Retrofit实例,通过一个Retrofit内部的Builder来配置全局请求的参数
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(API_URL)//指定baseUrl
.client(new OkhttpClient())//外部指定自定义的OkHttpClient,作用和callFactory方法一致,client方法内部就是委托给callFactory方法
.callFactory(new OkHttpClient())//外部指定callFactory,若外部没有指定默认创建OkHttpClient实例
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.build();
4、然后,进入Retrofit的Builder内部类中的build方法
public Retrofit build() {
//baseUrl不能为null
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//外部设置okhttp3.Call.Factory
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
//默认创建一个OkHttpClient实例
callFactory = new OkHttpClient();
}
//callbackExecutor数据回调执行器,用于线程的切换
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
//如果外部没有单独指定,会根据当前Platform来指定默认的回调执行器
//默认在Android平台指定的是MainThreadExecutor,实际上就是通过主线程Handler来实现线程的切换
callbackExecutor = platform.defaultCallbackExecutor();
}
//初始化CallAdapter.Factory的集合
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
//默认加入一个Platform默认的DefaultCallAdapterFactory,并把回调执行器传入,用于调用时的线程切换
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
//初始化CallAdapter.Factory的集合
List<Converter.Factory> converterFactories = new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
converterFactories.add(new BuiltInConverters());
//加入外部指定数据解析器工厂类
converterFactories.addAll(this.converterFactories);
//加入Platform默认的数据解析工厂对象
converterFactories.addAll(platform.defaultConverterFactories());
//最后创建Retrofit实例,并传入callFactory(OkHttpClient)、baseUrl、converterFactories、callAdapterFactories、callbackExecutor、validateEagerly
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
5、创建好Retrofit
实例,调用其create
方法,通过动态代理+反射实例化出API接口实例Github
//外部调用
Github github = retrofit.create(Github.class);
//create方法源码实现
public <T> T create(final Class<T> service) {
//1、验证外部API接口定义
validateServiceInterface(service);
//利用Proxy.newProxyInstance动态代理生成一个对应API接口类的代理类实例Github并返回
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 @Nullable
Object invoke(Object proxy, Method method,
@Nullable Object[] args) throws Throwable {
//注意: 由动态代理原理可知,代理类实例Github的代理方法每次调用执行,都是通过触发InvocationHandler中的invoke方法来执行的,
//比如github.contributors("square", "retrofit");返回一个Call实例就是通过当前invoke方法中的loadServiceMethod(method).invoke(args != null ? args : emptyArgs);返回的。
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);
}
});
}
//Retrofit#validateServiceInterface,验证外部API接口定义
private void validateServiceInterface(Class<?> service) {
//API接口定义必须是一个interface,否则抛出异常
if (!service.isInterface()) {
throw new IllegalArgumentException("API declarations must be interfaces.");
}
Deque<Class<?>> check = new ArrayDeque<>(1);
check.add(service);
while (!check.isEmpty()) {
Class<?> candidate = check.removeFirst();
//检查API接口类,不能带有泛型参数,如果泛型参数列表长度大于0就抛出异常
if (candidate.getTypeParameters().length != 0) {
StringBuilder message = new StringBuilder("Type parameters are unsupported on ")
.append(candidate.getName());
if (candidate != service) {
message.append(" which is an interface of ")
.append(service.getName());
}
throw new IllegalArgumentException(message.toString());
}
Collections.addAll(check, candidate.getInterfaces());
}
if (validateEagerly) {
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
loadServiceMethod(method);
}
}
}
}
6、通过动态代理Proxy.newProxyInstance
得到了代理接口类Github
实例github
,然后只要调用API接口的方法contributors
就能拿到一个Call
实例
GitHub github = retrofit.create(GitHub.class);//得到了代理接口类Github实例
//只要调用API接口的方法传入相应的请求参数,就能拿到一个Call实例
Call<List<Contributor>> call = github.contributors("square", "retrofit");
//由动态代理原理可知,代理类实例Github的代理方法contributors每次调用执行,都是通过触发InvocationHandler中的invoke方法来执行的,所以触发执行InvocationHandler中的invoke
//InvocationHandler#invoke方法
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//github.contributors("square", "retrofit")获取Call是通过调用Retrofit中的loadServiceMethod(method)方法返回实例ServiceMethod的invoke()返回的
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
7、深入Retrofit中的loadServiceMethod
,传入的参数是method
,它是Github
接口中定义的抽象接口方法contributors
的Method对象实例。
//Github#contributors方法
@GET("/repos/{owner}/{repo}/contributors")
Call<List<Contributor>> contributors(@Path("owner") String owner, @Path("repo") String repo);
//Retrofit#loadServiceMethos方法,通过Method拿到对应的解析注解信息的ServiceMethod
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
//首先会去serviceMethodCache缓存ConcurrentHashMap中的查,如果缓存中存在就直接返回method对应的ServiceMethod
if (result != null) return result;
synchronized (serviceMethodCache) {
//同步锁检查,可能会存在A线程正在解析并存入缓存中,此时B线程再次进入的时候,按道理可以直接在缓存中获取就可以了,所以还需要到serviceMethodCache中重新检查一次
result = serviceMethodCache.get(method);
//如果还是没有,所以需要执行ServiceMethod.parseAnnotations解析代理类接口方法中注解信息,比如请求方式、请求参数、Path等,然后解析注解信息后就会parseAnnotations转化成ServiceMethod
if (result == null) {
result = ServiceMethod.parseAnnotations(this, method);
//然后再将解析后的ServiceMethod存入缓存serviceMethodCache中
serviceMethodCache.put(method, result);
}
}
return result;
}
8、深入ServiceMethod
中的parseAnnotations
方法,传入接口代理方法Method对象以及Retrofit
实例,返回一个ServiceMethod
实例对象,实际上最后返回的是一个HttpServiceMethod
对象实例。
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//通过RequestFactory的parseAnnotations解析返回一个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);
}
//返回值泛型类型不能为Void,否则抛出异常
if (returnType == void.class) {
throw methodError(method, "Service methods cannot return void.");
}
//最后调用 HttpServiceMethod中的parseAnnotations,传入retrofit、method以及创建好的RequestFactory对象实际上最后返回的是一个HttpServiceMethod实例(ServiceMethod子类实例对象)
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
9、深入RequestFactory
类中的parseAnnotations
方法,然后返回一个RequestFactory
对象,并把从Method注解解析到的httpMethod、relativeUrl
等信息
final class RequestFactory {
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
return new Builder(retrofit, method).build();//通过RequestFactory的内部类Builder的build方法创建RequestFactory,传入retrofit实例和接口方法的Method对象
}
private final Method method;
private final HttpUrl baseUrl;
final String httpMethod;
private final @Nullable String relativeUrl;
private final @Nullable Headers headers;
private final @Nullable MediaType contentType;
private final boolean hasBody;
private final boolean isFormEncoded;
private final boolean isMultipart;
private final ParameterHandler<?>[] parameterHandlers;
final boolean isKotlinSuspendFunction;
RequestFactory(Builder builder) {
method = builder.method;
baseUrl = builder.retrofit.baseUrl;
httpMethod = builder.httpMethod;
relativeUrl = builder.relativeUrl;
headers = builder.headers;
contentType = builder.contentType;
hasBody = builder.hasBody;
isFormEncoded = builder.isFormEncoded;
isMultipart = builder.isMultipart;
parameterHandlers = builder.parameterHandlers;
isKotlinSuspendFunction = builder.isKotlinSuspendFunction;
}
...
}
//RequestFactory#Builder#build 方法返回一个RequestFactory
RequestFactory build() {
//遍历方法中所有的methodAnnotations数组
for (Annotation annotation : methodAnnotations) {
//调用parseMethodAnnotation解析每一个注解
parseMethodAnnotation(annotation);
}
if (httpMethod == null) {
throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
}
if (!hasBody) {
if (isMultipart) {
throw methodError(method,
"Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
}
if (isFormEncoded) {
throw methodError(method, "FormUrlEncoded can only be specified on HTTP methods with "
+ "request body (e.g., @POST).");
}
}
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);
}
if (relativeUrl == null && !gotUrl) {
throw methodError(method, "Missing either @%s URL or @Url parameter.", httpMethod);
}
if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
throw methodError(method, "Non-body HTTP method cannot contain @Body.");
}
if (isFormEncoded && !gotField) {
throw methodError(method, "Form-encoded method must contain at least one @Field.");
}
if (isMultipart && !gotPart) {
throw methodError(method, "Multipart method must contain at least one @Part.");
}
return new RequestFactory(this);//创建一个RequestFactory的对象并返回
}
//RequestFactory#parseMethodAnnotation解析方法Method对象中的注解
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {//解析HTTP中的DELETE注解和Path
parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {//解析HTTP中的GET注解和Path
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
} else if (annotation instanceof HEAD) {//解析HTTP中的HEAD注解和Path
parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
} else if (annotation instanceof PATCH) {//解析HTTP中的PATCH注解和Path
parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
} else if (annotation instanceof POST) {//解析HTTP中的POST注解和Path
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
} else if (annotation instanceof PUT) {//解析HTTP中的PUT注解和Path
parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
} else if (annotation instanceof OPTIONS) {//解析HTTP中的OPTIONS注解和Path
parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
} else if (annotation instanceof HTTP) {//解析HTTP中的HTTP注解和Path
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(method, "@Headers annotation is empty.");
}
headers = parseHeaders(headersToParse);//解析HTTP中设置的Headers
} else if (annotation instanceof Multipart) {
if (isFormEncoded) {
throw methodError(method, "Only one encoding annotation is allowed.");
}
isMultipart = true;
} else if (annotation instanceof FormUrlEncoded) {
if (isMultipart) {
throw methodError(method, "Only one encoding annotation is allowed.");
}
isFormEncoded = true;
}
}
//RequestFactory#parseHttpMethodAndPath解析方法Method和Path
private void (String httpMethod, String value, boolean hasBody) {
if (this.httpMethod != null) {
throw methodError(method, "Only one HTTP method is allowed. Found: %s and %s.",
this.httpMethod, httpMethod);
}
this.httpMethod = httpMethod;//初始化请求方式httpMethod
this.hasBody = hasBody;//初始化是否含有Body
if (value.isEmpty()) {
return;
}
//如果相对URL存在query,比如repos/{owner}/{repo}/contributors?query=xxx
int question = value.indexOf('?');
if (question != -1 && question < value.length() - 1) {
// 确保相对URL中不存在命名参数如果存在就抛出异常
String queryParams = value.substring(question + 1);
Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
if (queryParamMatcher.find()) {
throw methodError(method, "URL query string \"%s\" must not have replace block. "
+ "For dynamic query parameters use @Query.", queryParams);
}
}
this.relativeUrl = value;//通过注解解析可以拿到部分相对URL来初始化relativeUrl
this.relativeUrlParamNames = parsePathParameters(value);
}
//parsePathParameters解析path中的请求参数名
static Set<String> parsePathParameters(String path) {
Matcher m = PARAM_URL_REGEX.matcher(path);
Set<String> patterns = new LinkedHashSet<>();
while (m.find()) {
patterns.add(m.group(1));
}
return patterns;
}
10、拿到RequestFactory
对象后,回到parseAnnotations
中的HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory)
,深入HttpServiceMethod
中的parseAnnotations
方法,最后实际上返回一个CallAdapted
对象(HttpServiceMethod
的子类)
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;//是否是Kotlin中的suspend函数
boolean continuationWantsResponse = false;
boolean continuationBodyNullable = false;
Annotation[] annotations = method.getAnnotations();
Type adapterType;
if (isKotlinSuspendFunction) {
//... kotlin suspend function暂不做分析
} else {
//拿到Method对象返回值类型作为adapterType,adapterType用于筛选对应CallAdapterFactory并返回CallAdapter,
adapterType = method.getGenericReturnType();
}
//关键点一:通过adapterType调用createCallAdapter方法获得对应method的CallAdapter,如果返回值类型是Observable那么CallAdapter就是来自RxJavaCallAdapterFactory的ResponseCallAdapter;如果是Call那么CallAdapter就是默认的DefaultCallAdapterFactory的CallAdapter
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method, adapterType, annotations);
//通过callAdapter拿到responseType
Type responseType = callAdapter.responseType();
...
//关键点二: 然后利用responseType调用createResponseConverter方法拿到对应的Coverter数据解析器对象
Converter<ResponseBody, ResponseT> responseConverter = createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;//拿到callFacrtory这里一般就是OkHttpClient对象
if (!isKotlinSuspendFunction) {//如果不是kotlin中的suspend函数
//会返回一个CallAdapted对象,CallAdapted是一个HttpServiceMethod的子类,传入requestFactory,callFactory、reponseConverter、callAdapter
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>) new SuspendForResponse<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>) new SuspendForBody<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
}
//CallAdapted是一个HttpServiceMethod的子类,内部有adapt核心方法
static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
private final CallAdapter<ResponseT, ReturnT> callAdapter;
CallAdapted(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
Converter<ResponseBody, ResponseT> responseConverter,
CallAdapter<ResponseT, ReturnT> callAdapter) {
super(requestFactory, callFactory, responseConverter);
this.callAdapter = callAdapter;
}
@Override
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
//关键点三: 外部调用CallAdapted的方法,实际上最后调用各自CallAdapter的adapt方法,传入的call就是OkHttpCall对象
return callAdapter.adapt(call);
}
}
关键点一: 通过createCallAdapter
方法传入adapterType
来筛选找到对应的CallAdapterFactory
并返回对应CallAdapter
//关键点一:通过adapterType调用createCallAdapter方法获得对应method的CallAdapter,如果返回值类型是Observable那么CallAdapter就是来自RxJavaCallAdapterFactory的ResponseCallAdapter;如果是Call那么CallAdapter就是默认的DefaultCallAdapterFactory的CallAdapter
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method, adapterType, annotations);
//createCallAdapter
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
try {
//内部调用Retrofit中的callAdapter方法,传入returnType和annotations来确定使用哪个CallAdapterFactory
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create call adapter for %s", returnType);
}
}
然后,深入Retrofit
中的callAdapter
方法
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);//内部再调用nextCallAdapter获取对应的CallAdapter
}
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
Objects.requireNonNull(returnType, "returnType == null");
Objects.requireNonNull(annotations, "annotations == null");
int start = callAdapterFactories.indexOf(skipPast) + 1;
//遍历callAdapterFactories集合,通过Retrofit创建addCallAdapterFactory最终都会添加到这个集合中
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
//然后调用callAdapterFactories集合中所有的CallAdapterFactory的get方法,如果符合条件的就会返回adapter实例,如果不符合直接返回null,进行下一个CallAdapterFactory的get调用,直到找到第一个符合条件的CallAdapterFactory,并返回它对应的CallAdapter
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
//没找到抛出异常
...
}
关键点二: 利用responseType
调用createResponseConverter
方法拿到对应的Coverter
数据解析器对象
//关键点二: 然后利用responseType调用createResponseConverter方法拿到对应的Coverter数据解析器对象
Converter<ResponseBody, ResponseT> responseConverter = createResponseConverter(retrofit, method, responseType);
//createResponseConverter
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
//内部调用Retrofit中的responseBodyConverter方法,传入responseType和annotations来确定使用哪个Converter数据解析器对象
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create converter for %s", responseType);
}
}
然后,深入Retrofit
中的responseBodyConverter
方法
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);//内部再调用nextResponseBodyConverter获取对应的CallAdapter
}
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
@Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
Objects.requireNonNull(type, "type == null");
Objects.requireNonNull(annotations, "annotations == null");
int start = converterFactories.indexOf(skipPast) + 1;
//遍历converterFactories集合,通过Retrofit创建addCoverterFactory最终都会添加到这个集合中
for (int i = start, count = converterFactories.size(); i < count; i++) {
//然后调用converterFactories集合中所有的CoverterFactory的responseBodyConverter方法,如果符合条件的就会返回Converter实例,如果不符合直接返回null,进行下一个CoverterFactory的responseBodyConverter调用,直到找到第一个符合条件的Converter,并返回它对应的Converter
Converter<ResponseBody, ?> converter = converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<ResponseBody, T>) converter;
}
}
//没找到抛出异常
...
}