Android框架源码分析——Retrofit源码分析

最新推荐文章于 2022-04-21 14:13:43 发布

Alex@W

最新推荐文章于 2022-04-21 14:13:43 发布

阅读量304

点赞数

分类专栏： Android源码分析和框架编写文章标签： Retrofit 源码分析

本文链接：https://blog.csdn.net/Alexwll/article/details/94220201

版权

Android源码分析和框架编写专栏收录该内容

22 篇文章 2 订阅

订阅专栏

1、使用Demo

public static <T> T createApi(Class<T> clazz, String url) {
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(url)
            .client(okHttpClient)
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .addConverterFactory(GsonConverterFactory.create())
            .build();
    return retrofit.create(clazz);
}

2、源码分析

Retrofit.Builder()：创建Builder实例初始化Retrofit

Builder(Platform platform) {
  converterFactories.add(new BuiltInConverters()); //保存默认的内置转换工厂
}

baseUrl（）：设置请求的baseUrl，程序会解析baseUrl并创建HttpUrl实例，最终实例会保存在Retrofit中

public Builder baseUrl(String baseUrl) {
  HttpUrl httpUrl = HttpUrl.parse(baseUrl); //根据baseUrl创建HttpUrl
  return baseUrl(httpUrl);
}
public Builder baseUrl(HttpUrl baseUrl) {
  this.baseUrl = baseUrl; //赋值baseUrl
  return this;
}

create（）：创建API接口实例

Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },  new InvocationHandler() {
      private final Platform platform = Platform.get();  //获取设备平台
      @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ServiceMethod<Object, Object> serviceMethod =  (ServiceMethod<Object, Object>) loadServiceMethod(method);  //（1）获取或创建 ServiceMethod<Object, Object>实例
        OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args); //（2）创建OkHttpCall实例
        return serviceMethod.callAdapter.adapt(okHttpCall); //（3）调用设置的Adapter.adapt()转换OkHttpCall实例
      }
    });

Retrofit使用动态代理的形式拦截设置接口中的所有抽象方法，关于动态代理的内容点击查看，在动态代理的invoke（）方法中主要完成以下过程：

创建ServiceMethod<Object, Object>保存方法和参数的注解信息
创建OkHttpCall实例用于执行网络请求
调用设置的CallAdapter转换OkHttp返回的Call，从而封装转换请求方式，Retrofit之所以能使用RxJava就是因为CallAdapter的存在，它可以将请求适配到任何类型上

上面的三个过程就是Retrofit的主要工作原理，下面一一分析

2.1、获取、创建ServiceMethod实例

Retrofit.loadServiceMethod()

ServiceMethod<?, ?> loadServiceMethod(Method method) {
  ServiceMethod<?, ?> result = serviceMethodCache.get(method);   //（1）从缓存的Map中获取ServiceMethod
  if (result != null) return result;
    synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = new ServiceMethod.Builder<>(this, method).build();   //（2）创建实例、解析方法和参数的注解
      serviceMethodCache.put(method, result); （3）缓存ServiceMethod
    }
  }
  return result;
}

loadServiceMethod()首先从缓存中获取，如果缓存中没有则创建实例，这里设置缓存是为了当多次请求同一个接口时，避免每次都要反射获取注解，首次解析后缓存之后调用此方法时直接使用；

ServiceMethod.Builder——主要封装保存请求的Method、方法注解、参数类型、参数注解，具体内部属性见注解

Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;  //Retrofit实例
  this.method = method;   //Method方法
  this.methodAnnotations = method.getAnnotations();   //获取方法的注解类型
  this.parameterTypes = method.getGenericParameterTypes();  //获取方法的参数类型集合
  this.parameterAnnotationsArray = method.getParameterAnnotations();  //获取参数注解集合
}

ServiceMethod.Builder.build（）：创建ServiceMethod实例，解析所有的方法注解和参数注解

