Android网络编程-Retrofit源码角度分析Http

上一篇讲解了OKHttp，本篇来介绍下它的黄金搭档Retrofit，OKHttp+Retrofit是网络框架的不二之选。同是Square出品，和OKHttp融合起来非常简单。
Retofit是一个RESTful的HTTP网络请求框架，有以下特点：

• 基于OKHttp
• 通过注解配置网络请求参数
• 支持同步、异步请求
• 支持多种序列化、反序列化格式
• 解耦彻底、模块高度封装，使用很多设计模式来实现

基本使用

下面讲解的是官网的例子

创建网络请求接口

public interface GitHubService {
  @GET("users/{user}/repos")
  Call> listRepos(@Path("user") String user);
}

创建Retrofit实例(使用建造者模式)

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

创建网络接口实例

GitHubService service = retrofit.create(GitHubService.class);

Call> repos = service.listRepos("yeungeek");

发送网络请求

默认返回的是OKHttpCall，实际真正发送请求的就是OKHttp

同步

Response> list = repos.execute()

异步

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

   @Override
   public void onFailure(Call> call, Throwable t) {
   }
});

请求流程

具体的请求流程可以分为7大步骤

retrofit

1. 解析网络请求接口的注解，配置网络请求参数
2. 通过动态代理生成网络请求对象
3. 通过CallAdapter，将网络请求对象进行平台适配(Android,Java8)
4. 通过网络请求执行器(Call)，发送网络请求
5. 通过Converter进行数据解析
6. 通过回调执行器，进行线程切换
7. 在主线程处理返回结果

Refrofit最大特点是使用了大量的设计模式，来进行解耦，下图是完整的流程图(来自Stay 在 Retrofit分析-漂亮的解耦套路)：

retrofit 流程图

接下来通过源码分析，详细讲解上面的流程

源码分析

Retrofit初始化

Retrofit retrofit = new Retrofit  //1. Retrofit声明
    .Builder()                    //2. Builder
    .baseUrl("https://api.github.com/")   //3. baseUrl
    .addConverterFactory(GsonConverterFactory.create())  //4. Converter Factory
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())  //5. CallAdapter Factory
    .build();                    //6. 生成实例

Retrofit声明

在使用Retrofit时，首先通过建造者模式构建Retrofit。

public final class Retrofit {
  private final Map> serviceMethodCache = new ConcurrentHashMap<>();

  final okhttp3.Call.Factory callFactory;
  final HttpUrl baseUrl;
  final List converterFactories;
  final List callAdapterFactories;
  final @Nullable Executor callbackExecutor;
  final boolean validateEagerly;

  Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List converterFactories, List callAdapterFactories,
      @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
    this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
  }
  ......
}

• serviceMethodCache：网络请求配置对象缓存，通过解析网络请求接口后得到请求对象
• callFactory：网络请求器工厂(Call)，默认实现是OKHttp
• baseUrl：网络请求Url地址
• converterFactories：数据转换器工厂集合
• callAdapterFactories：请求适配器工厂集合
• callbackExecutor：回调方法执行器
• validateEagerly：是否提前验证请求方法

剩下的步骤都是来初始化上面的参数

Builder

public static final class Builder {
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List converterFactories = new ArrayList<>();
    private final List callAdapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
    }

    public Builder() {
      this(Platform.get());
    }
    ......
}

Builder中的参数和 Retrfit 是意义一一对应的，默认构造函数进行平台的选择

class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }
  ......
}

通过反射来判断选择Android还是Java8，以前版本还有对IOS平台的支持，最新版本已经去掉了。
我们看下Android平台：

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      //默认回调执行器，会切换到主线程
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      //默认的 CallAdapter
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

baseUrl

public Builder baseUrl(String baseUrl) {
   checkNotNull(baseUrl, "baseUrl == null");
   HttpUrl httpUrl = HttpUrl.parse(baseUrl);
   if (httpUrl == null) {
     throw new IllegalArgumentException("Illegal URL: " + baseUrl);
   }
   return baseUrl(httpUrl);
 }
......
public Builder baseUrl(HttpUrl baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  List pathSegments = baseUrl.pathSegments();
  //检查合法性
  if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
  }
  this.baseUrl = baseUrl;
  return this;
}

把String url 转换成HttpUrl，会对baseUrl进行合法性校验(URL参数是不是以"/"结尾)

ConverterFactory

public Builder addConverterFactory(Converter.Factory factory) {
   converterFactories.add(checkNotNull(factory, "factory == null"));
   return this;
 }

把factory加到数据转换器集合中，看下GsonFactory.create()具体的实现：

public static GsonConverterFactory create(Gson gson) {
  if (gson == null) throw new NullPointerException("gson == null");
  return new GsonConverterFactory(gson);
}

private final Gson gson;

private GsonConverterFactory(Gson gson) {
  this.gson = gson;
}

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

@Override
public Converter requestBodyConverter(Type type,
    Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
  TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
  return new GsonRequestBodyConverter<>(gson, adapter);
}

GsonConverterFactory使用Gson 为初始化参数，实现responseBodyConverter和requestBodyConverter接口，进行真正的数据转换处理。

CallAdapterFactory

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  callAdapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

把factory加到请求适配器工厂集合中，Android 平台默认实现是ExecutorCallAdapterFactory，后面再进行详细讲解。

build

最后一步build生成Retrofit对象

public Retrofit build() {
  if (baseUrl == null) {
    throw new IllegalStateException("Base URL required.");
  }
  
  okhttp3.Call.Factory callFactory = this.callFactory;
  if (callFactory == null) {
    callFactory = new OkHttpClient();
  }

  Executor callbackExecutor = this.callbackExecutor;
  if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
  }

  // Make a defensive copy of the adapters and add the default Call adapter.
  List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
  callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

  // Make a defensive copy of the converters.
  List converterFactories =
      new ArrayList<>(1 + this.converterFactories.size());

  // 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());
  converterFactories.addAll(this.converterFactories);

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

• callFactory配置，默认OkHttpClient
• callbackExecutor配置，Android 平台默认使用MainThreadExecutor
• callAdapterFactories配置，先加入自定义的callAdapter，然后再加入defaultCallAdapterFactory
• converterFactories配置，先加入内建转换器(BuiltInConverters)，然后加入自定义的数据转换器
• 生成Retrofit对象

创建网络接口实例

public interface GitHubService {
  @GET("users/{user}/repos")
  Call> listRepos(@Path("user") String user);
}
//创建接口实例
GitHubService service = retrofit.create(GitHubService.class);
//生成请求对象
Call> repos = service.listRepos("yeungeek");

Retrofit通过外观模式和动态代理生成网络接口实例，网络接口的请求参数从接口声明获取

create

public  T create(final Class 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 serviceMethod =
              (ServiceMethod) loadServiceMethod(method);
          OkHttpCall