Retrofit 2.9.0

1 Retrofit

1.1 retrofit介绍

A type-safe HTTP client for Android and Java. 一个安全类型的http请求的客户端。

底层网络请求是基于okhttp，retrofit对其进行了封装，提供了方便高效的网络访问框架

1.2 Retrofit 使用

1.2.1 简单使用

class RetrofitActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)//初始化一个Retrofit对象val retrofit = Retrofit.Builder().baseUrl("https://api.github.com/").addConverterFactory(GsonConverterFactory.create()).build()//创建出GitHubApiService对象val service = retrofit.create(ApiService::class.java)//返回一个 Call 对象val repos = service.listRepos("octocat")//调用 enqueue 方法在回调方法里处理结果repos.enqueue(object : Callback<List<Repo>?> {override fun onFailure(call: Call<List<Repo>?>, t: Throwable) {t.printStackTrace()}override fun onResponse(call: Call<List<Repo>?>, response: Response<List<Repo>?>) {"response.code() = ${response.code()}".logE()}})}
}//自己定义的 API 请求接口
interface ApiService {@GET("users/{user}/repos")fun listRepos(@Path("user") user: String?): Call<List<Repo>>
}

1.2.2 封装使用

public class RetrofitHelper {private Retrofit retrofit;private static RetrofitHelper instance = null;final static String ROOT_URL = "http://xxxxx/";public RetrofitHelper() {//解决handshake failed问题ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.COMPATIBLE_TLS).tlsVersions(TlsVersion.TLS_1_2, TlsVersion.TLS_1_1, TlsVersion.TLS_1_0).allEnabledCipherSuites().build();//解决在Android5.0版本以下https无法访问ConnectionSpec spec1 = new ConnectionSpec.Builder(ConnectionSpec.CLEARTEXT).build();//兼容http接口OkHttpClient.Builder httpClient = new OkHttpClient.Builder().connectTimeout(60, TimeUnit.SECONDS)//设置超时时间.readTimeout(60,TimeUnit.SECONDS);httpClient.connectionSpecs(Arrays.asList(spec,spec1));retrofit = new Retrofit.Builder().baseUrl(ROOT_URL).client(httpClient.build()).addConverterFactory(GsonConverterFactory.create(new GsonBuilder().create())).addCallAdapterFactory(RxJava2CallAdapterFactory.create()).build();}public static RetrofitHelper getInstance() {if (instance == null){instance = new RetrofitHelper();}return instance;}public RetrofitService getServer(){return retrofit.create(RetrofitService.class);//创建service对象}}

public interface RetrofitService {@Headers("Content-Type:application/json;charset=UTF-8")@POST("GpsData/getHotMapDate")Observable<List<HotMapInfo>> getHisHotMapDateData(@Body RequestBody requestbody);//...
}

public class DataManager {private static DataManager instance;private RetrofitService retrofitService;public DataManager(){this.retrofitService = RetrofitHelper.getInstance().getServer();}public static DataManager getInstance(){if(instance==null){instance = new DataManager();}return instance;}public Observable<List<HotMapInfo>> getHisHotMapDateData(RequestBody requestbody){return retrofitService.getHisHotMapDateData(requestbody);}
}

使用：

