Retrofit 源码学习与使用

预习

• 动态代理
  
• 反射

本文主要对retrofit的源码进行学习，了解，学习其设计模式，与实现方式。

retrofit 的基本用法：

1. Retrofit turns your HTTP API into a Java interface.
   （将HTTP API转换为Java接口。）

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

2. The Retrofit class generates an implementation of the GitHubService interface.
   （Retrofit类生成GitHubService接口的实现。）

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

GitHubService service = retrofit.create(GitHubService.class);
复制代码

3. Each Call from the created GitHubService can make a synchronous or asynchronous HTTP request to the remote webserver.
   (创建的GitHubService的每个调用都可以向远程web服务器发出同步或异步的HTTP请求。)

Call> repos = service.listRepos("octocat");
复制代码

---

A : service接口的构建

1. 首先创建一个service的接口类。
2. 指定请求方式 常见的有GET,POST,PUT,DELETE...,注意大小写。
3. 配置请求地址，注意path的配置规则（见retrofit 使用教程的7.2）
   

BaseUrl	和URL有关的注解中提供的值	最后结果
http://localhost:4567/path/to/other/	/post	http://localhost:4567/post
http://localhost:4567/path/to/other/	post	http://localhost:4567/path/to/other/post
http://localhost:4567/path/to/other/	github.com/ikidou	github.com/ikidou

• 如果你在注解中提供的url是完整的url，则url将作为请求的url。
• 如果你在注解中提供的url是不完整的url，且不以 / 开头，则请求的url为baseUrl+注解中提供的值
• 如果你在注解中提供的url是不完整的url，且以 / 开头，则请求的url为baseUrl的主机部分+注解中提供的值

4. 指定请求的回调对象,默认返回retrofit的Call对象，这里我们可以
   

• 通过实现retrofit的CallAdapter 接口，来自定义我们的返回对象。
• 再继承CallAdapter.Factory生成我们自己的Factory,在get()方法返回我们自定义的CallAdapter。
• 最后调用Retrofit.Builder的addCallAdapterFactory(Factory)

5. 指定请求结束后我们要接收的类型，如：okHttp返回默认的是ResponseBody,通过Retrofit的Converter可以转换为我们需要的 string 或 反序列化为java Bean对象等。

• 定义一个MyConvert类实现retrofit的Converter接口。
• 定义一个MyConvertFactory继承retrofit的Converter.Factory,实现responseBodyConverter()返回我们自定义的MyConvert类。
• 使用Retrofit.Builder.addConverterFactory（new MyConvertFactory()）添加我们自定义的Factory.

6. 定义我们请求的方法名字。
7. 请求参数的注解 见（见retrofit 使用教程的第三类：参数类）
   

8. 请求参数的名字
9. 参数类型
10. 参数名称

---

B : retrofit的构建，源码分析

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();
复制代码

我们可以看到retrofit的构建使用了builder模式。

1. 看一下Retrofit.Builder类：

/**
   * Build a new {@link Retrofit}.
   * 

   * Calling {@link #baseUrl} is required before calling {@link #build()}. All other methods
   * are optional.
   */
 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 adapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;
    ...
    }
复制代码

从源码可以看到：

• 从注释看到baseUrl()必须在build()之前调用，其它可以随意。
• platform 指定调用的平台，这里我们使用的是Android.
• callFactory okhttp3的Call.Factory
• baseUrl 请求的root地址
• converterFactories 存储我们自定义的和系统默认提供的convertFactory见上面的A.5
• adapterFactories 存储我们自定义的和系统默认提供的adapterFactory 见上面的A.4
• callbackExecutor 线程调用类
• validateEagerly 为true时做一些预处理操作

2. build()方法的实现

  /**
     * Create the {@link Retrofit} instance using the configured values.
     * 

     * Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link
     * OkHttpClient} will be created and used.
     */
     //通过配置参数创建一个Retrofit的实例，如果没有配置HttpClient也没有配置CallFactory将采用默认的OkHttpClient
    public Retrofit build() {

      if (baseUrl == null) {
      // baseUrl不能为空
        throw new IllegalStateException("Base URL required.");
      }
        //配置HttpClient，可以看出retrofit默认采用OkHttpClient
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
        //指定callback回调方法的执行器，这里的platform是Android平台，可以看出默认下面的Android--Platform的MainThreadExecutor
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      //将我们自定义的adapterFactory添加到集合中
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      //将我们自定义的convertFactory添加到集合中
      List converterFactories = new ArrayList<>(this.converterFactories);
       // 返回Retrofit
      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
复制代码

Android--Platform

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();
      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);
      }
    }
  }
复制代码

经过build()操作后，我们配置好了一个我们想要的retrofit,接下来我们来看看这些配置是如何生效的，我们通过

GitHubService service = retrofit.create(GitHubService.class);
复制代码

来生成我们service接口的实现类。我们来看create()方法。

3. 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