public ServiceMethod build() {
callAdapter = createCallAdapter(); // （1）
responseType = callAdapter.responseType(); //获取Adapter的返回类型
responseConverter = createResponseConverter(); //（2）
for (Annotation annotation : methodAnnotations) {  //（3）
  parseMethodAnnotation(annotation);
}
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
  Type parameterType = parameterTypes[p];
  Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
  parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations); //(4)
  }
 return new ServiceMethod<>(this); //（5）
}

build（）方法中执行的逻辑很多，完成了所有的转换和注解的处理，总结以下：

获取设置的Call的Adapter执行并获取转换的类型，一般设置的为RxJavaAdapter转换为Observable
获取返回类型转换器，用于对请求的结果Response进行转换
循环遍历方法的每个注解，获取请求的方法类型和请求地址
遍历参数注解，针对每个参数注解创建parameterHandlers实例封装注解信息并保存在数组中，最终使用所有的parameterHandlers创建执行网络请求
创建ServiceMethod（）对象

parseMethodAnnotation（）：遍历方法注解，获取请求方式和请求的url

//遍历方法注解，确定请求方式、请求地址、请求参数
private void parseMethodAnnotation(Annotation annotation) {
  if (annotation instanceof DELETE) {
    parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);  //根据选择的方式，转换方法和参数value，并解析请求参数
  } else if (annotation instanceof GET) {
    parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);  //GET请求
  } else if (annotation instanceof POST) {
    parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);  //POST请求
}

首先根据注解解析请求方式，并获取设置的方法注解参数最终拼接请求地址，以GET方式请求为例分析，保存了请求方法GET、请求体、请求Url

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
  this.httpMethod = httpMethod;   //保存方法“GET”
  this.hasBody = hasBody;   //是否有请求体，针对POST请求
  this.relativeUrl = value; //赋值实际请求的Url（也就是注解中的路径）
}

parameterAnnotationsArray（）：遍历方法参数注解

int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];   //创建ParameterHandler实例，保存参数下标、参数类型、参数注解的解析结果
for (int p = 0; p < parameterCount; p++) {
  Type parameterType = parameterTypes[p];  //（1）
  Annotation[] parameterAnnotations = parameterAnnotationsArray[p];  //（2）获取当前参数注解
  parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);   //（3）解析参数类型和参数注解创建ParameterHandler实例，并保存在数组中
}

从上面代码看出，parameterAnnotationsArray会遍历获取所有的获取当前注解的参数类型，解析每个参数类型和参数注解创建ParameterHandler实例，并保存在数组中

parseParameter（）：解析参数和参数注解

private ParameterHandler<?> parseParameter( int p, Type parameterType, Annotation[] annotations) {
  ParameterHandler<?> result = null;
  for (Annotation annotation : annotations) {
    ParameterHandler<?> annotationAction = parseParameterAnnotation( p, parameterType, annotations, annotation);
    result = annotationAction;
  }
  return result;
}

处理参数注解

