Retrofit源码分析

1. 概述

Retrofit和OkHttp都来自于Square公司,而且都是在用来处理HTTP请求的,先来看下用OkHttp处理HTTP请求的实现:

String url = "https://api.github.com/users/octocat/repos";
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
        .url(url)
        .build();
client.newCall(request).enqueue(new okhttp3.Callback() {
    @Override
    public void onFailure(okhttp3.Call call, IOException e) {

    }

    @Override
    public void onResponse(okhttp3.Call call, Response response) throws IOException {
        List<Repo> repos = JSON.parseArray(response.body().toString(), Repo.class);
    }
});

可以看到在发起HTTP请求之前需要构造Request对象,请求完成后还需要将Response转化成所需要的对象,如果每一个HTTP请求都要这么复杂,那对于需要成百上千个HTTP请求的应用来说无疑是多了很多的重复代码,对于一个追求完美的程序员来说是无法容忍的;因此Square公司推出了Retrofit框架,Retrofit的中文意思是改造,顾名思义就是在OkHttp的基础上的进行的一次升级和封装,Retrofit通过定义接口的方式来构建Request对象,通过Converter将Response转化为需要的对象,这就是Retrofit存在的意义,下面看一下通过Retrofit框架实现与上面一样的功能:

// 构建Retrofit实例,一般都是通过单例模式创建的,所以一般会创建一个Manager类来创建和管理Retrofit对象
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.github.com/")
        // 添加一个用来创建Converter实例的工厂,该工厂是针对于json字符串的
        .addConverterFactory(FastJsonConverterFactory.create())
        .build();

// 在一个项目中,都是会对HTTP请求进行分类的,每一个分类都会创建一个与之对应的一个接口(比如下面的GitHubService接口)
// 每一个接口包含多个方法,每一个方法对应于一个HTTP请求(执行的时候会根据方法来构建Request对象)
// 每一个方法的返回值都是一个Call对象,默认是ExecutorCallbackCall对象,针对于rxjava2就是返回的就是Observable对象
public interface GitHubService {
    @GET("users/{user}/repos")
    Call<List<Repo>> listRepos(@Path("user") String user);
}

// 下面就是发起HTTP的代码,相比于OkHttp来说简化了Request对象的构建和Response的解析
GitHubService service = retrofit.create(GitHubService.class);
Call<List<Repo>> repos = service.listRepos("octocat");
repos.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, retrofit2.Response<List<Repo>> response) {
        List<Repo> repoList = response.body();
    }

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

    }
});

上面代码中提到的Call对象,其实是对OkHttp中RealCall的封装,这样的设计也体现了一种设计模式(门面模式):

门面模式(Facade Pattern)也叫做外观模式,是一种比较常用的封装模式,其定义如下:
Provide a unified interface to a set of interfaces in a subsystem.
Facade defines a higher-level interface that makes the subsystem easier to use.
(要求一个子系统的外部和内部的通信必须通过一个统一的对象进行。门面模式提供一个高层次的接口,
使得子系统更易于使用。)

所以Retrofit示例代码中提到的Call对象就是门面模式中说到的统一的对象。
Retrofit源码地址

2. 预备知识

2.1 Java编程语言中的Type

在Retrofit中会对Method实例(对应上面的例子,就是GitHubService的listRepos方法对应的实例)进行解析,因此会对Method实例的返回值类型和参数类型进行解析,所以这里带大家了解一下Java编程语言中的Type:


Type是Java 编程语言中所有类型的公共高级接口,Java 编程语言中的类型包括(其中后面四种类型是泛型的三种表现形式):
1 基本类型:也就是我们所说的java中的8中基本类型。
2 原始类型(raw types):对应Class。
3 类型变量(TypeVariable):
  该接口代表各种类型变量的公共接口,如Collection<T>中的T就是一个类型变量。
  主要方法:
  Type[] getBounds():获取上边界Type数组。
4 参数化类型(ParameterizedType):
  该接口代表参数化类型,例如Collection<String>。
  主要方法:
  Type[] getActualTypeArguments():获取参数化类型中的所有类型的数组。
  Type getRawType():获取参数化类型中<>前面的类型。
5 泛型数组类型(GenericArrayType):
  该接口代表一种数组类型,其组件类型为参数化类型或类型变量
  ,例如参数化类型数组Map<String, String>[]map和类型变量数组T[] arr。
  主要方法:
  Type getGenericComponentType():返回其组件类型。

