Retrofit源码之请求对象的转换笔记

之前在Retrofit源码初探一文中我们提出了三个问题:

  1. 什么时候开始将注解中参数拼装成http请求的信息的?
  2. 如何产生发起http请求对象的?
  3. 如何将对象转换成我们在接口中指定的返回值的?

其中前两个问题在前几篇文章已经做了解答,今天我们探究下最后一个问题:

我们定义接口时,有这样的:

@GET("hello/world")
Call<News> getNews(@Query("num") String num,@Query("page")String page);

也有这样的:

@GET("book/search")
 Observable<Book> getSearchBook(@Query("q") String name,
                  @Query("tag") String tag, @Query("start") int start,
                  @Query("count") int count);

可以看到接口的返回值是不一样的,现在我们就来分析下,一个OkHttpCall对象是如何转换成对应的返回值的。

核心代码是这句:

return serviceMethod.adapt(okHttpCall);

进到adapt中去:

T adapt(Call<R> call) {
  return callAdapter.adapt(call);
 }

可以看到是调用了callAdapter.adapt方法,此处的callAdapter是一个接口类型,所以想要看它的adapt方法的具体实现就得看这个callAdapter具体怎么生成的。

经过搜索,发现它的生成方式如下:

 ServiceMethod(Builder<R, T> builder) {
   //………………
  this.callAdapter = builder.callAdapter;
   //………………
  }

而这个构造方法是在ServiceMethod.Builder的build方法中调用的:

 public ServiceMethod build() {
   callAdapter = createCallAdapter();
   //…………
   return new ServiceMethod<>(this);
   }

所以继续跟进createCallAdapter()中去:

 private CallAdapter<T, R> createCallAdapter() {
   Type returnType = method.getGenericReturnType();
   if (Utils.hasUnresolvableType(returnType)) {
    throw methodError(
      "Method return type must not include a type variable or wildcard: %s", returnType);
   }
   if (returnType == void.class) {
    throw methodError("Service methods cannot return void.");
   }
   Annotation[] annotations = method.getAnnotations();
   try {
    //noinspection unchecked
    return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
   } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw methodError(e, "Unable to create call adapter for %s", returnType);
   }
  }

可以看到,这里的主要作用就是获取方法级别的注解以及返回值,然后传入到retrofit.callAdapter中去获取正真的CallAdapter,所以继续跟到retrofit.callAdatper中去:

 public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
  return nextCallAdapter(null, returnType, annotations);
 }

继续进到nextCallAdapter中:

public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
   Annotation[] annotations) {
  checkNotNull(returnType, "returnType == null");
  checkNotNull(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;
   }
  }
  //省略一些不重要代码
 }

这里主要就是遍历Retrofit的所有CallAdapter,然后找到能够处理该返回类型以及方法注解的那个直接返回。
对于默认返回类型的处理CallAdapter,其实是在Retrofit生成时默认加上的:

 public Retrofit build() {
   //省略部分代码
   Executor callbackExecutor = this.callbackExecutor;
   if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
   }

   // Make a defensive copy of the adapters and add the default Call adapter.
   List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
   callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
   //省略部分代码
   return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
     unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
 }

这里有一点要事先说下,所有的CalllAdapter对象其实都是通过CallAdapter.Factory对象调用get()方法生成的。
所以这里利用platform.defaultCallAdapterFactory()生成了一个对应的CallAdapter.Factory对象,但生成这个对象首先生成了一个callbackExecutor,我们先看下它是怎么回事:

@Nullable Executor defaultCallbackExecutor() {
  return null;
 }

咦,为什么是返回null的?别慌,Retrofit的build中的platform根据不同的情况会是不同的子类,并不一定是Platform的实例,而是它的子类:

 static class Android extends Platform {
  @Override public Executor defaultCallbackExecutor() {
   return new MainThreadExecutor();
  }

  @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
   if (callbackExecutor == null) throw new AssertionError();
   return new ExecutorCallAdapterFactory(callbackExecutor);
  }

  static class MainThreadExecutor implements Executor {
   private final Handler handler = new Handler(Looper.getMainLooper());

   @Override public void execute(Runnable r) {
    handler.post(r);
   }
  }
 }

