Android Retrofit的使用

原文   http://blog.fangjie.info/2016/07/14/我对Retrofit的认识/

 

Retrofit的想的文章很多，先罗列下 我在看过觉得不错的几篇文章：

 

• Retrofit分析-漂亮的解耦套路 （配套视频） 特别是课时5 讲的很不错
• Retrofit分析-经典设计模式案例

这两篇文章都是stay写的，觉得真心赞。当然我也不重复他文章里面的内容了，读者们完全可以直接看他的文章。当然我写这篇文章，主要想自我总结下，谈谈自己的认识而已。

首先Retrofit之所以这么火。我觉得他里面设计模式用的好，特别是适配器模式那里。总体来说，我觉得Retrofit精髓就在三点。1、动 态代理，用注解来生成请求参数；2、适配器模式的应用，请求返回各种CallAdapter，可扩展到RxJava、Java8，还有任何你自己写的 Adapter；3、Converter，你可以把请求的响应用各种Converter转成你的需求上。>

接下来细细说这些东西。

Retrofit一个简单的使用过程是这样的：

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl(API_URL)
    .addConverterFactory(GsonConverterFactory.create())
    .build();

// Create an instance of our GitHub API interface.
GitHub github = retrofit.create(GitHub.class);

// Create a call instance for looking up Retrofit contributors.
Call<List<Contributor>> call = github.contributors("square", "retrofit");

call.enqueue(new Callback<List<Contributor>>() {
  @Override
  public void onResponse(Call<List<Contributor>> call, Response<List<Contributor>> response) {

  }

  @Override
  public void onFailure(Call<List<Contributor>> call, Throwable t) {

  }
});

上面过程可以看成四步，也是接下来要分析的四个步骤。
1、Retrofit.Builder().build()
2、retrofit.create
3、 github.contributors
4、call.enqueue

第一步、Retrofit.Builder().build()

就是用到建造者模式。

   public Retrofit build() {
     if (baseUrl == null) {
       throw new IllegalStateException("Base URL required.");
     }
// 忽略不看 这个工厂模式基本没什么作用了，目前来说Retrofit只支持OkHttp，不能支持URLConnection或者HTTPClient
     okhttp3.Call.Factory callFactory = this.callFactory;
     if (callFactory == null) {
     //这里首先创建了一个OkHttpClient对象
       callFactory = new OkHttpClient();
     }

//然后创建Executor对象
     Executor callbackExecutor = this.callbackExecutor;
     if (callbackExecutor == null) {
       callbackExecutor = platform.defaultCallbackExecutor();
     }

//然后创建 CallAdapter对象
     // Make a defensive copy of the adapters and add the default Call adapter.
     List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
     adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
// 创建Converter对象
     // Make a defensive copy of the converters.
     List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

     return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
         callbackExecutor, validateEagerly);
   }

总结这步的步骤就是准备好要用到的东西，callAdapter是请求返回的对象，Converter是转换器，转换请求的响应到对应的实体对象，OkHttpClient是具体的OkHttp的请求客户端。

第二步、Retrofit.create();

public <T> T create(final Class<T> service) {
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
    eagerlyValidateMethods(service);
  }
  return (T) 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 {
          // If the method is a method from Object then defer to normal invocation.
          if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
          }
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
          ServiceMethod serviceMethod = loadServiceMethod(method);
          OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.callAdapter.adapt(okHttpCall);
        }
      });
}

这里就是动态代理的原理，在使用Retrofit的时候，我们会把网络请求的接口写成这样一个接口方法。第二步只是准备这样一个代理。

第三步、调用这个接口方法

调用的时候才会真正的触发这样一个过程。

public interface GitHub {
  @GET("/repos/{owner}/{repo}/contributors")
  Call<List<Contributor>> contributors(
      @Path("owner") String owner,
      @Path("repo") String repo);
}

动态代理就是拦截GitHub接口方法调用，但接下来主要做两个工作：1、拿到这个方法的各种注解，然后配置OkHttp的网络请求参数。2、把真实的网络请求的OkHttpCall转换成该接口对应的CallAdapter。

3.1、loadServiceMethod()

