Retrofit源码分析

Retrofit是Square团队对网络请求库Okhttp的进一步封装，趁着刚分析完Okhttp源码的热乎劲顺带着把Retrofit源码又过了一遍。Okhttp源码分析戳这里

Retrofit基本使用

老规矩分析源码从最简单的流程来，一个简单的Retrofit请求如下：

 		OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://news.baidu.com/")
                .client(okHttpClient)
                .build();
        ApiService mApiService = retrofit.create(ApiService.class);
        Call<ResponseBody> call = mApiService.getData();

//        //同步请求
//        call.execute();

        //异步请求
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    Log.e("tag", "请求成功:" + response.body().string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                Log.e("tag", "请求失败");
                t.printStackTrace();
            }
        });

可以看到一个最基本的Retrofit请求仅仅需要创建OkhttpClient和Service两个对象，而仅使用Okhttp不但要创建OkhttpClient、Call，而且每次使用都要配置一点点配置Request，Retrofit提供了api接口的统一配置位置–>Service。

Retrofit请求流程

可以大致分为3个步骤：
1> 通过Java动态代理创建Service代理对象
2>通过代理对象创建请求，调用代理方法返回Call对象
3>通过Call对象发起请求，返回响应结果
备注：这里简单考虑，先不管CallAdapter直接返回请求结果的流程

先上一张Retrofit请求流程图，然后再具体分析：

1.动态代理创建Service代理对象

如下面代码所示，熟悉的Java动态代理常见代码，Retrofit的create(Service.class)通过动态代理创建了Service的代理对象：

 public <T> T create(final Class<T> 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 {
            ......
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

2.代理对象通过invoke()调用代理方法

继续看上面代码匿名类invoke()方法的实现，首先调用loadServiceMethod(method)创建了一个ServiceMethod对象，先看一下这个方法的实现：

ServiceMethod<?, ?> loadServiceMethod(Method method) {
    ServiceMethod<?, ?> result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        //创建ServiceMethod，内部读取了method方法信息以及各种注解配置，将信息保存在创建ServiceMethod对象中
        result = new ServiceMethod.Builder<>(this, method).build();
        //将创建ServiceMethod对象缓存起来，下次直接使用
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

方法内部直接通过Builder模式创建了个ServiceMethod对象，并加入到了缓存中，接着看ServiceMethod是怎么Build的

    Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      //获取被代理方法注解
      this.methodAnnotations = method.getAnnotations();
      //获取被代理方法参数类型
      this.parameterTypes = method.getGenericParameterTypes();
      //获取被代理方法参数注解
      this.parameterAnnotationsArray = method.getParameterAnnotations();
    }
    
    public ServiceMethod build() {
      //创建CallAdapter
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      //获取响应数据转换器
      responseConverter = createResponseConverter();

      //遍历方法解析注解
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      ......	

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      //遍历参数
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }
        //解析参数类型及注解
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

      ......
      
      return new ServiceMethod<>(this);
    }

看一下创建Builder的过程，它的构造方法内部通过被代理方法method引用读取了方法的注解、参数类型、参数注解等一系列信息。
再看一下build()方法，我们先不去管CallAdapter和Converter的逻辑，build()内部首先遍历了并解析了方法注解，获取请求Method、Header等一系列的信息，然后又遍历了参数及参数注解获取参数信息，统一保存在ServiceMethod对象中

具体的解析过程比较长，主要是一些逻辑判断，也没有什么比较复杂的逻辑，这里不再具体分析，简单看一下下面的简略代码就好：

//解析方法注解
private void parseMethodAnnotation(Annotation annotation) {
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        ......
      } else if (annotation instanceof POST) {
        ......
      }
}

//解析参数注解
private ParameterHandler<?> parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {
      if (annotation instanceof Url) {
        ......
      } else if (annotation instanceof Path) {
        ......
        return new ParameterHandler.Path<>(name, converter, path.encoded());
      } else if (annotation instanceof Query) {
   		......
      } else if (annotation instanceof Header) {
          ......
        } 
        ......
      return null; // Not a Retrofit annotation.
}