private ParameterHandler<?> parseParameterAnnotation( int p, Type type, Annotation[] annotations, Annotation annotation) {
//处理Url注解
if (annotation instanceof Url) {
  if (gotUrl) { //Url只能出现一次，如果已经出现过了抛出异常
    throw parameterError(p, "Multiple @Url method annotations found.");
  }
  if (gotPath) { //@Path和@Url不能同时在参数注解中使用
    throw parameterError(p, "@Path parameters may not be used with @Url.");
  }
  if (gotQuery) { //@Url不能出现在@Query之后
    throw parameterError(p, "A @Url parameter must not come after a @Query");
  }
  if (relativeUrl != null) { //如果在方法注解中设置了Url，参数中不能使用@Url注解
    throw parameterError(p, "@Url cannot be used with @%s URL", httpMethod);
  }
  gotUrl = true; //此处赋值goUrl位true
  return new ParameterHandler.RelativeUrl(); //创建ParameterHandler实例，此处为实现类RelativeUrl
}
//处理Path注解
if (annotation instanceof Path) {
  if (gotQuery) { //@Path 不能出现在@Query之后
    throw parameterError(p, "A @Path parameter must not come after a @Query.");
  }
  if (gotUrl) {//@Path 和@Url不能一起使用
    throw parameterError(p, "@Path parameters may not be used with @Url.");
  }
  if (relativeUrl == null) {//使用@Path必须在方法注解中设置请求Url
    throw parameterError(p, "@Path can only be used with relative url on @%s", httpMethod);
  }
  gotPath = true; //
  Path path = (Path) annotation;
  String name = path.value(); //获取@Path注解名称，请求数据的Key
  validatePathName(p, name); //校验参数合法性
  Converter<?, String> converter = retrofit.stringConverter(type, annotations); //获取设置的String转换
  return new ParameterHandler.Path<>(name, converter, path.encoded()); //创建Path实例
}
//处理Query注解
if (annotation instanceof Query) {
  Query query = (Query) annotation;
  String name = query.value(); //获取@Query注解名称
  boolean encoded = query.encoded();
  gotQuery = true; //
    return new ParameterHandler.Query<>(name, converter, encoded);
  }
}
//处理Head注解
if (annotation instanceof Header) {
  Header header = (Header) annotation;
  String name = header.value(); //获取@head注解名称
    Converter<?, String> converter =
        retrofit.stringConverter(type, annotations);
    return new ParameterHandler.Header<>(name, converter); //
} 
// 处理Field参数注解
if (annotation instanceof Field) {
  if (!isFormEncoded) { //使用@Field注解必须在方法注解上声明@FormUrlEncoded注解
    throw parameterError(p, "@Field parameters can only be used with form encoding.");
  }
  Field field = (Field) annotation;
  String name = field.value(); //获取@Field注解名称
  boolean encoded = field.encoded();
  gotField = true;  //
    Converter<?, String> converter =  retrofit.stringConverter(type, annotations);
    return new ParameterHandler.Field<>(name, converter, encoded);
} 
//处理FieldMap参数注解
if (annotation instanceof FieldMap) {
  if (!isFormEncoded) { // //使用@Field注解必须在方法注解上声明@FormUrlEncoded注解
    throw parameterError(p, "@FieldMap parameters can only be used with form encoding.");
  }
 …….
  Converter<?, String> valueConverter =
      retrofit.stringConverter(valueType, annotations);
  gotField = true;
  return new ParameterHandler.FieldMap<>(valueConverter, ((FieldMap) annotation).encoded()); //创建ParameterHandler.FieldMap<>实例
}
//处理@part注解
else if (annotation instanceof Part) {
  if (!isMultipart) { //对于@part注解必须在方法上添加@Multipart注解
    throw parameterError(p, "@Part parameters can only be used with multipart encoding.");
  }
  Part part = (Part) annotation;
  gotPart = true;
  String partName = part.value(); //获取@Part注解名称
  Class<?> rawParameterType = Utils.getRawType(type);
  if (partName.isEmpty()) { //注解名称为空的情况
     
  } else { //当@part注解名称不为空
    Headers headers =
        Headers.of("Content-Disposition", "form-data; name=\"" + partName + "\"",
            "Content-Transfer-Encoding", part.encoding()); // 设置上传文件参数的头部信息
      return new ParameterHandler.Part<>(headers, converter); // 创建ParameterHandler.Part实例
} 
//处理@partMap注解
if (annotation instanceof PartMap) {
  if (!isMultipart) { // 添加@Multipart注解
    throw parameterError(p, "@PartMap parameters can only be used with multipart encoding.");
  }
  gotPart = true;
  Class<?> rawParameterType = Utils.getRawType(type);
  …...
  Converter<?, RequestBody> valueConverter =
      retrofit.requestBodyConverter(valueType, annotations, methodAnnotations);
  PartMap partMap = (PartMap) annotation;
  return new ParameterHandler.PartMap<>(valueConverter, partMap.encoding());  
  //创建 ParameterHandler.PartMap<>实例
}
// 处理@Body注解
if (annotation instanceof Body) {
  if (isFormEncoded || isMultipart) { //@Multipart和@FormEncoded必须有一个
  }
  if (gotBody) { //已经设置了@Body
    throw parameterError(p, "Multiple @Body method annotations found.");
  }
  gotBody = true;
  return new ParameterHandler.Body<>(converter); //创建 ParameterHandler.Body<>实例
}
}

