<源码系列> Retrofit之二：源码分析

说明：
本文的源码分析较为粗浅，和其他源码“解析”的文章相比并未特别详细，个人觉得看别人的源码，将整体的思路和大框架了解了，理解了其思想原理足矣

很重要的一点：
一定要带着质疑别人所谓的的“解析”去分析，一定要结合源码有自己的理解，不能完全相信他人的观点，即便是所谓的“大神”，人，总有犯错的时候。

如果文中有哪里不对的地方，请多指教。

从调用的流程开始分析

流程

一、Retrofit的初始化

    // 初始化配置Retrofit
    retrofit = new Retrofit.Builder()
            .baseUrl(AppConfig.BASE_URL)
            //可设置自定义的client
            .client(getOkHttpClient())
            //可设置自定义的执行类CallAdapterFactory，可多个
            .addCallAdapterFactory(new CustCallAdapterFactory())
            //可设置自定义的解析类ConverterFactory，可多个
            .addConverterFactory(new CustConvertFactory())
            .build();

   private OkHttpClient getOkHttpClient() {
      if (okHttpClient == null) {
         okHttpClient = new OkHttpClient().newBuilder()
               .connectTimeout(15 * 1000, TimeUnit.MILLISECONDS)
               .readTimeout(15 * 1000, TimeUnit.MILLISECONDS)
               .retryOnConnectionFailure(true)
               .addInterceptor(xxxInterceptor)
               .build();
      }
      return okHttpClient;
   }

• 这里对Retrofit进行初始化，是通过构造者模式进行构建相关的参数数据
• addConverterFactory：为对象的序列化和反序列化添加转换器工厂
• addCallAdapterFactory：添加调用适配器工厂以支持除Call之外的服务方法返回类型

1、baseUrl：

• baseUrl的方法有多个重载，最终通过构造HttpUrl传入，一直传递给okhttp3.Request 中

  public Builder baseUrl(HttpUrl baseUrl)  //最终的调用
  public Builder baseUrl(String baseUrl)
  

  Request build() {
    HttpUrl url;
    HttpUrl.Builder urlBuilder = this.urlBuilder;
    if (urlBuilder != null) {
      url = urlBuilder.build();
    } else {
      // No query parameters triggered builder creation, just combine the relative URL and base URL.
      url = baseUrl.resolve(relativeUrl);
      if (url == null) {
        throw new IllegalArgumentException(
            "Malformed URL. Base: " + baseUrl + ", Relative: " + relativeUrl);
      }
    }
    //省略好多...
    return requestBuilder
        .url(url)
        .method(method, body)
        .build();
  }
  

• 如何动态切换Retrofit的BaseURL？
  Retrofit中接收的baseUrl（String），最终是作为HttpUrl（okhttp3包里的）的类型参数传入的，在HttpUrl中有个host的字段，可以通过反射进行修改

  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;
    }
  

二、Retrofit的请求和响应

    // ① 获取接口实现
    GitHubService service = retrofit.create(GitHubService.class);
    
    // ② 调用（下面同步或异步请求选其一）
    Call> repos = service.listRepos("octocat");
    
    // ③ 同步请求
    Response res = repos.execute();
    
    // ③ 异步请求
    repos.enqueue(new Callback() {
        @Override
        public void onResponse(Call call, Response response) {
            try {
                System.out.println(response.body().string());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public void onFailure(Call call, Throwable t) {
            t.printStackTrace();
        }
    });

    // 或者通过使用Observable，需要在初始化时进行配置：
    // addCallAdapterFactory(RxJava3CallAdapterFactory.createSynchronous())
   Observable call = mRetrofit.create(GitHubService.class).getUserData();
   call.subsribe(Xxx)

1、接口的实现类：

从Retrofit 的示例来看，只需要一个接口及接口方法即可，调用者无需实现接口的具体实现类，就可以调用其内的方法，接口的实现类是从哪来的呢？
通过Retrofit#create 方法获得了接口的实现类，其内部是通过 动态代理（模式） Proxy.newProxyInstance 来实现的：

  public  T create(final Class service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable 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);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)  //对default方法进行判断
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }

• 动态代理Proxy.newProxyInstance 的参数和返回结果：

  • classLoader[参数]：类加载器会产生新类（实现的是传入的接口）
  • class[][参数]：新类实现的接口，传进来（放到数组中）
  • invocationHandler 接口[参数]：执行方法体
  • T[返回值]：一个封装了请求参数的接口的类，来发起网络请求
    通过字节码（或打印其getClass()）可得出类似于：class com.sun.proxy.$Proxy0

• 获取（动态代理）接口的实例对象
  在Proxy中，通过newProxyInstance获取对象时，其中维护了一个代理类的缓存集合proxyClassCache【是WeakCache，其内部通过ConcurrentMap进行实际的缓存】，从此缓存中获取生成的接口实现类。
  而实现类的创建，是通过其固定的名称组装的类名：

   //Proxy中：
   //固定规则
   if (proxyPkg == null) {
      // if no non-public proxy interfaces, use com.sun.proxy package
      proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";  //com.sun.proxy
   }
   String proxyName = proxyPkg + proxyClassNamePrefix + num;
  
   byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
   try {
       //这里返回结果，加载byte[]来获取对象
       return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
   } catch (ClassFormatError e) {
       throw new IllegalArgumentException(e.toString());
   }
  