除了上面泛型的三种表现形式外还有一种并不属于Java类型的表达形式:
通配符类型(WildcardType):
该接口代表通配符类型表达式,例如 如 ?、? extends Number 或 ? super Integer.
主要方法:
Type[] getUpperBounds():获取上边界Type数组。
Type[] getLowerBounds():获取下边界Type数组。

3. 源码分析

我会根据上面的例子解析分析,因此在分析的过程中会依赖上面的代码
首先看一下Retrofit处理http请求的时序图:


3.1 构建Retrofit实例

上图中的前8步通过建造者模式构建了一个Retrofit实例

建造者模式(Builder Pattern,也叫生成器模式)的定义:
Separate the construction of a complex object from its representation so that 
the same construction process can create different representations.
(将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。)

构建的过程也是对Retrofit实例进行初始化的过程,初始化的结果:
1> callFactory : 顾名思义是用来创建Call对象的,默认为OkHttpClient类型对象,没错,这就就是OkHttp中的OkHttpClient,通常情况下不会修改该默认值。
2> baseUrl:默认值为HttpUrl.parse("https://api.github.com/"),通常情况下在同一个项目中所有的HTTP请求URL的 protocol :// hostname[:port] 部分是相同的,即在项目中baseUrl对应的值,如果一个项目中HTTP请求URL的 protocol :// hostname[:port] 部分多余一种的话,就需要多个Retrofit对象与之对应。
3> converterFactories:顾名思义是用来保存Converter.Factory对象的容器(Converter.Factory是用来创建Converter对象的,Converter有两个常用的方法requestBodyConverter和responseBodyConverter,说到这里相信大家应该明白了Converter的作用了),默认只包含一个BuiltInConverters对象,通过第4步就可以在converterFactories集合的末尾添加一个FastJsonConverterFactory对象,这也是为什么接口的方法中@Body注解的参数是RequestBody类型时,就不会调用FastJsonRequestBodyConverter的convert方法的原因。
4> callAdapterFactories:顾名思义是用来保存CallAdapter.Factory对象的容器(CallAdapter.Factory是用来创建CallAdapter对象的,CallAdapter的adapt方法会得到Call<R>对象的代理,这里就用到了装饰者模式),默认只包含一个ExecutorCallAdapterFactory对象,通过第5步就可以在ExecutorCallAdapterFactory对象的前面插入一个RxJava2CallAdapterFactory对象。
5> callbackExecutor:顾名思义就是用来控制Retrofit示例代码中Callback执行的线程,默认值为MainThreadExecutor,即默认在主线程执行。

上面5条都是根据源码得到的,不可能在该篇文章中完全分析所有细节,只有自己亲自查阅源码才会收获更多,我只会点到为止,这样你们可以更加快速的翻阅源。

3.2 创建GitHubService接口的实例

接下来看一下第9、10步的源码:

  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, @Nullable 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<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

可以看到使用了动态代理模式为GitHubService接口创建实例。

代理模式(Proxy Pattern)是一个使用率非常高的模式,其定义如下:
Provide a surrogate or placeholder for another object to control access to it.
(为其他对象提供一种代理以控制对这个对象的访问)

动态代理:
动态代理是在实现阶段不用关心代理谁,而在运行阶段才指定代理哪一个对象。

3.3 执行GitHubService接口中的方法

第11步调用GitHubService接口中的方法,此时InvocationHandler的invoke方法被执行(即第12步),对应于上面的例子listRepos方法对应的就是invoke方法中的参数method。

3.3.1 根据Method实例构建ServiceMethod实例

第13步loadServiceMethod方法被调用,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) {
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

为了提高运行时的效率,构建ServiceMethod实例的过程中使用了缓存机制,对于已经构建过ServiceMethod实例的Method实例,直接将缓存中与之对应的ServiceMethod实例返回,接下来的14到33步就是根据Method实例构建ServiceMethod实例的过程:

// 第14步对应的代码
Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;
  this.method = method;
  // 对应与上面例子,methodAnnotations保存的时GitHubService接口的listRepos方法的注解(即@GET("users/{user}/repos"))
  this.methodAnnotations = method.getAnnotations();
  // 对应与上面例子,parameterTypes保存的是GitHubService接口中listRepos方法的所以参数的类型
  this.parameterTypes = method.getGenericParameterTypes();
  // 对应与上面例子,parameterAnnotationsArray保存的是GitHubService接口中listRepos方法的所以参数的注解
  this.parameterAnnotationsArray = method.getParameterAnnotations();
}