至此ServiceMethod对象创建完毕，我们回到匿名类InvokeHandler的invoke()方法中。接下来Service对象又作为构造方法参数创建了OkhttpCall对象，最后serviceMethod调用adapt(okhttpCall)将结果最终返回。

 T adapt(Call<R> call) {
    return callAdapter.adapt(call);
  }

可以看到adapt()内部实际上是通过callAdapter调用了同名方法，callAdapter接口CallAdapter的实现类对象，使用这可以自己实现CallAdapter接口，这里是典型的策略模式的使用。

回到前面我们分析ServiceMethod的build()方法中有这么一行代码：

 callAdapter = createCallAdapter();

跟踪代码，它最终会走到Retrofit类的nextCallAdapter()方法，遍历callAdapterFactories集合通过工厂类获取到callAdapter实例

 public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
	......
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
    .......
  }

文章开头示例并没有添加任何的CallAdapter.Factory，其实Retrofit在通过build()模式最后构建的时候添加了一个默认的工厂类DefaultCallAdapterFactory，它的adapt()方法没有对Call对象做任何处理直接返回原始对象，即OkhttpCall对象，具体实现如下：

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();

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

    final Type responseType = Utils.getCallResponseType(returnType);

    //默认的CallAdapter匿名实现，adapt()方法直接返回了OkhttpCall
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        return call;
      }
    };
  }
}

梳理一下整个代理方法逻辑：
其实是读取被代理方法的注解、参数等信息，保存到ServiceMethod对象中（ServiceMethod其实就是一个各种请求配置的解析类和载体），创建Retrofit的Call对象OkhttpCall并返回给代理方法。

这里我们还可以看到代理方法的返回值类型取决于CallAdapter的adapt()方法的返回值类型。我们结合RxJava使用所接收到的Obserable类型，也一定是这里adapt()中实现其数据类型转换的，顺便上一下RxJava2CallAdapter的代码：

 @Override public Object adapt(Call<R> call) {
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }

3.Call对象发起请求并获取响应结果

同步请求：
OkhttpCall的execute方法内部其实是创建了Okhttp的Call对象执行了其execute()方法，请求逻辑转到了Okhttp中执行

@Override public Response<T> execute() throws IOException {

    okhttp3.Call call;
    synchronized (this) {
      ......
      if (call == null) {
        try {
         //创建Okhttp的Call对象
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException | Error e) {
          throwIfFatal(e); //  Do not assign a fatal error to creationFailure.
          creationFailure = e;
          throw e;
        }
      }
    }
	......
	//通过Call对象真正发起请求
    return parseResponse(call.execute());
  }

异步请求同理，仅仅是把Okhttp的异步调用封装了一下，和同步请求同样通过parseResponse()对Okhttp获取到的Response进行了进一步解析：

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) {
      catchingBody.throwIfCaught();
      throw e;
    }
  }

从方法内部可以很清晰的看到，Retrofit对Okhttp请求的Response进行了初步解析，帮我们处理了一些常见的状态码逻辑，最后调用serviceMethod.toResponse(catchingBody)对Response进行了进一步的转换

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

这里又涉及到Converter的概念，在这里它是一个转换器，用于把响应结果Response进行处理加工转换成其他类型的对象。它是一个接口，我们同样可以实现自己的转换策略，开源库考虑到不同使用场景的扩展性，策略设计模式还是很常见的。

与CallAdapter逻辑相似Retrofit在build()构建的时候同样给我们创建了默认的Converter工厂类对象：BuiltInConverters。默认的的Converter同样没有对okhttp的Response做任何处理，我们当然也可以自定义Converter对其进行加工，参考GsonConverterFactory实现：

//默认的ResponseConverter
 static final class StreamingResponseBodyConverter implements Converter<ResponseBody, ResponseBody> {
    static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();

    @Override public ResponseBody convert(ResponseBody value) {
      return value;
    }
  }
  
//GsonConverter
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      T result = adapter.read(jsonReader);
      if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
        throw new JsonIOException("JSON document was not fully consumed.");
      }
      return result;
    } finally {
      value.close();
    }
  }
}

在OkhttpCall的parseResponse()方法最后，Okhttp响应结果Response会被进一步封装成Retrofit的Response，同步请求直接返回，异步请求通过回调返回。
至此，整个Retrofit执行流程分析完毕。