Retrofit源码解读(五)–okhttpCall和adapt方法

标签（空格分隔）： Retrofit源码 学习笔记

---

前言

• 以下的相关知识总结是通过慕课网的相关学习和自己的相关看法,如果有需要的可以去查看一下慕课网的相关教学,感觉还可以。

内容

上一节总结了ServiceMethod的类和相关作用,接下来就总结一下下面的两行方法.

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

OkHttpCall（实现了okhttp的Call）

成员变量

  //ServiceMethod对象 用来表述网络请求参数信息  private final ServiceMethod<T, ?> serviceMethod;  //表述网络接口参数  private final @Nullable Object[] args; //该请求是否可以被取消  状态标志位  private volatile boolean canceled;  //okhttp3.Call   实际进行网络请求的类  @GuardedBy("this")  private @Nullable okhttp3.Call rawCall;  //异常  出现异常的处理类  @GuardedBy("this")  private @Nullable Throwable creationFailure; // Either a RuntimeException or IOException.  //标志位  用于异步方法执行逻辑使用  @GuardedBy("this")  private boolean executed;

构造函数

//ServiceMethod   请求接口参数OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {    this.serviceMethod = serviceMethod;    this.args = args;  }

OkHttpCall就是Retrofit这个库对于OkHttp的一个封装,请求网络的时候,不管事同步还是异步,都是通过OkHttpCall进行的请求

serviceMethod.callAdapter.adapt(okHttpCall);

通过调用adapt这个方法就是用来进行适配的,通过传入创建好的okhttpcall来获取他的返回值
我们可以看到callAdapter是属于serviceMethod里面的参数,这个参数的赋值在serviceMethod的build的时候进行的赋值。adapt也就是通过适配器模式,转换成我们需要的一些请求,比如当我们addCallAdapterFactory(RxJavaCallAdapterFactory.create())的时候,我们想要的就是通过RxJava来处理请求返回的response,那么通过adapt这个方法就可以转换成Observable这个类型,来让我们操作。也就是可以对于不同平台的其他类型。

所以当通过crete这个方法之后,我们就创建了 TestInterface service = getRetrofit().create(TestInterface.class);这个接口实例,然后通过接口实例的

service.getQiuShiJsonString()

但是有个疑问,那就是接口实例调用方法,这个时候我们可以想到的就是前面提到的动态代理,荣光Proxy.newProxyInstance进行拦截,然后调用InvocationHandler中的invoke()方法来进行实际的操作,最终我们会返回一个OkHttpcall类型的call对象来进行实际的网络请求,所以说我们的service.getQiuShiJsonString()这个请求,就是通过动态代理返还给我们的call对象来进行网络请你去,这个okhttpcall又是对okhttp的网络请求的封装,所以也就是通过okhttp来进行的同步和异步请求。

Retrofit请求

• 同步请求OkHttpCall.execute()
• 异步请求OkHttpCall.enqueue(callback)

经过之前的分析,我们可以知道Retrofit的Call其实是对于OkHttpCall的请求的封装,因此Retrofit的同步和异步请求就是调用OkHttpCall的请求来进行的同步和异步

同步VS异步

• 回调执行器
  
  • 整个的同步和异步请求比较类似,区别在于回调执行器,异步会把数据返回之后交给execute(回调执行器来做),由Executor来指定相应的线程去完成不同的操作

Retrofit同步请求

• 1、ParameterHandler进行请求方法的参数解析
• 2、根据ServiceMethod这个对象创建OkHttp的Request对象
  
  • 有了这个request对象我们才能调用okhttp进行网络请求
  • 而且ServiceMethod包含了我们所有的网络请求的基本信息(当前请求和已经换成的请求)
  • 而且这个ServiceMethod有缓存,使用的是ConcurrentHashMap,进行缓存是为了高效运行