上面的代码虽然很多但逻辑很清晰，就是针对注解类型Url、Path、Query、QueryName、QueryMap、Header、HeaderMap、Field、FieldMap、Part、PartMap、Body分别处理参数，除了必要的判断外，根据不同注解创建ParameterHandler对应的子类，保存注解值和对应的类型转换器，具体的见注释

2.2、创建OkHttpCall

OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
serviceMethod.callAdapter.adapt(okHttpCall)

获取转换的适配器Adapter，在上面知道执行了createCallAdapter()获取适配器，createCallAdapter()中根据方法的返回类型在已添加的adapter集合中查找
执行转换器的adapt（）方法，已RxJavaAdapter为例最终返回的是一个Observable（），在Observable中封装了OkhttpCall（相求见后面分析）
经过上面的封装OKhttpCall已经转换成RxJava操作了，在RxJAva订阅之后会执行Observable的subscribeActual（）方法，在subscribeActual（）中执行了OkhttpCall的execute（）

@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
    Response<T> response = call.execute(); 
}

2.3、执行网络请求

@Override public Response<T> execute() throws IOException {
  okhttp3.Call call;
  synchronized (this) {
    executed = true;
    call = rawCall; //赋值rawCall，此时拿到的初始化时创建Okhttp的Call实例
    if (call == null) {
      try {
        call = rawCall = createRawCall(); //（1）
      } 
    }
  }
  if (canceled) { //取消请求
    call.cancel();
  }
  return parseResponse(call.execute()); //
}
private okhttp3.Call createRawCall() throws IOException {
  Request request = serviceMethod.toRequest(args); //
  okhttp3.Call call = serviceMethod.callFactory.newCall(request);  //
  return call;
}

除去外层的Adapter封装，请求最终调用OkHttpCall.execute()方法，execute（）中的逻辑很清除，首先根据注解解析后的数据创建Okhttp中的Request对象那个，然后调用初始化时设置OkhttpClient创建Call实例

ServiceMethod.toRequest()：创建Okhttp请求的Request实例，具体见注释

 Request toRequest(Object... args) throws IOException {
  //（1）封装保存所有请求信息，RequestBuilder内部创建了OKhttp中的Request.Builder requestBuilder;
  RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,contentType, hasBody, isFormEncoded, isMultipart);  
  ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers; //保存所有参数注解和参数注解信息的数组
  int argumentCount = args != null ? args.length : 0;
  for (int p = 0; p < argumentCount; p++) {
  handlers[p].apply(requestBuilder, args[p]); // （2）为每个参数和注解执行apply（）方式（前面针对注解创建的ParameterHandler），将注解的参数注解和参数值进行拼接处理
  }
  return requestBuilder.build(); //（3）创建Okhttp的Request实例
}

ParameterHandler.apply()——此处根据解析参数注解时创建的ParameterHandler实例，调用对应的apply（）方法，每个apply（）都会将数据设置到最终的Request中

@url——ParameterHandler.RelativeUrl.apply()：保存请求的Url

//以Url注解为例
static final class RelativeUrl extends ParameterHandler<Object> {
  @Override void apply(RequestBuilder builder, Object value) {
    builder.setRelativeUrl(value); // 直接设置RequestBuilder请求的Url
  }
}

@path——ParameterHandler.Path().apply()：使用具体的参数值替换请求地址中的@Path注解

@Override void apply(RequestBuilder builder, T value) throws IOException {
  builder.addPathParam(name, valueConverter.convert(value), encoded);  //首先对参数值进行转换，然后在url中设置请求参数
}
void addPathParam(String name, String value, boolean encoded) {
  relativeUrl = relativeUrl.replace("{" + name + "}", canonicalizeForPath(value, encoded)); // 针对Path注解替换Url中的占位符字符串
}