// 第15对应的代码
public ServiceMethod build() {
  // 第16步到21步,完成CallAdapter实例的创建,默认为ExecutorCallAdapterFactory创建
  // 的CallAdapter实例,对于rxjava2而言对应的是RxJava2CallAdapter实例
  callAdapter = createCallAdapter();
  // 对应于上面的例子,responseType代表的是List<Repo>
  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?");
  }
  // 第22步到27步,完成 Converter<ResponseBody, T> responseConverter 实例的创建,
  // 对于fastjson而言对应的是FastJsonResponseBodyConverter实例
  // ,用于将ResponseBody中的json字符串转化成指定类型的对象
  responseConverter = createResponseConverter();

  // 第28到第30步,用于解析方法上的注解,对应于上面的例子就是对@GET("users/{user}/repos")的解析
  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }

  // 方法上的注解解析完成后,httpMethod为空代表方法上没有@GET, @POST等类型的注解
  if (httpMethod == null) {
    throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
  }

  // 对于没有请求体的情况,方法上不应该有@Multipart和@FormUrlEncoded注解
  if (!hasBody) {
    if (isMultipart) {
      throw methodError(
          "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
    }
    if (isFormEncoded) {
      throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
          + "request body (e.g., @POST).");
    }
  }

  // 第31、32步 完成方法参数上注解的解析,对应于上面的例子就是对@Path("user")的解析
  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];
    // 对参数的类型进行检查,不应该包含 类型变量 和 通配符类型,具体可以参考2.1
    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);
  }

  if (relativeUrl == null && !gotUrl) {
    throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
  }
  if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
    throw methodError("Non-body HTTP method cannot contain @Body.");
  }
  if (isFormEncoded && !gotField) {
    throw methodError("Form-encoded method must contain at least one @Field.");
  }
  if (isMultipart && !gotPart) {
    throw methodError("Multipart method must contain at least one @Part.");
  }

  return new ServiceMethod<>(this);
}
3.3.2 发起http请求
  // 第35步,创建OkHttpCall实例
  OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
    this.serviceMethod = serviceMethod;
    this.args = args;
  }

  // 第36步,默认情况下callAdapter代表ExecutorCallAdapterFactory创建的CallAdapter实例
  T adapt(Call<R> call) {
    return callAdapter.adapt(call);
  }

  // 第37步,返回ExecutorCallbackCall实例
  @Override public Call<Object> adapt(Call<Object> call) {
    return new ExecutorCallbackCall<>(callbackExecutor, call);
  }

  // 第39步enqueue方法发起http请求
 @Override public void enqueue(final Callback<T> callback) {
  checkNotNull(callback, "callback == null");

  // delegate是OkHttpCall实例,enqueue方法中会创建Request对象
  delegate.enqueue(new Callback<T>() {
    @Override public void onResponse(Call<T> call, final Response<T> response) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          if (delegate.isCanceled()) {
            // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
            callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
          } else {
            callback.onResponse(ExecutorCallbackCall.this, response);
          }
        }
      });
    }

    @Override public void onFailure(Call<T> call, final Throwable t) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          callback.onFailure(ExecutorCallbackCall.this, t);
        }
      });
    }
  });
}

4 细节分析

第3步中只是粗略的分析了Retrofit处理HTTP请求的大致流程,那么这一节就会详细分析一些关键点

4.1 CallAdapter实例的创建

第16步到21步,完成CallAdapter实例的创建,下面是Google官方对CallAdapter的adapt方法的注解:

  /**
   * Returns an instance of {@code T} which delegates to {@code call}.
   */
  T adapt(Call<R> call);

这句话也充分的说明CallAdapter是用来干嘛的了,同时也体现一种设计模式(装饰者模式),接下来看一下16步createCallAdapter方法的源码:

