retrofit 源码分析

Retrofit 2 源码分析

---

惯例从一个例子入手

//使用Builder模式创建Retrofit对象
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

//创建Service对象, 这里统称为Service, 其实是一个接口的描述
GitHubService service = retrofit.create(GitHubService.class);

//发起请求调用
Call> repos = service.listRepos("octocat");

定义Service接口

其实就是用元数据很清晰的描述一个HTTP请求以及参数等等

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

使用Builder模式创建Retrofit对象

这里有两个点比较有趣, 为一些属性做了default处理, 一个是保护性拷贝

public static final class Builder {
    private final Platform platform;
    private okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List converterFactories = new ArrayList<>();
    private final List adapterFactories = new ArrayList<>();
    private Executor callbackExecutor;
    private boolean validateEagerly;
    
    
    ...
    
     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();
      }

      //注意看这里, 这里用了个保护性拷贝创建两个list 比较有趣。
      // Make a defensive copy of the adapters and add the default Call adapter.
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      
      //这里后续会看到他添加了默认的CallAdapterFactory
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

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

创建Service的对象, 动态代理模式

如果说前面的GitHub 接口是对一个请求的描述, 那么create方法就是要生成这个被描述请求的对象。
通过create 方法, 动态代理GitHub这个接口, 解析Annotation, 生成调用对象等

public  T create(final Class service) {
    //验证service 是interface 并且, 不能继承其他接口
    Utils.validateServiceInterface(service);
    //是否急切的先执行loadServiceMethod
    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 {
            // 如果调用者的class对象是Object, 则执行默认的method 调用
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            
            //这里可以认为是解析调用方法参数等, 生成serviceMethod对象
            ServiceMethod serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
                
            //根据serviceMethod 最终实例化OkHttpCall 对象
            OkHttpCall