ServiceMethod loadServiceMethod(Method method) {
  ServiceMethod result;
  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = new ServiceMethod.Builder(this, method).build();
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

这里面对每个接口方法的注解解析生成ServiceMethod对象，使用了一个缓存，避免一个网络请求在多次调用的时候频繁的解析注解，毕竟注解解析过程消耗比较大。

这里面主要的工作又在ServiceMethod.Builder().build()；

   public ServiceMethod build() {

     callAdapter = createCallAdapter();
//... 
     responseConverter = createResponseConverter();

//...
     for (Annotation annotation : methodAnnotations) {
       parseMethodAnnotation(annotation);
     }

这里简单来说就是做三件事，1、找到对应的CallAdapter，2、找到对应的Converter，3、解析注解生成参数

3.1.1 找到对应的CallAdapter

for (int i = start, count = adapterFactories.size(); i < count; i++) {
  CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
  if (adapter != null) {
    return adapter;
  }
}

在找对应的callAdapter的时候，是根据不同的CallAdapterFactory的返回类型来区分的，比如我们看下默认的ExecutorCallAdapterFactory

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

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

这里就是说 返回类型是Call.class，都是使用 ExecutorCallAdapterFactory创建的的ExecutorCallbackCall。

而RxJava对应的返回类型就是Observable.class。

3.1.2 找对应的Converter

 public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,
     Type type, Annotation[] annotations) {

   int start = converterFactories.indexOf(skipPast) + 1;
   for (int i = start, count = converterFactories.size(); i < count; i++) {
     Converter<ResponseBody, ?> converter =
         converterFactories.get(i).responseBodyConverter(type, annotations, this);
     if (converter != null) {
       //noinspection unchecked
       return (Converter<ResponseBody, T>) converter;
     }
   }
}

看下GsonConverterFactory，

@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
    Retrofit retrofit) {
  TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
  return new GsonResponseBodyConverter<>(gson, adapter);
}

3.1.3 parseMethodAnnotation

最后就是解析请求参数的工作，这部分就是解析注解上配置的网络请求参数。很多，很琐碎。

三步完成之后，ServiceMethod对象就build出来了，然后放到缓存中，避免下次再build。再回到主线的第三步，loadServiceMethod完成之后，就是创建一个OkHttpCall。

3.2、创建OKhttpCall 并adapter对应的call

这个OkHttpCall才是真正OkHttp请求的回调，但是针对我们使用的不同的回调，比如：RxJava的Observable、 Call，所以有一层转换的关系，把OkHttpCall转成对应的Observable和Call。就是 serviceMethod.callAdapter.adapt(okHttpCall)的工作。

就拿默认的CallAdapter说吧，这里是个匿名类。

return new CallAdapter<Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

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

他的实现就是创建的一个ExecutorCallbackCall作为Call返回了。当然它里面还也持有OkHttpCall的引用。目的是为了上层的回调，下面会讲。

好了至此，主线的第三步完成，一切准备就绪了，就等网络请求了。网络请求分为异步、同步的，这里只讲异步的。同步的更简单。

第四步、call.enqueue

这个Call是对应选择的call，这里讲ExecutorCallbackCall

红色框起来的是，adapte步骤转换的时候，对应的call持有的真正网络请求OkHttp的Call。而这里的callbackExecutor又是运行在主线程的（这里没有跟踪代码，可以自己去查下，是这样的），所以callback的回调就运行在主线程了。

最后补充第五步，从主线上来看是看不出来Converter发挥作用的地方。

第五步、Converter的转换

就在第四步请求的时候，真实的网络请求OkHttpCall在enque的时候，里面有个onResponse，这里面调用了一个parseResponse，

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
  ResponseBody rawBody = rawResponse.body();




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

这里面关键的又回调了serviceMethod.toResponse，这里毫无疑问的就是找到把之前找出的Converter拿出来，进行convert操作。

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

至此一个完整的Retrofit的网络请求就已经完成了！

当然这里只讲了一个CallbackFactory，一个Conveter，Retrofit火就在于它能够扩张各种CallbackFactory，各种Conveter。当然配合 RxJavaCallbackFactory也是它火的一个原因。

自己拿源码走一遍吧！理解会更深刻！！