Android开发Retrofit源码分析
作者：jiangpan 发布时间：2022-06-11 18:19:07
项目结构
把源码 clone 下来 , 可以看到 retrofit 整体结构如下
图 http包目录下就是一些http协议常用接口 , 比如 请求方法 url , 请求体, 请求行 之类的
retrofit 使用
把retrofit使用作为分析的切入口吧 , retrofit单元测试使用如下
public final class BasicCallTest {
@Rule public final MockWebServer server = new MockWebServer();
interface Service {
@GET("/") Call<ResponseBody> getBody();
}
@Test public void responseBody() throws IOException {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(server.url("/"))
.build();
Service example = retrofit.create(Service.class);
server.enqueue(new MockResponse().setBody("1234"));
Response<ResponseBody> response = example.getBody().execute();
assertEquals("1234", response.body().string());
}
}
Retrofit 构建 , 以构建者模式构建出Retrofit
可以看到builer可以配置baseUrl , 回调线程池 , 还有一些适配器的工厂 , 这些适配器的作用后面说
Retrofit #create
从create 方法开始分析 , 跟进看下create 方法
public <T> T create(final Class<T> service) {
validateServiceInterface(service);
return (T)
Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
private final Object[] emptyArgs = new Object[0];
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
args = args != null ? args : emptyArgs;
Platform platform = Platform.get();
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
}
});
}
service 是请求的接口的class , * 只能是接口 , 所以validateServiceInterface 先验证是不是接口 , 不是接口则抛异常。
method.getDeclaringClass() 获取声明类的Class。
比如 A类 有个method , method.getDeclaringClass() 返回为A.class , 如果method声明类是Object.class 则直接method.invoke , 往下执行毫无意义。
Platform#get()会根据当前平台获取Platform 。
有点类似状态模式思想 , 根据当前的平台选择合适的子类
public boolean isDefaultMethod(Method method) {
return method.isDefault();
}
isDefault , 在接口类型中以default关键字声明 则返回true, 比如
interface InterfaceWithDefault {
void firstMethod();
default void newMethod() {
System.out.println("newMethod");
}
}
所以此处会返回 false 接着调用 loadServiceMethod。
ServiceMethod #parseAnnotations
跟进ServiceMethod #parseAnnotations
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
根据当前的方法信息构建出RequestFactory , 然后把具体实现细节交给HttpServiceMethod 处理 , HttpServiceMethod 继承自ServiceMethod , 有三个子类 。
我们在Api.class定义的方法 , 解析并不是由HttpServiceMethod 完成 , 而是由RequestFactory去处理的 , 比如解析方法的注解。
更多的解析方法如下
方法解析的细节就不说了 , 继续看RequestFactory 这个类 , 这个类的作用难道就是负责方法信息的解析 , 感觉和名字不太符合 , RequestFactory 顾名思义应该是用来构建Request的工厂 , 果不其然内部还有个 create 方法 , 用来构建okhttp3.Request的
//RequestFactory #create
okhttp3.Request create(Object[] args) throws IOException {
return requestBuilder.get().tag(Invocation.class, new Invocation(method, argumentList)).build();
}
就只有这一个create方法 , 难道retrofit 就只能使用okhttp来负责网络请求 ? 答案是肯定的 , 从最开始的 loadServiceMethod(method).invoke(args)也可以看出 , 方法里面只构建出OkHttpCall 没提供api可以让我们切换到其他的网络请求库。
但是 , Call 又抽象成接口的形式 ,如下, 这么做的目的可能是以后便于框架的维护
沿途风景再美丽 , 也要回到主线路 , 继续分析 HttpServiceMethod#parseAnnotations
HttpServiceMethod#parseAnnotations
这个方法太长 , 贴关键代码吧
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
boolean continuationWantsResponse = false;
boolean continuationBodyNullable = false;
boolean continuationIsUnit = 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) {
continuationWantsResponse = true;
}
} else {
//非kt 协程情况
adapterType = method.getGenericReturnType();
}
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
Type responseType = callAdapter.responseType();
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
//非kt 协程情况
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForResponse<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForBody<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable,
continuationIsUnit);
}
}
构建出HttpServiceMethod分两种情况 :
kotlin 协程情况
非Kotlin 协程情况
第二种 非Kotlin协程情况
第一种情况稍许复杂 , 先分析第二种
adapterType = method.getGenericReturnType();
@GET("/") Call<ResponseBody> getBody();
如果是上面代码 , method.getGenericReturnType() = Call , 然后根据方法的返回值类型 / 方法注解信息 , 构建出CallAdapter 。
createCallAdapter() 方法会使用 CallAdapter.Factory 构建CallAdapter , 因为初始化retrofit的时候没有配置CallAdapter.Factory , 所以会使用默认的DefaultCallAdapterFactory。
最终会进入DefaultCallAdapterFactory#get 。
DefaultCallAdapterFactory#get
这个方法作用就是返回CallAdapter , 修改下源码加入两个打印。
public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
System.out.println("TAG" + " ->" + "returnType = " +getRawType(returnType) .getSimpleName());
System.out.println("TAG" + " ->" + "responseType = " +getRawType(responseType) .getSimpleName());
return new CallAdapter<Object, Call<?>>() {
@Override
public Type responseType() {
return responseType;
}
@Override
public Call<Object> adapt(Call<Object> call) {
return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}
};
}
运行可以看到以下打印信息
returnType = Call ,responseType =ResponseBody 。
总结一下 , returnType就是方法返回值 , responseType 就是方法返回值上的泛型 DefaultCallAdapterFactory会根据平台环境去构建。
以Android24分析 , DefaultCallAdapterFactory(Executor callbackExecutor) , 构造方法中 , 线程池为主线程池 , 在retrofit初始化的时候添加到 到callAdapterFactories 集合中。
至此 , CallAdapterFactory 和 CallAdapter 分析完了 , 总结下就是给Call (retrofit内存只有OkHttpCall 作为唯一实现类)做适配 , 让其可以在 Rxjava / 协程 等各个环境中使用 Call。
非kt 协程情况下 , parseAnnotations 方法最终返回的是将requestFactory , callFactory , responseConverter, callAdapter 封装好的CallAdapted 对象。
再次回到梦开始的地方Retrofit#create 方法 , loadServiceMethod获取的ServiceMethod最终实现类为CallAdapted , 获取之后会调用invoke方法 , invoke是一个final方法 , 里面构建了OkHttpCall , 然后调用了adapt方法 , adapt中调用了callAdapter.adapt(call)。
@Override
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
return callAdapter.adapt(call);
}
这里的ReturnT 就是ExecutorCallbackCall<>(executor, call) 对象 , 所以 example.getBody().execute() 就是调用ExecutorCallbackCall#execute方法
//ExecutorCallbackCall#execute
public Response<T> execute() throws IOException {
return delegate.execute();
}
delegate为OkHttpCall , 所以就调用到OkHttpCallCall#execute方法 , 这里就转给Okhttp去请求网络加载数据了 , 代码就不贴了 , 我们看下网络请求之后 , 数据Response 的处理 , 关键代码OkHttpCall#parseResponse。
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
try {
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
}
}
responseConverter 在 HttpServiceMethod#parseAnnotations 方法中获取 , 回应数据转换器 , 把数据转换成我们可以直接使用的对象 , 比如我们常用的 GsonConverterFactory。
最后把转换好之后的数据 , 封装成Response对象返回。
response.body()就是responseConverter 转换后的数据 来张大致流程图感受下吧
第一种 Kotlin协程情况
其实大致流程第二种情况分析的差不多了 , 接下来分析下Retrofit对于kotlin的特殊处理吧。
if (Utils.getRawType(parameterType) == Continuation.class) {
isKotlinSuspendFunction = true;
return null;
}
协程挂起方法 , 第一个参数为Continuation , 所以判断是不是挂起方法也很简单 , 根据ResponseType 去构建协程专用的HttpServiceMethod , 主要有两类。
SuspendForResponse , 对应type为Continuation<Response>
SuspendForBody , 对应type为Continuation
这里看下 SuspendForBody 实现 , 套娃情况就不分析了。
如果是这样使用 , 最终会调到SuspendForBody #adapt。
@Override
protected Object adapt(Call<ResponseT> call, Object[] args) {
call = callAdapter.adapt(call);
Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];
try {
//去掉干扰代码 , 仅保留这个
return KotlinExtensions.awaitNullable(call, continuation);
}
}
这个地方就很关键了 , java 直接调kotlin 协程 suspend 方法。
KotlinExtensions.awaitNullable 会调到KotlinExtensions#await方法。
retrofit与协程适配的细节都在 KotlinExtensions这个类里。
进入await , 可以看到使用suspendCancellableCoroutine把回调装换成协程。
@JvmName("awaitNullable")
suspend fun <T : Any> Call<T?>.await(): T? {
return suspendCancellableCoroutine { continuation ->
continuation.invokeOnCancellation {
cancel()
}
enqueue(object : Callback<T?> {
override fun onResponse(call: Call<T?>, response: Response<T?>) {
if (response.isSuccessful) {
continuation.resume(response.body())
} else {
continuation.resumeWithException(HttpException(response))
}
}
override fun onFailure(call: Call<T?>, t: Throwable) {
continuation.resumeWithException(t)
}
})
}
}
其实内部也是调用 OkHttp Call.enqueue() , 只不过是用suspendCancellableCoroutine给协程做了一层包装处理
通过 suspendCancellableCoroutine包装之后使用就很简单了。
GlobalScope.launch {
try {
val result = xxxApi.getXxx()
} catch (exception: Exception) {
}
}
来源：https://juejin.cn/post/7124611158329262087
0
投稿猜你喜欢
自定义 webflux 容器配置配置代码@Componentpublic class ContainerConfig extends Rea- 匿名内部类：先举个例子吧，给大家看一下什么是匿名内部类，Endeavor刚刚接触的时候，觉得哇哦，好奇怪的样子，这也太别扭了吧，不知道大家是
- 继续我们的源码解析，上一篇文章我们介绍了Activity的启动流程，一个典型的场景就是Activity a 启动了一个Activity b，
- 目录主要功能介绍客户端main方法入口主窗体代码更新帮助类版本xml文件解析服务端版本xml文件自动升级服务Controller版本文件自动
- java简易小游戏制作游戏思路：设置人物移动，游戏规则，积分系统，随机移动的怪物，游戏胜负判定，定时器。游戏内容部分package 代码部分
- 循环对数组进行拷贝利用循环对数组进行拷贝很简单，就是利用循环将要拷贝的数组的元素逐个赋值给新的数组。具体代码实现如下：public stat
- 前言上节在谈论Bean的实例化过程时，在说明实例化后阶段时只是粗略地看了一下populateBean,并未展开分析。本节接着populate
- 在需要线程同步的时候如何选择合适的线程锁？例：选择可以存入到常量池当中的对象，String对象等public class SyncTest{
- GB2312是简体中文系统的标准编码 用“区” 跟“位”的概念表示 称之为区位码 区指代大的范围 位相当于偏移量。每个汉字占两个字节高位字节
- Spring depends-on的使用通过在XML中的<bean>里配置depends-on属性或者在一个类上使用注解@Dep
- 本文实例讲述了Java实现的两个线程同时运行。分享给大家供大家参考，具体如下：/** * 两个案例同时运行案例 * 1:这个两个线程并不是有
- 从今天开始写关于C#的系列文章，本篇文章主要讲解C#中的委托使用。委托其实就是一种数据类型，和int，string是一样的概念。如果要把一个
- 1.1 JDK 14详细概述JDK 8 已经在 2014年 3月 18日正式可用，JDK 8作为长期支持(Long-Term-Support
- 在1.zip中增加一张新图片StorageFile jpg = await KnownFolders.PicturesLibrary.Get
- 1.application.yml中添加两个datasourceserver: port: 8080spring: application:
- SpringBoot整合第三方技术一、整合Junit新建一个SpringBoot项目使用@SpringBootTest标签在test测试包内
- 介绍Java中的享元模式(Flyweight Pattern)是一种结构型设计模式,旨在通过共享尽可能多的对象来减少内存占用和提高性能.Ja
- MD5,全称为 Message Digest Algorithm 5(消息摘要算法第五版).详情请参考 * :MD5MD5加密后是一个字
- Integer获取第一位和最后一位并截取场景获取 5,10,15,25,30; 判断尾数为5的进入判断public static void
- 模板编程是idea的强大功能，也提高了开发人员的编程效率，比如输入main函数：public static void main(String