private CallAdapter<T, R> createCallAdapter() {
  Type returnType = method.getGenericReturnType();
  // 返回值类型中不能包含类型变量和通配符表达式
  if (Utils.hasUnresolvableType(returnType)) {
    throw methodError(
        "Method return type must not include a type variable or wildcard: %s", returnType);
  }
  // 返回值类型不能为void
  if (returnType == void.class) {
    throw methodError("Service methods cannot return void.");
  }
  // 获取方法上的注解,对应于上面的示例就是获取listRepos方法的注解 @GET("users/{user}/repos")
  Annotation[] annotations = method.getAnnotations();
  try {
    // 根据方法的返回值类型和注解来创建CallAdapter实例
    return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
  } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw methodError(e, "Unable to create call adapter for %s", returnType);
  }
}

上面的蛛丝已经很清楚来,下面直接看第17、18步的源码:

public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
  return nextCallAdapter(null, returnType, annotations);
}

public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
    Annotation[] annotations) {
  checkNotNull(returnType, "returnType == null");
  checkNotNull(annotations, "annotations == null");

  // 因为skipPast为null,所以start为0,
  int start = callAdapterFactories.indexOf(skipPast) + 1;
  // 默认情况下callAdapterFactories包含一个ExecutorCallAdapterFactory对象,
  // 对于RxJava2CallAdapterFactory对象,有兴趣的同学可以自己研究一下,后面的分析过程中也只会基于ExecutorCallAdapterFactory对象进行分析。
  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实例,就会抛出IllegalArgumentException异常
  StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
      .append(returnType)
      .append(".\n");
  if (skipPast != null) {
    builder.append("  Skipped:");
    for (int i = 0; i < start; i++) {
      builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
    }
    builder.append('\n');
  }
  builder.append("  Tried:");
  for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
    builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
  }
  throw new IllegalArgumentException(builder.toString());
}

接下来看ExecutorCallAdapterFactory的get方法,即第19步:

@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
  // 如果返回值的类型不是Call类型,返回null,那么上面第18步中就会抛出IllegalArgumentException异常
  if (getRawType(returnType) != Call.class) {
    return null;
  }
  // returnType必须是参数化类型(对应于上面的例子,returnType代表的是Call<List<Repo>>),否者会抛出IllegalArgumentException异常
  // responseType是参数化类型中的类型,对应于上面的例子,responseType代表的是List<Repo>
  final Type responseType = Utils.getCallResponseType(returnType);
  return new CallAdapter<Object, Call<?>>() {
    @Override public Type responseType() {
      return responseType;
    }

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

到这里CallAdapter实例的创建完成了,总结一下关键点:
1> 方法的返回值类型:必须是参数化类型,并且rawtype为Call类型,并且不能包含类型变量和通配符表达式,否者会抛出异常;
2> CallAdapter是用来为Call<R>创建一个代理对象T,默认情况下T是ExecutorCallbackCall类型,对应于rxjava2情况下T通常是BodyObservable类型。

4.2 Converter<ResponseBody, T>实例的创建

第22步到27步,完成 Converter<ResponseBody, T>实例的创建,接下来看一下第22步的源码:

 // 该方法返回的Converter对象是用来将ResponseBody转化成需要类型的对象,
 // 对应于上面的示例就是转化成<List<Repo>类型的对象。
private Converter<ResponseBody, T> createResponseConverter() {
  Annotation[] annotations = method.getAnnotations();
  try {
    // 第19步中提到过,对应于上面的例子,responseType代表的是List<Repo>
    // 对应于上面的例子,annotations对应于listRepos方法的注解 @GET("users/{user}/repos")
    return retrofit.responseBodyConverter(responseType, annotations);
  } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw methodError(e, "Unable to create converter for %s", responseType);
  }
}

接下来看23、24步:

public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
  return nextResponseBodyConverter(null, type, annotations);
}

public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
    @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
  checkNotNull(type, "type == null");
  checkNotNull(annotations, "annotations == null");

  // 因为skipPast为null,所以start为0
  int start = converterFactories.indexOf(skipPast) + 1;
  // 默认情况下converterFactories包含一个BuiltInConverters对象,
  // 在项目中一般都会配置一个针对于fastjson的FastJsonResponseBodyConverter对象。
  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;
    }
  }

  // 如果没有找到合适的Converter<ResponseBody, T>实例,就会抛出IllegalArgumentException异常
  StringBuilder builder = new StringBuilder("Could not locate ResponseBody converter for ")
      .append(type)
      .append(".\n");
  if (skipPast != null) {
    builder.append("  Skipped:");
    for (int i = 0; i < start; i++) {
      builder.append("\n   * ").append(converterFactories.get(i).getClass().getName());
    }
    builder.append('\n');
  }
  builder.append("  Tried:");
  for (int i = start, count = converterFactories.size(); i < count; i++) {
    builder.append("\n   * ").append(converterFactories.get(i).getClass().getName());
  }
  throw new IllegalArgumentException(builder.toString());
}

