Retrofi分析（三）

上一篇Retrofi分析（二） 分析了下Retrofit和Service的创建，经过一系列的封装，最终返回的是GitHubService接口的代理实现类。下面就是调用实现类中的方法开始请求网络了。

        Call<List<Repo>> call = service.listRepos("octocat");
          try {
          //同步请求
            Response<List<Repo>> execute = call.execute();
            List<Repo> body = execute.body();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //异步请求
        call.enqueue(new Callback<List<Repo>>() {
            @Override
            public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
                Log.i("response",response.body().toString());
            }

            @Override
            public void onFailure(Call<List<Repo>> call, Throwable t) {
                Log.i("onFailure",t.toString());
            }
        });

先看同步请求：

上一篇我们知道生成的代理类封装进OkHttpCall中，因为OkHttpCall是实现retrofit2.Call接口的具体实现类，所以
call.execute()实际调用是OkHttpCall的execute()方法

  @Override public Response<T> execute() throws IOException {
    okhttp3.Call call;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      if (creationFailure != null) {
        if (creationFailure instanceof IOException) {
          throw (IOException) creationFailure;
        } else if (creationFailure instanceof RuntimeException) {
          throw (RuntimeException) creationFailure;
        } else {
          throw (Error) creationFailure;
        }
      }

      call = rawCall;
      if (call == null) {
        try {
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException | Error e) {
          throwIfFatal(e); //  Do not assign a fatal error to creationFailure.
          creationFailure = e;
          throw e;
        }
      }
    }

    if (canceled) {
      call.cancel();
    }

    return parseResponse(call.execute());
  }

可以看到调用的createRawCall()l来获取一个okhttp3.Call，然后调用parseResponse()来获取retrofit2.Response。

createRawCall()方法：

  private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = serviceMethod.toCall(args);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

调用serviceMethod的callFactory对象的toCall来获取一个okhttp3.Call call。传入方法的参数

 okhttp3.Call toCall(@Nullable Object... args) throws IOException {
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
        contentType, hasBody, isFormEncoded, isMultipart);

    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;

    int argumentCount = args != null ? args.length : 0;
    if (argumentCount != handlers.length) {
      throw new IllegalArgumentException("Argument count (" + argumentCount
          + ") doesn't match expected count (" + handlers.length + ")");
    }

    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

    return callFactory.newCall(requestBuilder.build());
  }

方法注释：从方法参数构建HTTP请求。
首先创建了RequestBuilder ，RequestBuilder这个类，主要就是用于创建一个okHttp的Request，里面有很多方法用于设置Request的一些参数。

看有多少参数，并判断参数跟以前赋值的ParameterHandler的数量是不是一样

然后赋值一个ParameterHandler。它是一个参数处理类，循环调用它的apply方法。apply(RequestBuilder builder, T value)方法是抽象的，需要子类去实现。它的子类跟我们的的参数注解对应比如Path，Field，FieldMap，Part，PartMap，Query等

最后调用callFactory.newCall(requestBuilder.build());创建okhttp3.Call。第一篇中我们知道callFactory其实就是okhttp中的OkHttpClient对象。所以剩下的就是okhttp中的方法了。

parseResponse(call.execute())方法： 处理响应

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

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }

（1）Retrofit是先取出ResponseBody
（2）调用rawResponse.newBuilder()的build()方法构建一个* 空的 *响应的体的rawResponse。
（3）根据HTTP状体码来判断是否成功与失败
（4）如果成功且是204或者205则说明内容或者重复内容则不用关心响应体，则调用Response.success(null, rawResponse)方法
（5）最后，调用ServiceMethod实例的toResponse(catchingBody)方法来获取一个类型是T的对象

 R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }

可以看到 ServiceMethod类的parseResponse() 方法内部调用的是responseConverter.convert(body)，responseConverter是ServiceMethod.Builder的build()方法中获取的通过调用createResponseConverter()来获取的。这里我们使用的是GsonResponseBodyConverter所以看看它的convert方法。

 @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      return adapter.read(jsonReader);
    } finally {
      value.close();
    }
  }

这样就实现了网络响应体的反序列化。我们就可以通过response.body()来获取响应的对象了。

再看异步请求

因为OkHttpCall是实现retrofit2.Call接口的具体实现类，所以call.enqueue()实际调用是OkHttpCall的enqueue()方法。看下OkHttpCall的enqueue()方法的源码

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

    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 {
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          throwIfFatal(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) {
        Response<T> response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }

        try {
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        callFailure(e);
      }

      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }

可以看到里面最终还是调用了okhttp3.Call的异步的方法，异步操作跟同步的最大区别就是在子线程中执行，别的基本都一样。
将请求成功或者失败的结果通过回调接口回调到主线程。我们知道okhttp3.Call的异步请求的回调最后也是在子线程中。这里的回调直接回调到主线程中，我们就可以直接操作UI界面了。

总结：

Retrofit的流程，首选创建Retrofit，配置响应的参数，Retrofit总体使用的是外观模式，Retrofit持有所有子系统的引用；Retrofit有两个比较重要的两个Factory，一个是用来生成对应”Call”的CallAdapter的CallAdapterFactory；一个是用来进行响应数据转化(反序列化)的ConvertFactory；这两个都是list集合，用户可以自己进行添加

在我们自定义的Service中，每一个method一一对应一个ServiceMethod，而ServiceMethod持有一个Retrofit，前面两个Factory以及生成的Request的RequestBuilder，在okHttp中，Request需要自己进行定义创建，而Retrofit简化了这个操作，进行相应的封装，使用注解的方式来定义RequestBuilder相关参数信息；

具体的注解信息的解析则在parseMethodAnnotation()方法里面和parseParameterAnnotation()方法里面分别解析方法注解和参数注解。最终通过RequestBuilder来具体生成一个Request

RequestBuilder中持有okHttp中的Request.Builder类的引用，其创建Request的过程其实都是交给okHttp来操作的；生成的Request最终封装成一个OkHttpCall，

OkHttpCall则可以看做是对okHttp中Call的代理，同时对okHttp的返回Response进行解析，使用convertFactory将其解析为用户所期望的返回类型。

Retrofit内部使用了动态代理，方便了使用，通过retrofit.create返回的其实是一个动态代理类，所有具体的逻辑处理交给ServiceMethod来进行处理。

OK结束。