@query——ParameterHandler.Query<>：拼接处理最终的请求路径（http://****？key=value）

@Override void apply(RequestBuilder builder, T value) throws IOException {
  builder.addQueryParam(name, valueConverter.convert(value), encoded); // 对参数进行转换
}
void addQueryParam(String name, String value, boolean encoded) {
  if (relativeUrl != null) {
    urlBuilder = baseUrl.newBuilder(relativeUrl); //创建Okhttp中HttpUrl。Builder
    relativeUrl = null;
  }
  if (encoded) {
    urlBuilder.addEncodedQueryParameter(name, value); //加密设置，
  } else {
    urlBuilder.addQueryParameter(name, value); //直接添加参数和Value，最终都会将数据保存在encodedQueryNamesAndValues集合中
  }
}

@head——ParameterHandler.Header<>：设置请求Request的Header信息

@Override void apply(RequestBuilder builder, T value) throws IOException {
  builder.addHeader(name, valueConverter.convert(value)); 
}
void addHeader(String name, String value) {
  if ("Content-Type".equalsIgnoreCase(name)) { //如果设置Content-Type暂时保存在contentType中，在创建Request中时设置
    MediaType type = MediaType.parse(value);
    contentType = type; //保存ContentType
  } else {
    requestBuilder.addHeader(name, value); //直接调用Okhttp中的Request。Builder设置头部信息
  }
}

@Field——ParameterHandler.Field<>：为Post请求设置请求参数

@Override void apply(RequestBuilder builder, T value) throws IOException {
  builder.addFormField(name, valueConverter.convert(value), encoded);
}
void addFormField(String name, String value, boolean encoded) {
  if (encoded) {
    formBuilder.addEncoded(name, value); //调用FormBody.Builder添加参数值
  } else {
    formBuilder.add(name, value); 
  }
}

@FieldMap——ParameterHandler.FieldMap<>：为Post请求设置参数集合

@Override void apply(RequestBuilder builder, Map<String, T> value) throws IOException {
  for (Map.Entry<String, T> entry : value.entrySet()) {
    String entryKey = entry.getKey(); //获取Map的Key
    T entryValue = entry.getValue(); //获取Map的Value
    builder.addFormField(entryKey, valueConverter.convert(entryValue), encoded); //便利整个参数Map依次添加参数值
  }
}

@part——ParameterHandler.Part<>：根据参数信息，设置请求MultipartBody的参数