接下来看一下25步:

// 如果方法的返回值为Call<ResponseBody>,那么BuiltInConverters的responseBodyConverter方法的返回值不会为null
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
    Retrofit retrofit) {
   if (type == ResponseBody.class) {
    return Utils.isAnnotationPresent(annotations, Streaming.class)
        ? StreamingResponseBodyConverter.INSTANCE
        : BufferingResponseBodyConverter.INSTANCE;
  }
  if (type == Void.class) {
    return VoidResponseBodyConverter.INSTANCE;
  }
  return null;
}

// 对应于上面的例子,listRepos方法的返回值不是Call<ResponseBody>类型,
// 那么FastJsonConverterFactory的responseBodyConverter方法的返回值会被使用
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
                                                        Retrofit retrofit) {
  return new FastJsonResponseBodyConverter<>(type, mParserConfig, featureValues, features);
}

到这里Converter<ResponseBody, T>实例的创建完成了,总结一下关键点:
1> Converter<ResponseBody, T>是用来将ResponseBody对象转化成方法的返回值类型中的参数类型,对应于上面的例子,就是List<Repo>类型。
2> 如果方法的返回值为Call<ResponseBody>,那么BuiltInConverters的responseBodyConverter方法的返回值不会为null并且会被使用;否者FastJsonResponseBodyConverter对象会被使用。

4.3 OkHttpCall发起HTTP请求

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 {
        // 创建OkHttp中的RealCall实例
        call = rawCall = createRawCall();
      } catch (Throwable t) {
        throwIfFatal(t);
        failure = creationFailure = t;
      }
    }
  }

  if (failure != null) {
    callback.onFailure(this, failure);
    return;
  }

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

  // 调用RealCall的enqueue方法发起HTTP请求
  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方法
        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方法
        callback.onFailure(OkHttpCall.this, e);
      } catch (Throwable t) {
        t.printStackTrace();
      }
    }
  });
}

接下来看一下createRawCall和parseResponse方法:

private okhttp3.Call createRawCall() throws IOException {
  // 根据方法的参数构建Request实例,并且使用Request实例作为参数构建RealCall实例
  okhttp3.Call call = serviceMethod.toCall(args);
  if (call == null) {
    throw new NullPointerException("Call.Factory returned null.");
  }
  return call;
}

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 {
    // 对应与上面的例子,下面这句代码会使用Converter<ResponseBody, T>实例将catchingBody转化为List<Repo>类型对象。
    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;
  }
}

到这里OkHttpCall发起HTTP请求的过程分析完了。

5 总结

到这里源码已经分析完了,Retrofit处理HTTP请求主要流程为(为了便于说明,会用到上面的例子):
1> 首先创建Retrofit实例和GitHubService接口的实例。
2> 然后调用GitHubService接口中的listRepos方法(对listRepos进行解析,得到与之对应serviceMethod对象,然后调用serviceMethod对象的adapt方法得到listRepos方法的Call<List<Repo>>类型返回值)。
3> 调用Call的enqueue方法发起请求。

4.0 参考

Retrofit分析-漂亮的解耦套路

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 141,621评论 1 298
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 60,780评论 1 254
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 93,376评论 0 211
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 40,770评论 0 174
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 48,482评论 1 252
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 38,637评论 1 172
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,297评论 2 267
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,094评论 0 165
  • 想象着我的养父在大火中拼命挣扎,窒息,最后皮肤化为焦炭。我心中就已经是抑制不住地欢快,这就叫做以其人之道,还治其人...
    爱写小说的胖达阅读 28,855评论 6 228
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 32,420评论 0 213
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,200评论 2 213
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 30,521评论 1 224
  • 白月光回国,霸总把我这个替身辞退。还一脸阴沉的警告我。[不要出现在思思面前, 不然我有一百种方法让你生不如死。]我...
    爱写小说的胖达阅读 24,181评论 0 31
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,065评论 2 213
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 31,424评论 3 202
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,590评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 25,947评论 0 163
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 33,406评论 2 230
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 33,509评论 2 229

推荐阅读更多精彩内容