Retrofit2源码阅读

本次分析的要点：
1. Retrofit中的动态代理和整个流程（Proxy、ServiceMethod、OkHttpCall）
2. Retrofit中的转换器和适配器（Converter、CallAdapter）

Retrofit整体流程和动态代理

首先我们回顾一下retrofit的使用demo

   Retrofit retrofit = new Retrofit.Builder()
                //设置OKHttpClient
                .client(okHttp.INSTANCE.getOkHttpClient())
                //Rx适配器
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                //gson转化器
                .addConverterFactory(GsonConverterFactory.create())
                // 设置API基础的Url
                .baseUrl("https://www.baidu.com")
                // 创建Retrofit
                .build();
    BaiduAPI api = retrofit.create(BaiduAPI.class);

    Call<String> call = api.getInfo();

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

            }

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

            }
        });

    public interface BaiduAPI{
        @GET("https://www.baidu.com)
        Call<String> getInfo();
    }

retrofit的使用还是比较简单的，通过定义规定好的接口，通过Builder来创建Retrofit对象，通过create方法来创建接口的代理对象，然后调用定义好的方法就可以请求网络来获取数据了。

首先看一下Builder类吧

public static final class Builder {
    // 平台验证 JAVA和Android，这里是Android
    private final Platform platform;
    // 真正发起OkHttp3请求的Call类
    private @Nullable okhttp3.Call.Factory callFactory;
    // 将字符url包装为HttpUrl
    private HttpUrl baseUrl;
    // 转换工厂集合，Retrofit可以插入多个转换器，例如Gson，jackson等
    private final List<Converter.Factory> converterFactories = new ArrayList<>();
    // 用于发起请求和接受相应的Call适配器集合
    private final List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    // 并发框架
    private @Nullable Executor callbackExecutor;
    // 是否立即加载所有的接口方法，转换为ServiceMethod对象，放在serviceMethodCache中
    private boolean validateEagerly;

    // 省略代码
    ...

重点是create方法

 public <T> T create(final Class<T> service) {
    // 检查接口的合法性，必须是接口，并且不能继承其他接口
    Utils.validateServiceInterface(service);
    // 是否立即给接口中的所有方法生成包装类，默认是false
    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, @Nullable Object[] args)
              throws Throwable {
            // 如果方法对象的类时Object的对象，就走普通的代理方法
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // 在Android平台上是是返回false的
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 生成ServiceMethod对象，这个对象是为了将请求的方法是配成HTTP Call
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            // 创建OkHttpCall对象
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            // 将OkHttpCall对象适配成我们需要的Call类型
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

可以看到这里用到了Java自带的Proxy类，提供了动态代理支持，newProxyInstance方法会生成当前接口的代理类，并且放回改代理类的实例。正式动态代理设计模式，让我们在触发真正的网络请求时添加其他的逻辑。Retrofit正是利用这一点，利用注解，生成request和response，将重复的工作封装到这个类中，我们只需要专注于API接口的编写即可，这也是AOP（面向切面编程）思想的一种体现。

每当我们调用代理对象的方法时，都会触发InvocationHandler的invoke方法，它会把我们这次调用的方法method和参数args都回调过来，拿到method后首先经过loadServiceMethod方法，将method作为key转换为ServiceMethod对象，看一下这个类都做了什么？

/** Adapts an invocation of an interface method into an HTTP call. */
final class ServiceMethod<R, T> {
  // Upper and lower characters, digits, underscores, and hyphens, starting with a character.
  static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
  static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
  static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);

  final okhttp3.Call.Factory callFactory;
  final CallAdapter<R, T> callAdapter;

  private final HttpUrl baseUrl;
  private final Converter<ResponseBody, R> responseConverter;
  private final String httpMethod;
  private final String relativeUrl;
  private final Headers headers;
  private final MediaType contentType;
  private final boolean hasBody;
  private final boolean isFormEncoded;
  private final boolean isMultipart;
  private final ParameterHandler<?>[] parameterHandlers;

  ServiceMethod(Builder<R, T> builder) {
    this.callFactory = builder.retrofit.callFactory();
    this.callAdapter = builder.callAdapter;
    this.baseUrl = builder.retrofit.baseUrl();
    this.responseConverter = builder.responseConverter;
    this.httpMethod = builder.httpMethod;
    this.relativeUrl = builder.relativeUrl;
    this.headers = builder.headers;
    this.contentType = builder.contentType;
    this.hasBody = builder.hasBody;
    this.isFormEncoded = builder.isFormEncoded;
    this.isMultipart = builder.isMultipart;
    this.parameterHandlers = builder.parameterHandlers;
  }

  /** 将请求的方法转换为一个请求需要Request对象 */
  Request toRequest(@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 requestBuilder.build();
  }

  /** 经过Convert处理，将原始的response body转换成我们需要的类型 */
  R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }
  ...
  省略代码

这个勒种最重要的两个方法是toRequest和toResponse。我们请求时使用的request和最后得到的response就是由这两个方法返回的，还有其他大量的方法parseXXX,都是讲注解解析成具体的参数。

在得到ServiceMethod后，将它和请求参数一起作为参数创建了OkHttpCall对象，这个对象就是网络请求所需要的对象。OkHttpCall是一个装饰类，真正的网络请求时rawCall，而这个rawCall对象就是通过传入的serviceMethod的toRequest方法生成的。

看一下OkHttpCall类中几个主要方法：

// OkHttpCall.java

//生成真正用于执行请求任务的call
 private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

  // 异步请求方法
  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) {
          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 = 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(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callSuccess(Response<T> response) {
        try {
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }

  // 同步方法
  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 {
          throw (RuntimeException) creationFailure;
        }
      }

      call = rawCall;
      if (call == null) {
        try {
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException e) {
          creationFailure = e;
          throw e;
        }
      }
    }

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

    return parseResponse(call.execute());
  }


  // 本次请求结果经过toResponse(Converter)处理后返回
  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;
    }
  }

上面代码只截取了四个重要的方法

• createRawCall()生成用于请求的Call对象
• enqueue() 异步请求的方法
• excute() 同步执行的方法
• parseResponse() 将结果通过Convert转换为所需要的类型

Retrofit中的转换器和适配器

Retrofit的定位是网络框架（底层是由OkHttp负责），它的主要职责就是接口转换为底层可以网络请求的request，和将网络请求返回的response转换为我们想要的数据类型。所以CallAdapter和Convert完成了这两个功能。同时，这两个接口设计的十分灵活，易于拓展，可以和当今甚至未来的各种库对接，也体现了Retrofit的优势。

CallAdapter在Retrofit中有一个默认的实现类，在Platform类中的ExecutorCallAdapterFactory，RxJavaCallAdapterFactory、SquareGuavaCallAdapterFactory等都做了很好的适配。

Convert是将一个类型转换为另一个类型，在retrofit2中的converter库中已经包含了我们通常使用的Gson，jackson等一些列的传唤器，使用十分方便。

最后再总结一下，Retrofit使用到的设计模式

• 适配器模式
• 动态代理
• Builder模式
• 工厂模式

从okhttp和retrofit可以看出来，优雅的设计框架，总是非常灵活的，通过实现一些定义好的接口，然后根据业务的场景需求将相应的逻辑无缝插入到这些框架中，即实现了功能又不会破坏代码整体的结构，这才是“优雅”的框架。我们在设计框架时，也应该充分借鉴这一点，为用户预留充足的自定义空间，这样才能造出受欢迎的轮子。