@Override void apply(RequestBuilder builder, T value) {
  RequestBody body;
  body = converter.convert(value); //  转为RequestBody实例
  builder.addPart(headers, body);
void addPart(Headers headers, RequestBody body) {
  multipartBuilder.addPart(headers, body); //MultipartBody.Builder添加参数
}

@partMap——ParameterHandler.PartMap<>：处理PartMap

@Override void apply(RequestBuilder builder, Map<String, T> value) throws IOException {
  for (Map.Entry<String, T> entry : value.entrySet()) {
    String entryKey = entry.getKey(); //获取Map的key
    T entryValue = entry.getValue(); //获取Map的Value
    //为每个文件传输设置头部信息
    Headers headers = Headers.of(
        "Content-Disposition", "form-data; name=\"" + entryKey + "\"",
        "Content-Transfer-Encoding", transferEncoding);
    builder.addPart(headers, valueConverter.convert(entryValue));
  }
}
void addPart(Headers headers, RequestBody body) {
  multipartBuilder.addPart(headers, body);
}

@Body——ParameterHandler.Body<>：直接设置请求RequestBody

@Override void apply(RequestBuilder builder, T value) {
  RequestBody body;
  try {
    body = converter.convert(value);
  builder.setBody(body); 
}
void setBody(RequestBody body) {
  this.body = body; //设置RequestBody
}

RequestBuilder.build()——创建OkHttp请求的Request实例

public Request build() {
  HttpUrl url;
  HttpUrl.Builder urlBuilder = this.urlBuilder;
  if (urlBuilder != null) {
    url = urlBuilder.build();
  } else {
    url = baseUrl.resolve(relativeUrl);  //设置请求的Url
  }
  RequestBody body = this.body;  //设置请求Body
  
  RequestBody body = this.body;
  if (body == null) {
  if (formBuilder != null) {
    body = formBuilder.build();
  } else if (multipartBuilder != null) {
    body = multipartBuilder.build();
  } 
 }
  MediaType contentType = this.contentType;
  if (contentType != null) {
    if (body != null) {
      body = new ContentTypeOverridingRequestBody(body, contentType);
    } else {
      requestBuilder.addHeader("Content-Type", contentType.toString());  //设置请求头部信息
    }
  }
  return requestBuilder      //利用Okhttp的RequestBuilder创建请求的Request
      .url(url)
      .method(method, body)
      .build();
}

创建RealCall

okhttp3.Call call = serviceMethod.callFactory.newCall(request);  //调用初始化时设置OkhttpClient创建Call实例

执行——真正执行call.execute()

call.execute()

3、解析返回的Response

parseResponse(call.execute());

call.execute()执行后获取Okhttp返回的Response，根据状态码确定请求结果

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
  ResponseBody rawBody = rawResponse.body(); //获取请求返回Body
  rawResponse = rawResponse.newBuilder()
  //创建ExceptionCatchingRequestBody实例
  ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);   
  try {
    T body = serviceMethod.toResponse(catchingBody); // （1）调用ServiceMethod.toResponse()转化响应结果(Gson在此执行映射对象)
    return Response.success(body, rawResponse); //（2）返回请求成功，参数：转化后的对象、原来的Response
  } catch (RuntimeException e) {
    catchingBody.throwIfCaught();
    throw e;
  }
}

首先获取ResponseBody，然后调用ServiceMethod.toResponse()转化响应结果(Gson在此执行映射对象)，最后返回Reponse

调用ServiceMethod.toResponse（）根据设置的转换器，转换Response返回的结果，这里获取的responseConverter对象就是在ServiceMethod中获取（参考上面获取RxJavaAdapter的过程），最终执行的是GsonConverterFactory.convert（）

R toResponse(ResponseBody body) throws IOException {
  return responseConverter.convert(body); //调用设置的对结果的转换器转换Response
}
ServiceMethod build（）{ // 此处的responseConverter
responseConverter = createResponseConverter();
}

GsonConverterFactory.convert()：Json转换为对象T

@Override public T convert(ResponseBody value) throws IOException {
  JsonReader jsonReader = gson.newJsonReader(value.charStream()); // 获取JsonReader
  try {
    return adapter.read(jsonReader); //读取JsonReader转换为对象
  } finally {
    value.close();
  }
}

Response<>（）：将转换后的结果保存在Response中并返回

public static <T> Response<T> success(T body, okhttp3.Response rawResponse) {
 。。。。。。 
  return new Response<>(rawResponse, body, null); // （1）封装转换后的Object和原始的Response
}
* addConverterFactory（）：为对象的序列化和反序列化添加转换器工厂，上面的converterFactories也是此处添加
public Builder addConverterFactory(Converter.Factory factory) {
  converterFactories.add(checkNotNull(factory, "factory == null"));//保存添加的Converter.Factory
  return this;
}

4、转换请求方式（以RxJava2CallAdapterFactory为例）

@FormUrlEncoded
@POST("user/register/")
fun register( @Field("repassword") repassword: String): Call<ArticleBean> //返回Call实例

callAdapter.adapt(okHttpCall)：在create（）实例化接口对象时，调用AdapterFactory.adapt()转换OkhttpCall，系统默认使用DefaultCallAdapterFactory，在DefaultCallAdapterFactory中直接返回Call，所以Retrofit注解的方法默认返回Call

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();
  @Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }
      @Override public Call<Object> adapt(Call<Object> call) {
        return call;  //默认直接返回RealCall实例
      }
    };
  }
}

