Retrofit源码学习随笔(1)

Retrofit

Retrofit用到了动态代理;

1.在 retrofit.create(interface service).service是用户自定义的一个请求数据Url相关的接口(一下同称自定义请求数据接口),这个接口不能继承其他的接口。原因如下:
1.进入create方法可以看到第一行的代码如下:

 public  T create(final Class service) {
    Utils.validateServiceInterface(service);

这个方法是检测当前这个类是否符合要求。跳进去,代码如下:

static  void validateServiceInterface(Class service) {
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }
    // Prevent API interfaces from extending other interfaces. This not only avoids a bug in
    // Android (http://b.android.com/58753) but it forces composition of API declarations which is
    // the recommended pattern.
    if (service.getInterfaces().length > 0) {
      throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
    }
  }

由第一个if语句可知这个类一定要是一个interface,第二个if语句则限定这个接口不能实现其他的接口。

1.Converter.Factory 用于创建转换ResponseBody的Converter的工厂类
Converter 用于将T转换为V 的转换类。convert方法定义了转换的逻辑以及返回了最终转换的结果。

最基本的用法

1.  Retrofit retrofit = new Retrofit.Builder()
2.              .baseUrl("http://www.baidu.com/")
3.              .addConverterFactory(EpgHomePageConverterFactory.create())
4. //               .addConverterFactory(GsonConverterFactory.create())
5.              .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
6.              .build(); //返回一个Retrofit的对象
7.   GetResponseService responseService = retrofit.create(GetResponseService.class);
8.  //通过动态代理获取调用对应的方法,结合CallAdapter以及ConverterFactory获取对应的Call对象。       
     Call responseBodyCall =    responseService.getResponse("xxxxx","xxxxx",1);
9. //调用Call的异步网络请求,请求网络并获取结果。   
     responseBodyCall.enqueue(new Callback() {
            @Override
            public void onResponse(Response response, Retrofit retrofit) {
                Log.i(TAG, response.body().getAreaUrl() + "areaUrl");

            }
            @Override
            public void onFailure(Throwable t) {

            }
        });

跟踪上面代码,探究Retrofit的工作流程:

  1. new Retrofit.Builder() 给Retrofit添加一个默认的转换工厂,用于转换网络请求的结果或者生成网络请求对象。
  public Builder() {
    // Add the built-in converter factory first. This prevents overriding its behavior but also
    // ensures correct behavior when using converters that consume all types.
    converterFactories.add(new BuiltInConverters());
  }
  1. baseUrl("http:/www.baidu.com/xxxx/xxxx/") 根据字符串参数,生成对应的HttpUrl。

3.第七句,调用retrofit.create(GetResponseService.class)方法通过动态代理模式生成一个GetResponseService的实例。
4 . loadMethodHandler(method) 用于加载interface中的方法,并构建对应的网络请求url,Converter以及CallAdapter。

static MethodHandler create(Retrofit retrofit, Method method) {
    CallAdapter callAdapter = (CallAdapter) createCallAdapter(method, retrofit);
    Type responseType = callAdapter.responseType();
    Converter responseConverter =
        (Converter) createResponseConverter(method, retrofit, responseType);
    //根据方法的返回类型以及注释,构成RequestFactory,继而得到Request对象。
    RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
    return new MethodHandler<>(retrofit, requestFactory, callAdapter, responseConverter);
  }

5 . invoke(arg) 传入方法的参数,然后通过OkHttp结合requestFactory和arg调用网络请求,并且通过responseConverter将请求的结果转换成对应的T.

  Object invoke(Object... args) {
  return callAdapter.adapt(new OkHttpCall<>(retrofit, requestFactory, responseConverter, args));
}

6.请求网络的操作在第九句,Call 其实是OkHttpCall对象,让我们来看看enqueue方法。

  @Override public void enqueue(final Callback callback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed");
      executed = true;
    }

    com.squareup.okhttp.Call rawCall;
    try {
    //获取一个Call对象 用于网络请求
      rawCall = createRawCall();
    } catch (Throwable t) {
      callback.onFailure(t);
      return;
    }
    if (canceled) {
      rawCall.cancel();
    }
    this.rawCall = rawCall;
    //执行网络请求,传入一个Okhttp的CallBack,回调函数中调用callback的方法,返回对应请求状态.
    rawCall.enqueue(new com.squareup.okhttp.Callback() {
      private void callFailure(Throwable e) {
        try {
          callback.onFailure(e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callSuccess(Response response) {
        try {
          callback.onResponse(response, retrofit);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      @Override public void onFailure(Request request, IOException e) {
        callFailure(e);
      }
      //关键 将请求结果转换成T类型。
      @Override public void onResponse(com.squareup.okhttp.Response rawResponse) {
        Response response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }
    });
  }

  • response = parseResponse(rawResponse);
    跳进parseResponse(rawResponse)看看是如何实现转换的。代码如下:
  private Response parseResponse(com.squareup.okhttp.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.readBodyToBytesIfNecessary(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        closeQuietly(rawBody);
      }
    }
    //请求成功
    if (code == 204 || code == 205) {
      return Response.success(null, rawResponse);
    }
  
    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
       //通过调用ResponseCoverter的converter方法转换。
      T body = responseConverter.convert(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;
    }
  }

通过以上源码跟踪分析:

总结

  • Converter.Factory用于在最后请求的时候,将请求得到的结果转换成F之后再转换成泛型T.
  • CallAdapter.Factory 决定了网络请求Call适配器,底层依然是OkhttpCall,不过可以通过自定义Call在OkHttpCall的基础上进行拓展。对应于自定一点的service的接口返回值类型。
    Converter.Factory的方法返回CallAdapter
    CallAdapter的Get方法返回 自定义的service的返回值类型,改类型封装了Call对象。responseType 对应于函数的返回值类型。
  • 默认会设置HttpClient,也可以自己设置HttpClient。
  • 采用动态代理模式完成请求接口的实例化以及函数调用。
  • 但是在Retrofit2.0 ,不管请求是否可以转换成功,onResponse都会被调用,但是请求返回的结果不能转换成相应的对象,'response.body()'将返回null,所以记住要处理情况!!!!

边学习源码,边做的一些随笔,写下来之后有其他理解在不断完善,有不对的多多指教,欢迎交流。O(∩_∩)O哈!

你可能感兴趣的:(Retrofit源码学习随笔(1))