                         DataManager.getInstance().getHisHotMapDateData(requestBody).subscribeOn(Schedulers.io()).observeOn(Schedulers.io()).subscribe(pointFutureInfos -> {//获取数据}, throwable -> {//获取异常});

2 主要类

Retrofit：总揽全局一个类，一些配置，需要通过内部 Builder 类构建，比如CallAdapter、Converter等
ApiService：自定义API接口，通过 Retrofit 的 create 方法进行实例化
Call：Retrofit 的 Call，是执行网络请求的是一个顶层接口，具体实现类实际是一个 OkHttpCall
Callback：请求结果回调

2.1 Retrofit

Retrofit 主要属性：

//Retrofit.java
public final class Retrofit {// 根据接口中的方法名，存储方法对应的 Service 对象。//这里的方法指的就是代理接口对象（ApiService）中定义的方法,ServiceMethod就是接口方法对应的解析信息private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();// 网络请求器的工厂，用来生成网络请求器，默认使用的OkHttp，实为OkHttpClientfinal okhttp3.Call.Factory callFactory;// 请求的url地址等信息，包括scheme、username、password、host、port、path、query、fragment等信息final HttpUrl baseUrl;// 数据转换器的工厂的集合，存储数据转换器工厂，来生成数据转换器final List<Converter.Factory> converterFactories;final int defaultConverterFactoriesSize;// 网络请求适配器工厂的集合，存放请求适配器工厂，来生成请求适配器final List<CallAdapter.Factory> callAdapterFactories;final int defaultCallAdapterFactoriesSize;// 回调方法执行器，在 Android 上默认是封装了 handler 的 MainThreadExecutor, // 默认作用是：切换线程（子线程 -> 主线程）final @Nullable Executor callbackExecutor;// 是否提前创建 ServiceMethod 缓存的开关，如果为true，则在调retrofit.create(MovieService.class);// 的时候就会生成 ServiceMethod 并添加到缓存里面，如果为false，则在调用方法获取call的时候才会生成 ServiceMethod 并添加到缓存里面。final boolean validateEagerly;}

Retrofit 的主要属性如上，他们是由 Retrofit 的内部类 Builder 来生成的，在调用 Builder 的 build() 时，会创建 Retrofit 对象。

使用 new Retrofit.Builder() 创建一个Builder对象：

//Builder.javapublic static final class Builder {private @Nullable okhttp3.Call.Factory callFactory;private @Nullable HttpUrl baseUrl;//内置转换器工厂private final List<Converter.Factory> converterFactories = new ArrayList<>();private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();private @Nullable Executor callbackExecutor;private boolean validateEagerly;Builder(Retrofit retrofit) {callFactory = retrofit.callFactory;baseUrl = retrofit.baseUrl;// Do not add the default BuiltIntConverters and platform-aware converters added by build().for (int i = 1,size =retrofit.converterFactories.size()- Platform.get().createDefaultConverterFactories().size();i < size;i++) {converterFactories.add(retrofit.converterFactories.get(i));}// Do not add the default, platform-aware call adapters added by build().for (int i = 0,size =retrofit.callAdapterFactories.size() - retrofit.defaultCallAdapterFactoriesSize;i < size;i++) {callAdapterFactories.add(retrofit.callAdapterFactories.get(i));}callbackExecutor = retrofit.callbackExecutor;validateEagerly = retrofit.validateEagerly;}public Retrofit build() {if (baseUrl == null) {throw new IllegalStateException("Base URL required.");}//获取平台信息Platform platform = Platform.get();// 设置网络请求工厂，如果没有设置，就使用OkHttpClient作为网络请求工厂okhttp3.Call.Factory callFactory = this.callFactory;if (callFactory == null) {callFactory = new OkHttpClient();}// 设置回调方法执行器，如果没有指定，就使用Android 平台指定的执行器（也就是回调到主线程）Executor callbackExecutor = this.callbackExecutor;if (callbackExecutor == null) {callbackExecutor = platform.defaultCallbackExecutor();}// 获取自定义设置的请求适配器工厂集合（这里是通过 addCallAdapterFactory 添加的），添加到 adapterFactories ，// 然后再把 platform 设置的平台默认网络请求适配器工厂也加入 callAdapterFactoriesList<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);List<? extends CallAdapter.Factory> defaultCallAdapterFactories =platform.createDefaultCallAdapterFactories(callbackExecutor);callAdapterFactories.addAll(defaultCallAdapterFactories);// 获取自定义设置的数据转换器工厂集合（这里是通过addConverterFactory 添加的），// 添加到 converterFactories，注意此时在创建 Builder 的时候已经把内置的转换器工厂添加进去List<? extends Converter.Factory> defaultConverterFactories =platform.createDefaultConverterFactories();int defaultConverterFactoriesSize = defaultConverterFactories.size();List<Converter.Factory> converterFactories =new ArrayList<>(1 + this.converterFactories.size() + defaultConverterFactoriesSize);converterFactories.add(new BuiltInConverters());converterFactories.addAll(this.converterFactories);converterFactories.addAll(defaultConverterFactories);// 调用Retrofit 的构造方法创建 Retrofit。需要注意的是 validateEagerly 默认是false的，// 也就是不提前缓存ServiceMethod。return new Retrofit(callFactory,baseUrl,unmodifiableList(converterFactories),defaultConverterFactoriesSize,unmodifiableList(callAdapterFactories),defaultCallAdapterFactories.size(),callbackExecutor,validateEagerly);}}

//Platform.java
abstract class Platform {private static final Platform PLATFORM = createPlatform();static Platform get() {return PLATFORM;}private static Platform createPlatform() {switch (System.getProperty("java.vm.name")) {case "Dalvik":if (Android24.isSupported()) {return new Android24();}return new Android21();case "RoboVM":return new RoboVm();default:if (Java16.isSupported()) {return new Java16();}if (Java14.isSupported()) {return new Java14();}return new Java8();}}
}

这里返回的平台时 Android21 或者 Android24 (7.0以上)

//Platform.java@IgnoreJRERequirement // Only used on Android API 24+@TargetApi(24)private static final class Android24 extends Platform {static boolean isSupported() {return Build.VERSION.SDK_INT >= 24;}private @Nullable Constructor<Lookup> lookupConstructor;// 获取 Android 平台默认的callback 回调处理器，这里返回的是MainThreadExecutor// MainThreadExecutor 是 Android 的一个静态内部类，里面初始化了 主线程的 Handler// 也就是最后收到服务器响应以后切换到主线程处理消息。@OverrideExecutor defaultCallbackExecutor() {return MainThreadExecutor.INSTANCE;}// 获取默认的请求适配器工厂，这里使用的 DefaultCallAdapterFactory。用于在执行异步请求时候在适配器中生成的Executor 中执行。// Retrofit 支持的六种请求适配器，分别为：DefaultCallAdapterFactory/(Rxjava1/2/3)/Guava/java8@OverrideList<? extends CallAdapter.Factory> createDefaultCallAdapterFactories(@Nullable Executor callbackExecutor) {return asList(new CompletableFutureCallAdapterFactory(),new DefaultCallAdapterFactory(callbackExecutor));}@Nullable@Overridepublic Object invokeDefaultMethod(Method method, Class<?> declaringClass, Object proxy, Object... args) throws Throwable {if (Build.VERSION.SDK_INT < 26) {throw new UnsupportedOperationException("Calling default methods on API 24 and 25 is not supported");}Constructor<Lookup> lookupConstructor = this.lookupConstructor;if (lookupConstructor == null) {lookupConstructor = Lookup.class.getDeclaredConstructor(Class.class, int.class);lookupConstructor.setAccessible(true);this.lookupConstructor = lookupConstructor;}return lookupConstructor.newInstance(declaringClass, -1 /* trusted */).unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);}}private static final class MainThreadExecutor implements Executor {static final Executor INSTANCE = new MainThreadExecutor();private final Handler handler = new Handler(Looper.getMainLooper());@Overridepublic void execute(Runnable r) {handler.post(r);}}

Retrofit 支持的五种请求适配器 + 社区提供的请求适配器：

2.2 Call

Call 是调用代理接口的方法返回的对象。

public interface Call<T> extends Cloneable {//同步发送请求并返回响应Response<T> execute() throws IOException;//异步发送请求并通知 {@code callback} 其响应或是否发生错误与服务器通信、创建请求或处理响应void enqueue(Callback<T> callback);//如果调用 execute 或者 enqueue 则返回 trueboolean isExecuted();void cancel();boolean isCanceled();Call<T> clone();//原始HTTP请求Request request();//返回跨越整个调用的超时时间：解析 DNS、连接、写入请求正文、服务器处理和读取响应正文。//如果调用需要重定向或重试，则所有调用都必须在一个超时期限内完成。Timeout timeout();
}

3 源码分析

        //创建接口代理对象对象val service = retrofit.create(ApiService::class.java)//返回一个 Call 对象val repos = service.listRepos("octocat")//调用 Call.enqueue 方法在回调方法里处理结果repos.enqueue(object : Callback<List<Repo>?> {override fun onFailure(call: Call<List<Repo>?>, t: Throwable) {t.printStackTrace()}override fun onResponse(call: Call<List<Repo>?>, response: Response<List<Repo>?>) {"response.code() = ${response.code()}".logE()}})

3.1 创建接口代理对象

使用 Retrofit.create(ApiService::class.java) 返回一个接口代理对象

//Retrofit.javapublic <T> T create(final Class<T> service) {//1. 验证自定义的ApiService是一个接口，且不是泛型接口。并且会判断是否进行方法的提前验证，为了更好把错误暴露给编译期validateServiceInterface(service);//2. 动态代理来返回 ApiService 的实例return (T)Proxy.newProxyInstance(service.getClassLoader(),new Class<?>[] {service},//ApiService的字节码对象，也是我们要代理的具体接口new InvocationHandler() {private final Object[] emptyArgs = new Object[0];@Overridepublic @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)throws Throwable {// 因为有代理类的生成，默认继承Object类，如果是Object即可直接调用if (method.getDeclaringClass() == Object.class) {return method.invoke(this, args);}args = args != null ? args : emptyArgs;Platform platform = Platform.get();//如果是默认方法(比如java8)，就执行platform的默认方法//否则执行loadServiceMethod.invokereturn platform.isDefaultMethod(method)? platform.invokeDefaultMethod(method, service, proxy, args): loadServiceMethod(method).invoke(args);//最后是调用了HttpServiceMethod.invoke()}});}

InvocationHandler 的 invoke 拦截到方法、参数。再解析注解，去拼接成一个正常的OkHttp请求，然后执行。

动态指的是运行期，而代理指的是实现了ApiService接口的具体类，实现了接口的方法。

loadServiceMethod.invoke是Retrofit的最关键代码，也是分析的重点入口

3.1.1 loadServiceMethod（Method）

先查看 loadServiceMethod（method） 方法返回的数据（若不是kotlin协程，则返回CallAdapted，实为HttpServiceMethod的静态内部类；否则返回强制转换成 HttpServiceMethod 类型的的 SuspendForResponse或SuspendForBody）

//Retrofit.javaprivate final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();ServiceMethod<?> loadServiceMethod(Method method) {//1. 先从缓存找ServiceMethod<?> result = serviceMethodCache.get(method);if (result != null) return result;synchronized (serviceMethodCache) {//2. 获取锁后能获取到ServiceMethod对象，则直接加入缓存result = serviceMethodCache.get(method);if (result == null) {//3. 通过ServiceMethod.parseAnnotations(this, method)创建一个ServiceMethod对象（具体是HttpServiceMethod类型）result = ServiceMethod.parseAnnotations(this, method);//4. 将新创建的ServiceMethod存入缓存（Method-ServiceMethod）serviceMethodCache.put(method, result);}}return result;}

ServiceMethod.parseAnnotations

//ServiceMethod.parseAnnotations
abstract class ServiceMethod<T> {static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {//1. 通过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);}if (returnType == void.class) {throw methodError(method, "Service methods cannot return void.");}//2. 将1中获得的RequestFactory传入 HttpServiceMethod.parseAnnotations，返回的是HttpServiceMethod类型的对象return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);}abstract @Nullable T invoke(Object[] args);
}

1、RequestFactory.parseAnnotations

RequestFactory.parseAnnotations：获得代理接口的方法中的方法注解、方法参数注解并解析，将解析后的信息包装成RequestFactory类型返回

//RequestFactory
final class RequestFactory {static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {//Builder是RequestFactory的静态内部类return new Builder(retrofit, method).build();}
}

 static final class Builder {    Builder(Retrofit retrofit, Method method) {this.retrofit = retrofit;this.method = method;//反射获得方法的注解信息this.methodAnnotations = method.getAnnotations();//反射获得参数类型信息this.parameterTypes = method.getGenericParameterTypes();//反射获得方法参数中的注解信息this.parameterAnnotationsArray = method.getParameterAnnotations();}RequestFactory build() {// 解析 方法 中的所有注解，主要处理请求类型、Headers、Multipart、FormUrlEncoded等注解类型for (Annotation annotation : methodAnnotations) {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;// 为方法中的每个参数创建一个ParameterHandler<?>对象并解析每个参数使用的注解类型// 该对象的创建过程就是对 方法参数 中注解进行解析// 这里的注解包括：Body、PartMap、Part、FieldMap、Field、Header、QueryMap、Query、Path、Url 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.");}//返回 RequestFactory(Builder builder)return new RequestFactory(this);}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);} 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(method, "@Headers annotation is empty.");}headers = parseHeaders(headersToParse);} 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(Builder builder): 将上面解析到的信息包装成 RequestFactory 返回RequestFactory(Builder builder) {//请求方法method = builder.method;// 请求的baseUrlbaseUrl = builder.retrofit.baseUrl;// http 请求类型httpMethod = builder.httpMethod;// 相对地址，和 baseUrl一起构成完整请求地，格式为 baseUrl+relativeUrlrelativeUrl = builder.relativeUrl;// 请求的请求头信息headers = builder.headers;// 请求类型contentType = builder.contentType;// 是否有 bodyhasBody = builder.hasBody;// form表单类型isFormEncoded = builder.isFormEncoded;// 是否是上传文件isMultipart = builder.isMultipart;      // 参数处理器parameterHandlers = builder.parameterHandlers;      //是否是kotlin协程（挂起函数）isKotlinSuspendFunction = builder.isKotlinSuspendFunction;}

2、HttpServiceMethod.parseAnnotations

HttpServiceMethod.parseAnnotations：检查接口方法上的注解，封装HttpServiceMethod返回

//HttpServiceMethod.parseAnnotations
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {/***检查接口方法上的注解，以构建可重用的 HTTP 服务方法。这需要潜在的昂贵反射，因此最好只构建一次服务方法并重用它。*/static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;boolean continuationWantsResponse = false;boolean continuationBodyNullable = false;//获取方法注解Annotation[] annotations = method.getAnnotations();Type adapterType;if (isKotlinSuspendFunction) {//获取参数类型Type[] parameterTypes = method.getGenericParameterTypes();Type responseType =Utils.getParameterLowerBound(0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {// 从 Response<T> 解析实际正文类型responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);continuationWantsResponse = true;} else {}adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);} else {adapterType = method.getGenericReturnType();}//创建请求适配器//HttpServiceMethod.invoke 实际调用的是callAdapter.adapt方法CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);//在遍历converterFactories时会根据 **responseType**来找到对应的内容转换器。Type responseType = callAdapter.responseType();if (responseType == okhttp3.Response.class) {throw methodError(method,"'"+ getRawType(responseType).getName()+ "' is not a valid response body type. Did you mean ResponseBody?");}if (responseType == Response.class) {throw methodError(method, "Response must include generic type (e.g., Response<String>)");}// TODO support Unit for Kotlin?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);//1. okhttp3.Call.Factory类型的callFactoryokhttp3.Call.Factory callFactory = retrofit.callFactory;if (!isKotlinSuspendFunction) {//2. 如果不是kotlin的挂起函数，返回的是CallAdaptedreturn 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);}}//...
}

最终可得，如果不是kotlin的挂起函数，返回的是CallAdapted，否则返回的是强制转换成 HttpServiceMethod 类型的的 SuspendForResponse或SuspendForBody

其实CallAdapted、SuspendForResponse、SuspendForBody都为 HttpServiceMethod 的静态内部类

3.1.2 HttpServiceMethod.invoke

//HttpServiceMethodfinal @Nullable ReturnT invoke(Object[] args) {//将解析到的注解信息传入 OkHttpCall 的构造函数Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);//在不使用Kotlin协程的情况下，其实调用的是子类CallAdapted.adaptreturn adapt(call, args);}protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);

//HttpServiceMethod.java//CallAdapted为HttpServiceMethod的静态内部类（非kotlin协程则调用CallAdapted.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;}@Overrideprotected ReturnT adapt(Call<ResponseT> call, Object[] args) {return callAdapter.adapt(call);}}

这里的callAdapter由HttpServiceMethod.parseAnnotations创建

//HttpServiceMethod.javastatic <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {//callAdapter由createCallAdapter创建CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);            }//createCallAdapterprivate static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {try {//noinspection uncheckedreturn (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方法获取

//Retrofitpublic CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {return nextCallAdapter(null, returnType, annotations);}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;for (int i = start, count = callAdapterFactories.size(); i < count; i++) {CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);if (adapter != null) {return adapter;}}
//没找到则抛异常}

callAdapter实为Retrofir属性中的网络请求适配器工厂callAdapterFactories获取到匹配到条件（返回类型、注解）的callAdapter

Retrofit初始化callAdapterFactories

//Retrofit的构造方法List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);List<? extends CallAdapter.Factory> defaultCallAdapterFactories =platform.createDefaultCallAdapterFactories(callbackExecutor);callAdapterFactories.addAll(defaultCallAdapterFactories);

//Platform.javaList<? extends CallAdapter.Factory> createDefaultCallAdapterFactories(@Nullable Executor callbackExecutor) {return asList(new CompletableFutureCallAdapterFactory(),new DefaultCallAdapterFactory(callbackExecutor));}

Retrofit初始化callAdapterFactories实为DefaultCallAdapterFactory（Executor callbackExecutor）

Executor callbackExecutor：回调方法执行器，如果不设置的话，Android 平台默认的callback 回调处理器，这里返回的是MainThreadExecutor
MainThreadExecutor 是 Android 的一个静态内部类，里面初始化了主线程的 Handler，也就是最后收到服务器响应以后切换到主线程处理消息

final class DefaultCallAdapterFactory extends CallAdapter.Factory {private final @Nullable Executor callbackExecutor;DefaultCallAdapterFactory(@Nullable Executor callbackExecutor) {this.callbackExecutor = callbackExecutor;}@Overridepublic @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {if (getRawType(returnType) != Call.class) {return null;}if (!(returnType instanceof ParameterizedType)) {throw new IllegalArgumentException("Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");}final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);final Executor executor =Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)? null: callbackExecutor;return new CallAdapter<Object, Call<?>>() {@Overridepublic Type responseType() {return responseType;}@Overridepublic Call<Object> adapt(Call<Object> call) {//此时这里的call为OkHttpCall//如果executor为空返回传入的Call，不为空返回ExecutorCallbackCallreturn executor == null ? call : new ExecutorCallbackCall<>(executor, call);}};}
}

//DefaultCallAdapterFactory.java
//ExecutorCallbackCall 是 DefaultCallAdapterFactory 的静态内部类static final class ExecutorCallbackCall<T> implements Call<T> {final Executor callbackExecutor;final Call<T> delegate;ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {this.callbackExecutor = callbackExecutor;this.delegate = delegate;}//ExecutorCallbackCall.enqueue 实为 call.enqueue(即OkHttpCall.enqueue)@Overridepublic void enqueue(final Callback<T> callback) {Objects.requireNonNull(callback, "callback == null");delegate.enqueue(new Callback<T>() {@Overridepublic void onResponse(Call<T> call, final Response<T> response) {callbackExecutor.execute(() -> {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);}});}@Overridepublic void onFailure(Call<T> call, final Throwable t) {callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));}});}

此时已经明显看出 HttpServiceMethod.invoke 返回的实际上就是封装后的 OkHttpCall

3.2 OkHttpCall.enqueue

处理异步请求。只是通过异步线程和callback做了一个异步调用的封装，最终逻辑还是会调用到execute()同步请求

其中都是调用了OkHttp.enqueue和execute，这里面的细节（责任链，任务队列，连接池）由OkHttp的源码解析可知细节。

final class OkHttpCall<T> implements Call<T> {@Overridepublic void enqueue(final Callback<T> callback) {Objects.requireNonNull(callback, "callback == null");//1. 声明一个 okhttp3.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 {//2. 调用createRawCall()创建 okhttp3.Call 对象（实为OkHttpClient）call = rawCall = createRawCall();} catch (Throwable t) {throwIfFatal(t);failure = creationFailure = t;}}}if (failure != null) {callback.onFailure(this, failure);return;}if (canceled) {call.cancel();}//3. 调用 okhttp3.Call.enqueue 进行真正的网络请求call.enqueue(new okhttp3.Callback() {@Overridepublic void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {Response<T> response;try {//4. parseResponse解析响应response = parseResponse(rawResponse);} catch (Throwable e) {throwIfFatal(e);callFailure(e);return;}try {//5.成功的回调callback.onResponse(OkHttpCall.this, response);} catch (Throwable t) {throwIfFatal(t);t.printStackTrace(); // TODO this is not great}}@Overridepublic void onFailure(okhttp3.Call call, IOException e) {callFailure(e);}private void callFailure(Throwable e) {try {//6. 失败的回调callback.onFailure(OkHttpCall.this, e);} catch (Throwable t) {throwIfFatal(t);t.printStackTrace(); // TODO this is not great}}});}}

//OkHttpCallprivate okhttp3.Call createRawCall() throws IOException {// okhttp3.Call.Factory(OKhttpClient)类型的 callFactory 创建的 okhttp3.Call//即调用OkHttpClient.newCall(Request):即requestFactory.create(args)返回的为Requestokhttp3.Call call = callFactory.newCall(requestFactory.create(args));if (call == null) {throw new NullPointerException("Call.Factory returned null.");}return call;}OkHttpCall(RequestFactory requestFactory,Object[] args,//callFactory是创造方法传入的okhttp3.Call.Factory callFactory,Converter<ResponseBody, T> responseConverter) {this.requestFactory = requestFactory;this.args = args;this.callFactory = callFactory;this.responseConverter = responseConverter;}

//OkHttpClientoverride fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)

OkHttpClient是OkHttp核心管理类，所有内部逻辑和对象归OkHttpClient统一管理，由Builder构造器生成。就是OkHttp封装的网络请求（拦截器责任链）

RealCall：OkHttp 的应用层和网络层之间的桥梁。负责请求的调度（同步走当前线程发送请求，异步使用OkHttp内部的线程池进行），同时负责构造内部逻辑责任链，并执行责任链相关逻辑，知道获取结果。虽然OkHttpClient师整个OkHttp的核心管理类，但是真正发出请求并且组织逻辑的师RealCall类，它同时肩负了调度和责任链组织的两大重任。

这些内容为OkHttp的网络请求细节。

3.3 内容转换器（解析响应结果）Gson

我们的响应结果是如何通过 Gson 直接解析成数据模型的？

.addConverterFactory(GsonConverterFactory.create(new GsonBuilder().create()))

内容转换器

//Retrofit.javapublic Builder addConverterFactory(Converter.Factory factory) {converterFactories.add(checkNotNull(factory, "factory == null"));return this;}

//OkHttpCall.java
//解析响应数据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) {rawBody.close();return Response.success(null, rawResponse);}ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);try {//1 通过 responseConverter.convert 转换 ResponseBodyT body = responseConverter.convert(catchingBody);return Response.success(body, rawResponse);} catch (RuntimeException e) {catchingBody.throwIfCaught();throw e;}}

//OkHttpCall.javaprivate final Converter<ResponseBody, T> responseConverter;OkHttpCall(RequestFactory requestFactory,Object[] args,okhttp3.Call.Factory callFactory,Converter<ResponseBody, T> responseConverter) {this.requestFactory = requestFactory;this.args = args;this.callFactory = callFactory;//内容转换器由OkHttpCall的构造函数得到this.responseConverter = responseConverter;}

OkHttpCall的responseConverter是HttpServiceMethod的responseConverter属性传入的

HttpServiceMethod的responseConverter是在 HttpServiceMethod.parseAnnotations 方法初始化的

//HttpServiceMethod.parseAnnotations//创建内容转换器Converter<ResponseBody, ResponseT> responseConverter =createResponseConverter(retrofit, method, responseType);

//HttpServiceMethod.javaprivate static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(Retrofit retrofit, Method method, Type responseType) {Annotation[] annotations = method.getAnnotations();try {//返回 retrofit.responseBodyConverter(responseType, annotations)return retrofit.responseBodyConverter(responseType, annotations);} catch (RuntimeException e) { throw methodError(method, e, "Unable to create converter for %s", responseType);}}

//Retrofit.javapublic <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {return nextResponseBodyConverter(null, type, annotations);}

  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;for (int i = start, count = converterFactories.size(); i < count; i++) {//遍历内容转换器工厂，找到匹配的（类型及注解）内容转换器Converter<ResponseBody, ?> converter =converterFactories.get(i).responseBodyConverter(type, annotations, this);if (converter != null) {//noinspection uncheckedreturn (Converter<ResponseBody, T>) converter;}}//没找到则抛出异常}

是怎么找到GsonConverterFactory来调用 Gson 的 convert方法的呢？在遍历converterFactories时会根据 responseType来找到对应的转换器。

我们代码初始化Retrofit的时候会把我们添加的Gson转换器加入到Retrofir的内容转换器工厂。

//Retrofit的构造方法// 获取自定义设置的数据转换器工厂集合（这里是通过addConverterFactory 添加的），// 添加到 converterFactories，注意此时在创建 Builder 的时候已经把内置的转换器工厂添加进去//1.如果是 Java8 就是一个 OptionalConverterFactory 的转换器否则就是一个空的List<? extends Converter.Factory> defaultConverterFactories =platform.createDefaultConverterFactories();int defaultConverterFactoriesSize = defaultConverterFactories.size();//2. 初始化converterFactoriesList<Converter.Factory> converterFactories =new ArrayList<>(1 + this.converterFactories.size() + defaultConverterFactoriesSize);//3.添加默认的构建的转换器，其实是 StreamingResponseBodyConverter 和 BufferingResponseBodyConverterconverterFactories.add(new BuiltInConverters());//4.自定义的转化器（即通过addConverterFactory 添加的）converterFactories.addAll(this.converterFactories);converterFactories.addAll(defaultConverterFactories);

3.4 请求适配器 Rxjava

我们写的API接口时如何支持Rxjava的？

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

//Retrofit.java
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {callAdapterFactories.add(checkNotNull(factory, "factory == null"));return this;}

OkHttpCall的responseConverter是HttpServiceMethod的responseConverter属性传入的

HttpServiceMethod的responseConverter是在 HttpServiceMethod.parseAnnotations 方法初始化的

//HttpServiceMethod.parseAnnotations//创建请求适配器CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);//1. okhttp3.Call.Factory类型的callFactoryokhttp3.Call.Factory callFactory = retrofit.callFactory;if (!isKotlinSuspendFunction) {//2. 如果不是kotlin的挂起函数，返回的是CallAdaptedreturn new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);}

//HttpServiceMethod.javaprivate static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {try {//noinspection uncheckedreturn (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.javapublic CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {return nextCallAdapter(null, returnType, annotations);}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;for (int i = start, count = callAdapterFactories.size(); i < count; i++) {CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);if (adapter != null) {return adapter;}}//没找到抛异常}

遍历 callAdapterFactories 根据 returnType类型 来找到对应的 CallAdapter 返回

比如：我们在 GitHubApiService 的 returnType 类型为 Single，那么返回的就是 RxJava2CallAdapterFactory 所获取的 CallAdapter

interface GitHubApiService {@GET("users/{user}/repos")fun listReposRx(@Path("user") user: String?): Single<Repo>
}

RxJava2CallAdapterFactory的 get方法

  @Override public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {Class<?> rawType = getRawType(returnType);if (rawType == Completable.class) {// Completable is not parameterized (which is what the rest of this method deals with) so it// can only be created with a single configuration.return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,false, true);}

  @Override public Object adapt(Call<R> call) {//1. 把 Call 包装成一个 Observable 对象Observable<Response<R>> responseObservable = isAsync? new CallEnqueueObservable<>(call): new CallExecuteObservable<>(call);Observable<?> observable;if (isResult) {observable = new ResultObservable<>(responseObservable);} else if (isBody) {observable = new BodyObservable<>(responseObservable);} else {observable = responseObservable;}if (scheduler != null) {observable = observable.subscribeOn(scheduler);}if (isFlowable) {return observable.toFlowable(BackpressureStrategy.LATEST);}if (isSingle) {return observable.singleOrError();}if (isMaybe) {return observable.singleElement();}if (isCompletable) {return observable.ignoreElements();}return RxJavaPlugins.onAssembly(observable);}

3.5 如何支持Kotlin协程

3.5.1 Kotlin使用协程网络请求

添加依赖

def kotlin_coroutines = '1.3.7'
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines"implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.2.0'
implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.2.0'
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0'

定义请求接口，写一个挂起函数

interface ApiService {//使用 Kotlin 协程 ，定义一个挂起函数@GET("users/{user}/repos")suspend fun listReposKt(@Path("user") user: String?): List<Repo>
}

进行请求

//创建出GitHubApiService对象
val service = retrofit.create(ApiService::class.java)
//lifecycle提供的协程的Scope，因为 suspend 函数需要运行在协程里面
lifecycleScope.launchWhenResumed {try {val repo = service.listReposKt("octocat")"response name = ${repo[0].name}".logE()} catch (e: Exception) {e.printStackTrace()//出错逻辑//ignore}
}

3.5.2 源码解析

suspend函数

suspend fun test(name: String) {}

转为java形式

public final class SuspendKt {@Nullablepublic static final Object test(@NotNull String name, @NotNull Continuation $completion) {return Unit.INSTANCE;}
}

suspend 的关键字变成 test 方法的一个Continuation类型的参数

//Continuation
@SinceKotlin("1.3")
public interface Continuation<in T> {public val context: CoroutineContextpublic fun resumeWith(result: Result<T>)
}

//HttpServiceMethod.parseAnnotations
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {/***检查接口方法上的注解，以构建可重用的 HTTP 服务方法。这需要潜在的昂贵反射，因此最好只构建一次服务方法并重用它。*/static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {//1. 获取 isKotlinSuspendFunction 的值boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;boolean continuationWantsResponse = false;boolean continuationBodyNullable = false;//获取方法注解Annotation[] annotations = method.getAnnotations();Type adapterType;//2. 如果是 Kotlin 挂起函数if (isKotlinSuspendFunction) {//获取参数类型Type[] parameterTypes = method.getGenericParameterTypes();Type responseType =Utils.getParameterLowerBound(0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {// 从 Response<T> 解析实际正文类型responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);//3. continuationWantsResponse为truecontinuationWantsResponse = true;} else {}adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);} else {adapterType = method.getGenericReturnType();}//创建请求适配器//HttpServiceMethod.invoke 实际调用的是callAdapter.adapt方法CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);//在遍历converterFactories时会根据 **responseType**来找到对应的内容转换器。Type responseType = callAdapter.responseType();if (responseType == okhttp3.Response.class) {throw methodError(method,"'"+ getRawType(responseType).getName()+ "' is not a valid response body type. Did you mean ResponseBody?");}if (responseType == Response.class) {throw methodError(method, "Response must include generic type (e.g., Response<String>)");}// TODO support Unit for Kotlin?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);okhttp3.Call.Factory callFactory = retrofit.callFactory;if (!isKotlinSuspendFunction) {return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);} else if (continuationWantsResponse) {//返回 SuspendForResponse 它是 HttpServiceMethod的子类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);}}//...
}

获取 isKotlinSuspendFunction 的值的过程

//RequestFactory.javaprivate @Nullable ParameterHandler<?> parseParameter(int p, Type parameterType, @Nullable Annotation[] annotations, boolean allowContinuation) {ParameterHandler<?> result = null;if (annotations != null) {for (Annotation annotation : annotations) {//1 遍历解析参数的注解，就是 @Path @Query @Field 等注解，具体就不看了，不是协程的重点ParameterHandler<?> annotationAction =parseParameterAnnotation(p, parameterType, annotations, annotation);if (annotationAction == null) {continue;}if (result != null) {throw parameterError(method, p, "Multiple Retrofit annotations found, only one allowed.");}result = annotationAction;}}if (result == null) {//2 如果是协程 ，其实比的就是最后一个值if (allowContinuation) {try {//3 判断参数类型是 Continuation，这个接口，前面在 10.2 小节写 Demo 时提过if (Utils.getRawType(parameterType) == Continuation.class) {// 4 isKotlinSuspendFunction 赋值为 trueisKotlinSuspendFunction = true;return null;}} catch (NoClassDefFoundError ignored) {// Ignored}}throw parameterError(method, p, "No Retrofit annotation found.");}return result;}

接下来就要 SuspendForResponse 以及它的 adapt 方法了

//HttpServiceMethod.javastatic final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object> {private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;SuspendForResponse(RequestFactory requestFactory,okhttp3.Call.Factory callFactory,Converter<ResponseBody, ResponseT> responseConverter,CallAdapter<ResponseT, Call<ResponseT>> callAdapter) {super(requestFactory, callFactory, responseConverter);this.callAdapter = callAdapter;}@Overrideprotected Object adapt(Call<ResponseT> call, Object[] args) {//1. 调用callAdapter 代理 call 方法call = callAdapter.adapt(call);//取出最后一个参数，强转成 Continuation 类型Continuation<Response<ResponseT>> continuation =(Continuation<Response<ResponseT>>) args[args.length - 1];// See SuspendForBody for explanation about this try/catch.try {//3. Call 的扩展函数（Kotlin 的写法）下面具体看下 awaitResponsereturn KotlinExtensions.awaitResponse(call, continuation);} catch (Exception e) {return KotlinExtensions.suspendAndThrow(e, continuation);}}}

suspend fun <T> Call<T>.awaitResponse(): Response<T> {return suspendCancellableCoroutine { continuation ->continuation.invokeOnCancellation {cancel()}enqueue(object : Callback<T> {override fun onResponse(call: Call<T>, response: Response<T>) {continuation.resume(response)}override fun onFailure(call: Call<T>, t: Throwable) {continuation.resumeWithException(t)}})}
}

4 总结

总体来说，Retrofit就是封装了三层的网络请求框架

第一层：通过动态代理，反射获取代理接口方法，解析方法注解和方法参数注解信息封装成ServiceMethod

第二层：通过请求适配器（Rxjava等）和数据内容转换器（Gson等）包装处理返回的数据

第三层：通过包装类里面调用 OkhttpCall 调用 OkHttp 的方式完成网络请求。

Retrofit 2.9.0 源码解析相关推荐

solrlucene3.6.0源码解析（三）
solr索引操作(包括新增更新删除提交合并等)相关UML图如下从上面的类图我们可以发现,其中体现了工厂方法模式及责任链模式的运用 UpdateRequestProcessor相当于责任链模式 ...
Heritrix 3.1.0 源码解析（八）
本文接着分析存储CrawlURI curi的队列容器,最重要的是BdbWorkQueue类及BdbMultipleWorkQueues类 BdbWorkQueue类继承自抽象类WorkQueue,抽象 ...
Heritrix 3.1.0 源码解析（六）
本文分析BdbFrontier对象的相关状态和方法 BdbFrontier类继承自WorkQueueFrontier类 WorkQueueFrontier类继承自AbstractFrontier类 ...
Heritrix 3.1.0 源码解析（十一）
上文分析了Heritrix3.1.0系统是怎么添加CrawlURI curi对象的,那么在系统初始化的时候,是怎么载入CrawlURI curi种子的呢? 我们回顾前面的文章,在我们执行采集任务的la ...
Heritrix 3.1.0 源码解析（三十四）
本文主要分析FetchFTP处理器,该处理器用于ftp文件的下载,该处理器的实现是通过封装commons-net-2.0.jar组件来实现ftp文件下载在FetchFTP处理器里面定义了内部类Soc ...
Heritrix 3.1.0 源码解析（十四）
我在分析BdbFrontier对象的void schedule(CrawlURI caURI).CrawlURI next() .void finished(CrawlURI cURI)方法是,其实还 ...
锚框、交并比和非极大值抑制（tf2.0源码解析)
锚框.交并比和非极大值抑制(tf2.0源码解析) 文章目录锚框.交并比和非极大值抑制(tf2.0源码解析) 一.锚框生成 1.锚框的宽高 2.锚框的个数 3.注意点(★★★) 4.tf2.0代码二 ...
基于8.0源码解析：startService 启动过程
基于8.0源码解析:startService 启动过程首先看一张startService的图,心里有个大概的预估,跟Activity启动流程比,Service的启动稍微简单点,并且我把Service ...
Android Glide 3.7.0 源码解析(八) , RecyclableBufferedInputStream 的 mark/reset 实现
个人博客传送门一.mark / reset 的作用 Android Glide 3.7.0 源码解析(七) , 细说图形变换和解码有提到过RecyclableBufferedInputStream ...
Vue2.0源码解析——编译原理
Vue2.0源码解析--编译原理前言:本篇文章主要对Vue2.0源码的编译原理进行一个粗浅的分析,其中涉及到正则.高阶函数等知识点,对js的考察是非常的深的,因此我们来好好啃一下这个编译原理的部分. ...

Retrofit 2.9.0 源码解析