• InvocationHandler#invoke 内部解析：
  1】Retrofit#loadServiceMethod：
  在每次调用请求接口方法的时候，每次都会通过调用invocationHandler 中的loadServiceMethod 方法，
  在loadServiceMethod方法内部，会解析得到具体的接口方法的实现（如例子中的listRepos），进行调用invoke(args) 执行方法，发起网络请求。
  2】platform.isDefaultMethod(method)
invocationHandler 中对default 方法进行了判断。如果是默认方法则对默认方法进行调用
  default 是Java8的特性，在接口中可定义一些默认的方法：

   interface GithubApi {
        //默认方法
       default void hello() {
         //do something...
       }
   }
  

注：其中loadServiceMethod返回的类型是ServiceMethod ，其具体实现类为HttpServiceMethod。（似乎在之前的版本，2.2.0吧，ServiceMethod 是final 的，没有实现类。）

2、解析并装配参数（Okhttp请求）

在发送请求的时候，需要传入一些参数，对于Retrofit ，其请求的参数是放到注解上的，那它是如何对其进行解析的呢？是通过loadServiceMethod 方法内部对接口方法的注解及参数的解析而得。

• Retrofit#loadServiceMethod
  在loadServiceMethod 方法中，通过传入的Method类型的参数来封装成ServiceMethod 对象。
  获取具体的ServiceMethod对象流程（复用）：
  1】先从serviceMethodCache 缓存集合（ConcurrentHashMap）中根据Method取出ServiceMethod对象，有则直接返回
  2】若无，加锁，通过ServiceMethod#parseAnnotations解析方法的注解信息，创建对应的接口方法的实现；
  并缓存到集合中

• ConcurrentHashMap是个线程安全的集合（数组 + 链表 + 红黑树），因为网络请求都是在线程中去做的
• ServiceMethod 对象（具体实现为HttpServiceMethod）中封装了各种解析工厂类等请求和响应的数据类信息（CallAdapter 和Converter 等等）。

• ServiceMethod#parseAnnotations
  1】通过RequestFactory获取接口方法（如listRepos方法）上的注解和参数等信息
  如：baseUrl、headers等等
  2】获取返回值的泛型参数类型：
  method.getGenericReturnType()
  3】最后返回具体的注解信息结果：
  HttpServiceMethod.parseAnnotations
  通过HttpServiceMethod（ServiceMethod的实现类）进行 返回值包装类 和 返回值类的处理。

• HttpServiceMethod#parseAnnotations
  1】通过HttpServiceMethod#createCallAdapter 得到CallAdapter对象，方法内部根据参数进行匹配而得
  2】通过createResponseConverter得到Converter对象，方法内部根据参数匹配而得
  3】通过CallAdapter和Converter等对象构造出HttpServiceMethod具体实现的子类对象并返回
  ① 若不是kotlin协程的方法，则返回CallAdapted对象
  ② 否则返回协程方法相关的对象实例：SuspendForResponse或SuspendForBody

• ServiceMethod#invoke(args)
  执行接口方法的调用，进而发起网络请求
  invoke是ServiceMethod的抽象方法，由其直接子类HttpServiceMethod实现

• HttpServiceMethod.invoke(args)
  1】实现了父类ServiceMethod的方法
  2】创建Call对象：
  Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
  3】在实现的invoke方法中，又转交给HttpServiceMethod.adapt的抽象方法去完成的

• HttpServiceMethod.adapt：
  适配数据类型，并执行网络请求。
  1】具体如何将Call转换为指定的返回值包装类的，最终是交给实现了HttpServiceMethod的子类去完成的。
  2】如在CallAdapted中，其adapt方法是直接交由传入的CallAdapter的实现类来处理的
  在使用的例子中是RxJava3CallAdapterFactory内的具体实现RxJava3CallAdapter

3、“处理器”工厂：

这里我将类型适配器CallAdapter和解析转换器Converter称之为处理器，两者都用了 抽象工厂模式。
CallAdapter：是对响应的数据进行转换，由T类型转换为R类型，这里用了 适配器模式
Converter：是对请求数据和响应结果进行处理的数据类型转换的处理类。

• CallAdapter
  1】Retrofit中定义了接口CallAdapter，并由具体的子类实现如下方法：
  ① Type responseType();：返回具体的内部类型，如UserBean
  ② T adapt(Call call);：用于将retrofit2.Call转换为 返回值包装类，如Observable，并执行请求
  2】Retrofit默认只支持retrofit2.Call作为接口方法的 返回值包装类，
  可通过实现CallAdapter接口进行扩展Call，适配器的添加是通过在初始化Retrofit时配置的：
  Retrofit.Builder.addCallAdapterFactory方法，可加多个适配器来转换 返回值包装类，
  如可设置RxJava2CallAdapterFactory的Adapter
  3】而真正使用的只有一个，在Retrofit#nextCallAdapter中处理了相关逻辑
  根据类型和注解的相关信息，循环List 进行匹配，
  根据returnType（Type）、annotations（Annotation[]）等信息，匹配到了适配器（即返回结果不为null），则终止循环，直接返回这个factory。

  public interface CallAdapter {
  
    Type responseType();
  
    T adapt(Call call);
  }
  