• 3、通过okhttpCall发送网络请求
• 4、调用converter进行数据解析(默认是GsonConverter)

 qiuShiJson.execute();  //同步请求方法 @Override public Response<T> execute() throws IOException {    //创建okhttp3 里面的Call对象  来请求数据    okhttp3.Call call;    //加锁    synchronized (this) {     //是否执行的标志位        if (executed) throw new IllegalStateException("Already executed.");      executed = true;      call = rawCall;      if (call == null) {        try {        //创建一个新的okhttpcall          call = rawCall = createRawCall();        } catch (IOException | RuntimeException e) {          creationFailure = e;          throw e;        }    }    //当canceled为true的时候 直接取消请求    if (canceled) {      call.cancel();    }    //接下来分析这个parseResponse()方法  因为call.execute()这个call其实就是okhttp的call,然后这个请求就已经交给了okhttp进行请求,这里暂不做相关分析    return parseResponse(call.execute());  }  //创建okhttp3.Call   private okhttp3.Call createRawCall() throws IOException {    Request request = serviceMethod.toRequest(args);    //创建okhttp call    okhttp3.Call call = serviceMethod.callFactory.newCall(request);   //直接返回    return call;  }  //上述方法就是把我们网络请求中的参数,调用ParameterHandler对象来进行参数的解析,然后在通过serviceMethod.toRequest()方法来生成Request这个对象,最后把这个Request对象通过serviceMethod的CallFactory工厂的newCall()方法创建我们的实际请求的OkHttp.Call对象

parseResponse(call.execute())方法

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {    //获取到ResponseBody    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();    //返回码  暂不解析。。。    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);    //主要是这个toResponse()方法     最终也就是调用我们传入的GsonConverter转换器  转换成我们需要的数据类型    /** Builds a method return value from an HTTP response body.   //R toResponse(ResponseBody body) throws IOException //{  //  return responseConverter.convert(body);  //}      T body = serviceMethod.toResponse(catchingBody);      //返回成功的response  完成了整个的response解析      return Response.success(body, rawResponse);    }  }

上述就是retrofit的同步请求的相关解析。其实简单来说,retrofit就是通过接口的注解和参数,把我们的http请求进行了包装，然后呢我们在retrofit使用的时候,然后在使用的时候我们只需要把重点放在接口的创建上,通过接口来配置方法和参数,其他都是通过他的内部来进行逻辑处理,他内部也是通过动态代理将客户端写好的接口中的方法转换成ServiceMethod对象,然后通过这个ServiceMethod对象来获取到我们需要的信息(数据转换器/网络适配器等、、),最终网络底层的请求还是交给了okhttp来进行。

Retrofit异步请求

异步请求的相关原理基本和Retrofit的同步请求类似,关于那4步骤可以看Retrofit的同步请求刚开始那4条。主要的区别就是在于异步的异步回调

@Override public void enqueue(final Callback<T> callback) {    //okhttpcall    okhttp3.Call call;    //错误    Throwable failure;    synchronized (this) {    //和同步类似      if (executed) throw new IllegalStateException("Already executed.");      executed = true;      call = rawCall;      failure = creationFailure;        try {        //创建rawCall          call = rawCall = createRawCall();        } catch (Throwable t) {          failure = creationFailure = t;        }    }    //错误相关逻辑处理    if (failure != null) {      callback.onFailure(this, failure);      return;    }    //是否取消请求    if (canceled) {      call.cancel();    }    //这个才是真正的异步请求    call.enqueue(new okhttp3.Callback() {      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)          throws IOException {        Response<T> response;        try {        //这个是正确请求返回数据只会  解析response          response = parseResponse(rawResponse);        } catch (Throwable e) {          callFailure(e);          return;        }        //调用成功的逻辑  回调执行器        callSuccess(response);      }      @Override public void onFailure(okhttp3.Call call, IOException e) {        try {        //失败的时候  回调执行器          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }      //失败的逻辑处理      private void callFailure(Throwable e) {        try {        //这个就是callback  在我们自己的实现的onFailure里面进行异常的处理          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }      private void callSuccess(Response<T> response) {        try {        //成功的返回 这个会在我们异步请求中  复写这个onResponse方法来进行  数据逻辑处理,第一个参数是OkHttpCall   第二个参数就是response这个  也就是如果我们接受的是HttpResult<List<TestBean>>>这个类型  那么我们返回的也是这个类型  Response<HttpResult<List<TestBean>>> response  这个response就是我们的最终解析后的数据类型          callback.onResponse(OkHttpCall.this, response);        } catch (Throwable t) {          t.printStackTrace();        }      }    });  }