我们重点关注Android平台的,可以看到这里生成的callbackExecutor的execute()方法主要就是用来将操作发送到主线程执行。

ok,callbackExecutor我们弄清楚了,那么接下来我们继续看platform.defaultCallAdapterFactory()方法生成了什么样的CallAdapter.Factory对象:

 CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
  if (callbackExecutor != null) {
   return new ExecutorCallAdapterFactory(callbackExecutor);
  }
  return DefaultCallAdapterFactory.INSTANCE;
 }

对于Android平台来说,我们之前生成了一个对应的callbackExecutor,所以我们继续跟进if中的语句,发现最终生成了一个ExecutorCallAdapterFactory()对象,当然,我们主要是看它的get()方法能得到什么样的CallAdapter对象:

 @Override
 public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
  if (getRawType(returnType) != Call.class) {
   return null;
  }
  final Type responseType = Utils.getCallResponseType(returnType);
  return new CallAdapter<Object, Call<?>>() {
   @Override public Type responseType() {
    return responseType;
   }

   @Override public Call<Object> adapt(Call<Object> call) {
    return new ExecutorCallbackCall<>(callbackExecutor, call);
   }
  };
 }

这个get()方法生成了一个匿名的CallAdapter对象,所以:

serviceMethod.adapt(okHttpCall)最终就是调用这个匿名对象的adapt方法

可以看到adapt方法最终就是将OkHttpCall对象转换成了ExecutorCallbackCall对象。那这个对象能干什么?

 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;
  }

  @Override public void enqueue(final Callback<T> callback) {
   checkNotNull(callback, "callback == null");

   delegate.enqueue(new Callback<T>() {
    @Override public void onResponse(Call<T> call, final Response<T> response) {
     callbackExecutor.execute(new Runnable() {
      @Override public void run() {
       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);
       }
      }
     });
    }

    @Override public void onFailure(Call<T> call, final Throwable t) {
     callbackExecutor.execute(new Runnable() {
      @Override public void run() {
       callback.onFailure(ExecutorCallbackCall.this, t);
      }
     });
    }
   });
  }

  @Override public boolean isExecuted() {
   return delegate.isExecuted();
  }

  @Override public Response<T> execute() throws IOException {
   return delegate.execute();
  }

  @Override public void cancel() {
   delegate.cancel();
  }

  @Override public boolean isCanceled() {
   return delegate.isCanceled();
  }

  @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
  @Override public Call<T> clone() {
   return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
  }

  @Override public Request request() {
   return delegate.request();
  }
 }

可以明显看到这个方法就是对OkHttpCall对象的一个包装,不同的是对它的enque()方法重写了,重写的目的很简单,就是为了将异步结果交给MainThreadExecutor,最终转换到主线程执行回调。

总结