• Converter
  1】Retrofit 中定义了接口Converter，并由具体的子类实现convert方法：
  ① T convert(F value)：即从F 到T（数据Bean）之间的转换操作。（多是处理POST请求）
  F 一般是RequestBody（请求体）或是ResponseBody （响应体），而T 是通过convert 方法返回的转换类型（如UserBean）。
  2】Retrofit提供了addConverterFactory方法，来配置添加转换实体的工厂对象，可加多个
  ① 在请求的时候，通过Retrofit#requestBodyConverter 方法（在构建RequestFactory中调用的）获取指定的 请求 数据解析器。
  ② 通过Retrofit#responseBodyConverter 方法（在HttpServiceMethod#createResponseConverter中获得的）获取指定的 响应 数据解析器。
  3】在HttpServiceMethod#parseAnnotations方法中调用了HttpServiceMethod#createResponseConverter，
  并在其内部获取到匹配的转换器，实际调用了Retrofit#responseBodyConverter方法
  4】在获取响应结果的转换器Retrofit#responseBodyConverter（实际调用了nextResponseBodyConverter方法）中，会循环遍历converterFactories转换器集合（addConverterFactory方法添加）
  直到根据type（Type）、annotations（Annotation[]）等信息，匹配到转换器（即返回结果不为null），则终止循环，直接返回这个factory。

  public interface Converter {
    T convert(F value) throws IOException;
  }
  

4、请求的发起OkHttpCall

Retrofit 中真正发起网络请求的，最终还是通过的OkHttp，所以要创建OkHttpCall

• OkHttpCall对象的创建：
  在HttpServiceMethod.invoke(args)的方法中，创建了OkHttpCall对象
  并将其实例传给了抽象方法adapt，是由子类决定如何通过OkHttp的实例发起网络请求

   @Override
   final @Nullable ReturnT invoke(Object[] args) {
     Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
     return adapt(call, args);
   }
  

• OkHttpCall#getRawCall -> createRawCall
  在方法中，创建了真正的请求调用对象，并传入了请求的相关信息
  返回的Call实例，是OkHttp中的请求对象，所以具体的请求还是由OkHttp完成的。

    private okhttp3.Call createRawCall() throws IOException {
      okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
      if (call == null) {
        throw new NullPointerException("Call.Factory returned null.");
      }
      return call;
    }
  

• OkHttpCall#enqueue / execute方法:
  1】OkHttpCall类中是具体发起请求的地方，即重写的enqueue / execute方法
  2】在接口（GitHubService）中定义的方法（listRepos）的返回类型Call ，这里的Call 实际上就是OkHttpCall类型
  3】当调用call.enqueue(Callback)时，enqueue就是OkHttpCall中的具体实现，而Callback（retrofit2.Callback）会在okhttp3.Callback回调时进行转换。
  4】HttpServiceMethod的子类实现的adapt方法中，根据传入的Call，又调用了其enqueue来执行请求的异步任务。

5、结果返回类型

例子中的Call> 是如何返回的呢？

• 类型说明
  首先先明确一下，Retrofit中如何对这个返回类型中的各个部分定义的：

  • returnType：接口方法中的 返回值类型，如Call>
  • rawType：接口方法中的 返回值包装类，如Call
  • responseType：接口方法中返回的数据Bean类型，如List

• 创建对象后的类型返回
  1】ReturnT invoke：
  上面1中说到，请求的方法通过invoke方法来调用的，那返回类型就从这里入手，
  而invoke 是在ServiceMethod 中定义的，具体实现在HttpServiceMethod 的invoke中（之前ServiceMethod无实现类的时候，代码直接写在Retrofit 中来实现的），
  而HttpServiceMethod#invoke 中又包了一层了adapt 抽象方法，adapt定义的返回值的类型ReturnT 就是接口方法的返回类型（如Call>）

  @Override
  final @Nullable ReturnT invoke(Object[] args) {
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }
  
  protected abstract @Nullable ReturnT adapt(Call call, Object[] args);
  

  2】ReturnT adapt(Call call, Object[] args)
adapt 方法的具体实现类是CallAdapted（非kotlin协程），就在HttpServiceMethod 中，是个内部类。此方法是通过CallAdapter 来实现的，它其中的adapt 方法就是一个类型转换器，具体后面介绍。

   @Override
   protected ReturnT adapt(Call call, Object[] args) {
     return callAdapter.adapt(call);
   }
  

  3】CallAdapter 的具体实现有很多，其中有个最原始的支持：DefaultCallAdapterFactory ，
  此类中直接创建的匿名内部类CallAdapter的实现没有具体转换，只转成了最基本的Call 类型，是因为要将线程中的请求结果，发送到主线程中，这其中就将Handler的消息发送包装了起来：

    return new CallAdapter>() {
      @Override
      public Type responseType() {
        return responseType;
      }
  
      @Override
      public Call