根据数据的返回类型获取转换适配器，执行adapt（）转换OkhttpCall实例

serviceMethod.callAdapter.adapt(okHttpCall);
//最终执行nextCallAdapter（）
public CallAdapter<?, ?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
  int start = adapterFactories.indexOf(skipPast) + 1;
  for (int i = start, count = adapterFactories.size(); i < count; i++) { //获取设置的AdapterFcatory
    CallAdapter<?, ?> adapter = adapterFactories.get(i).get(returnType, annotations, this); 
    if (adapter != null) {
      return adapter;
    }
  }
}

addCallAdapterFactory（）：在创建Retrofit实例时添加Call转换器工厂，所有的转换工厂会保存在adapterFactories，上面就是从adapterFactories查找适配器

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  //将添加的Adapter.Factory保存在 adapterFactories集合中
  adapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

RxJava2CallAdapter

@Override public Object adapt(Call<R> call) { //传入的OkhttpCall
  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); //对于RxJava此处创建的是BodyObservable
  } else {
    observable = responseObservable;
  }
  return observable;
}
//执行被观察者
@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
  Call<T> call = originalCall.clone(); // （1）Copy一份OKhttpCall
  try {
    Response<T> response = call.execute(); // （2）执行OKhttpCall完成网络请求和数据转换
    if (!call.isCanceled()) {
      observer.onNext(response); // （3）发送数据，发送的是封装转化对象和Response的对象
    }
  } 
}

在使用Retrofit时一般设置RxJava2CallAdapter，将创建执行的Call转换为Observable实例，这里直接看adapt（）首先根据同步或异步选择相应的被观察者，在被观察者执行时会执行Observable的subscribeActual（），在subscribeActual中执行OKhttpCall完成网络请求和数据转换，然后执行onNext（）发送数据

BodyObservable：获取Response中的Body作为最终的对象发送

BodyObservable(Observable<Response<T>> upstream) {
  this.upstream = upstream; // 构造函数中保存传入的Observable实例
}
@Override protected void subscribeActual(Observer<? super T> observer) {
  upstream.subscribe(new BodyObserver<T>(observer)); //调用保存实力的方法去获取数据
}
Override public void onNext(Response<R> response) {
  if (response.isSuccessful()) {
    observer.onNext(response.body()); // 只发送请求的Body即转换后的对象
  }
}

到这里Retrofit的源码分析结束了，总结一下Retrofit的完整执行流程：

首先根据需要创建并配置Retrofit的实例，此时需要设置相应的请求适配器和结果转换器
在接口方法中配置retrofit的方法、方法注解、参数及参数注解
在调用Retrofit.create（）实例化API接口时，为Retrofit注解设置动态代理，接口中所有方法都会被动态代理拦截
在调用接口方法时，回调执行动态代理中的InvocationHandler（），解析处理方法注解和参数注解的信息，保存在ServiceMethod实例中，并缓存ServiceMethod
创建OkHttpCall实例，保存ServiceMethod实例和传入的参数数组
调用Retrofit配置的CallAdapter.Factory中的CallAdapter.adapt()转换OkHttpCall实例，在转换后的对象中保存并引用OkhttpCall
执行转换实例会间接调用OkhttpCall的execute（）执行方法时，根据保存ServiceMethod实例和传入参数解析并创建Okhttp中的Request实例
使用传入的OkhttpClient和创建的Request创建真实的RealCall
执行RealCall网络请求解析返回的结果，根据结果创建并返回Response的实例
调用设置的结果转换器，转换并发送相应的数据

Alex@W

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android框架源码分析——Retrofit源码分析

1、使用Demopublic static <T> T createApi(Class<T> clazz, String url) { Retrofit retrofit = new Retrofit.Builder() .baseUrl(url) .client(okHttpClient) ...
复制链接

扫一扫