上面源码分析了很多,有点杂乱,这里我们统一总结下OkHttpCall到接口定义的返回类型(这里以Call<ResponseBody>为例,)的转换过程:

  1. 通过platform(在Android平台上是它的子类Android) 生成一个Executor对象,在Android上就是MainThreadExecutor对象。
  2. 通过platform生成一个CallAdapterFactory对象,在Android上就是ExecutorCallAdapterFactory对象,该对象能通过get()方法生成一个CallAdapter对象,来将OkHttpCall对象转成ExecutorCallbackCall对象。
  3. 将上面提到的CallAdapterFactory对象塞到Retrofit对象中,最终在ServiceMethod的adapt()方法中调用,将OkHttpCall转成ExecutorCallback,然后就可以正常的调用enque()方法发起请求了。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 深入浅出RxJava+Retrofit+OkHttp网络请求

    浅谈RxJava+Retrofit+OkHttp 封装使用之前发出后收到很多朋友的关注,原本只是自己学习后的一些经验总结,但是有同学运用到实战当中,这让我很惶恐,所有后续一直更新了很多次版本,有些地方难免有所变动导致之前的博客有所出入,正好最近受到掘金邀请内测博客,所以决定重新写一版,按照最后迭代完成的封装详细的讲述一遍,欢迎大家关注! 注意:由于本章的特殊性,后续文章比较长而且复杂,涉及内容也很多,所以大家准备好茶水,前方高能预警. 简介: Retrofit: Retrofit是Square

  • 详解Retrofit Interceptor(拦截器) 拦截请求并做相关处理

    本文介绍Retrofit拦截器(Interceptor)的使用方法及相关注意事项.如果本文对您有所帮助,烦请点亮小红心- 首先看一下Interceptor源码: /** * Observes, modifies, and potentially short-circuits requests going out and the corresponding * responses coming back in. Typically interceptors add, remove, or tran

  • 为Retrofit统一添加post请求的默认参数的方法

    最近在学习使用Retrofit,并尝试将之引入到现有的项目中来.大家都知道,在Http请求中我们使用 Content-Type 来指定不同格式的请求信息: APP_FORM_URLENCODED("application/x-www-form-urlencoded"), APP_JSON("application/json"), APP_OCTET_STREAM("application/octet-stream"), MULTIPART_FOR

  • Android Retrofit和Rxjava的网络请求

    Android  Retrofit和Rxjava的网络请求 去年的时候好多公司就已经使用Rxjava和Retrofit了,最近自自己学习了一下,感觉真的是很好用,让自己的网络请求变得更简单了,而且封装性极强. 首先做一下准备工作,导入需要引用的文件 compile 'com.android.support:appcompat-v7:25.1.0' testCompile 'junit:junit:4.12' compile 'io.reactivex:rxjava:1.1.0' compile

  • 详解Retrofit 动态参数(非固定参数、非必须参数)(Get、Post请求)

    详解Retrofit 动态参数(非固定参数.非必须参数)(Get.Post请求) 关键词:Retrofit 动态参数.非固定参数.非必须参数 有如下场景: 请求数据时: 1. 用户未登录时,不带参数userId: 2. 登录时带上参数userId. 如下接口: @GET("index.php?r=default/homepage") Observable<Response<Exercise>> getDataList(@Query("page"

  • Kotlin结合Rxjava+Retrofit实现极简网络请求的方法

    前言 因为最近正在写的项目集成了两个网络请求框架(Volley and Retrofit)对比之下也是选择了Retrofit.既然选择那自然要让自己以后开发更加省力(就是懒).于是我在Retrofit中加入了Rxjava,这也是当下蛮流行的一个请求框架.然后又利用了Kotlin的一些新特性,使网络请求变得特别简单,代码量特别少. Kotlin镇楼 RxJava RxJava学习是一个曲折漫长的过程,但一旦掌握,妙用无穷. 通过这里了解更多:http://www.jb51.net/article/

  • Android网络请求框架Retrofit详解

    介绍: Retrofit 是Square公司开发的一款针对Android网络请求的框架,Retrofit2底层基于OkHttp实现的,OkHttp现在已经得到Google官方认可,大量的app都采用OkHttp做网络请求.本文使用Retrofit2.0.0版本进行实例演示. 使用Retrofit可以进行GET,POST,PUT,DELETE等请求方式. 同步请求:需要在子线程中完成,会阻塞主线程. Response response = call.execute().body(); 异步请求:请

  • Retrofit源码之请求对象的转换笔记

    之前在Retrofit源码初探一文中我们提出了三个问题: 什么时候开始将注解中参数拼装成http请求的信息的? 如何产生发起http请求对象的? 如何将对象转换成我们在接口中指定的返回值的? 其中前两个问题在前几篇文章已经做了解答,今天我们探究下最后一个问题: 我们定义接口时,有这样的: @GET("hello/world") Call<News> getNews(@Query("num") String num,@Query("page&qu

  • Android开发Retrofit源码分析

    目录 项目结构 retrofit 使用 Retrofit #create ServiceMethod #parseAnnotations HttpServiceMethod#parseAnnotations 第二种 非Kotlin协程情况 DefaultCallAdapterFactory#get 第一种 Kotlin协程情况 总结 项目结构 把源码 clone 下来 , 可以看到 retrofit 整体结构如下 图 http包目录下就是一些http协议常用接口 , 比如 请求方法 url ,

  • Retrofit 源码分析初探

    现如今,Android开发中,网络层Retrofit+Okhttp组合好像已成标配,身为技术人员,这么火的框架当然得一探究竟,不为装逼,纯粹是为了充电而已. 基本使用介绍 介绍源码前,我们先看下Retrofit的基本使用,大致了解下流程,跟着这个流程来分析源码才不会乱. 1.初始化Retrofit对象 Retrofit retrofit = new Retrofit.Builder() //使用自定义的mGsonConverterFactory .addConverterFactory(Gson

  • 浅谈flask源码之请求过程

    Flask Flask是什么? Flask是一个使用 Python 编写的轻量级 Web 应用框架, 让我们可以使用Python语言快速搭建Web服务, Flask也被称为 "microframework" ,因为它使用简单的核心, 用 extension 增加其他功能 为什么选择Flask? 我们先来看看python现在比较流行的web框架 Flask Django Tornado Sanic Flask: 轻, 组件间松耦合, 自由.灵活,可扩展性强,第三方库的选择面广的同时也增加

  • Spring源码之请求路径匹配路由方式

    目录 请求路径匹配路由 入口 进入上面方法 SpringMVC 将请求找到匹配的处理 初始化映射关系 从映射关系中寻找匹配方法 请求路径匹配路由 在spring中,当一个请求过来的时候会做路径匹配,下面我们就从源码层面分析一下路径匹配. 示例: @RequestMapping(value = "/user/{aid}/online/**", method = RequestMethod.GET) 我们一起看看这个方法是如何寻找的,和一些相应的工具类 入口 我的项目使用的是自动配置的Re

  • Bootstrap源码解读媒体对象、列表组和面板(10)

    媒体对象 基础媒体对象 例如: <div class="media"> <a class="pull-left" href="#"> <img class="media-object" src="http://placehold.it/350x150" alt="..."> </a> <div class="media-bo

  • Retrofit之OKHttpCall源码分析

    之前在Retrofit源码初探一文中我们提出了三个问题: 什么时候开始将注解中参数拼装成http请求的信息的? 如何产生发起http请求对象的? 如何将对象转换成我们在接口中指定的返回值的? 其中第一个问题前几篇文章已经做了解答,今天我们探究下第二个问题. 之前也分析过,具体生成这个请求对象的是这句代码: OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args); 代码很简单,那我们就来探究下这个Ok

  • 简略分析Android的Retrofit应用开发框架源码

    面对一个项目,对于Android应用开发框架的选择,我想过三种方案: 1.使用Loader + HttpClient + GreenDao + Gson + Fragment,优点是可定制性强,由于使用Google家自己的Loader和LoaderManager,代码健壮性强. 缺点是整套代码学习成本较高,使用过程中样板代码较多,(比如每一个Request都需要产生一个新类) 2.Volley,作为Google在IO大会上得瑟过的一个网络库,其实不算什么新东西(2013 IO发布),使用较为简单

  • 深入理解vue-class-component源码阅读

    vue-class-component是vue作者尤大推出的一个支持使用class方式来开发vue单文件组件的库.但是,在使用过程中我却发现了几个奇怪的地方. 首先,我们看一个简单的使用例子: // App.vue <script> import Vue from 'vue' import Component from 'vue-class-component' @Component({ props: { propMessage: String } }) export default clas

  • Vue3 编译流程-源码解析

    前言: Vue3 发布已经很长一段时间了,最近也有机会在公司项目中用上了 Vue3 + TypeScript + Vite 的技术栈,所以闲暇之余抽空也在抽空阅读 Vue3 的源码.本着好记性不如烂笔头的想法,在阅读源码时顺便记录了一些笔记,也希望能争取写一些源码阅读笔记,帮助每个想看源码但可能存在困难的同学减少理解成本. Vue2.x 的源码我也有过一些简单的阅读,自 Vue3 重构后,Vue 项目的目录结构也发生了很大的变化,各个功能模块被分别放入了 packages 目录下,职责更加清晰,

随机推荐