Retrofit源码解析

最新推荐文章于 2023-03-23 16:05:34 发布

小图包

最新推荐文章于 2023-03-23 16:05:34 发布

阅读量609

点赞数

分类专栏：框架源代码分析

本文链接：https://blog.csdn.net/u012845099/article/details/113997042

版权

框架源代码分析专栏收录该内容

7 篇文章 1 订阅

订阅专栏

一简单使用

引入依赖，

implementation 'com.squareup.okhttp3:okhttp:3.14.9'
implementation 'com.squareup.retrofit2:retrofit:2.6.0'
implementation 'com.squareup.retrofit2:converter-gson:2.6.0'
implementation 'com.google.code.gson:gson:2.8.6'
复制代码

定义接口WanApi，

interface WanApi {
    //用注解标记网络请求类型get，参数path
    @GET("article/list/{page}/json")
    Call<WanArticleBean> articleList(@Path("page") int page);
}
复制代码

发起请求，

class RetrofitActivity extends AppCompatActivity {
    final String SERVER = "https://www.xxx.com/";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(SERVER) //指定服务器地址
            .addConverterFactory(GsonConverterFactory.create()) //用gson将数据反序列化成实体
            .build();
        //运行期生成一个实现WanApi接口的类（字节码），并反射创建其实例
        WanApi wanApi = retrofit.create(WanApi.class);
        //得到Retrofit的call，他封装了okhttp的call
        Call<WanArticleBean> call = wanApi.articleList(0);
        //请求入队
        call.enqueue(new Callback<WanArticleBean>() {
            @Override
            public void onResponse(Call<WanArticleBean> call, Response<WanArticleBean> response) {
                //得到数据实体
                WanArticleBean bean = response.body();
                //不同于okhttp，Retrofit已经用Handler帮我们切回主线程了
                mBinding.tvResult.setText("" + bean.getData().getDatas().size());
            }

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

二实现原理

三源码分析

创建Retrofit对象

public final class Retrofit {
  //网络请求缓存，如：请求方法、请求头、请求体，各种适配器等
  private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();

  final okhttp3.Call.Factory callFactory;
  final HttpUrl baseUrl;
  final List<Converter.Factory> converterFactories;
  final List<CallAdapter.Factory> callAdapterFactories;
  final @Nullable Executor callbackExecutor;
  final boolean validateEagerly;
  
  Retrofit(okhttp3.Call.Factory callFactory
        , HttpUrl baseUrl
        ,List<Converter.Factory> converterFactories
        , List<CallAdapter.Factory> callAdapterFactories
        ,@Nullable Executor callbackExecutor
        , boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories;
    this.callAdapterFactories = callAdapterFactories; 
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
  }
  ...
  public static final class Builder {
    //平台信息
    private final Platform platform; 
    //okhttp3请求工厂，默认是okhttp
    private @Nullable okhttp3.Call.Factory callFactory;
    //基础请求地址
    private @Nullable HttpUrl baseUrl; 
    //转换器集合
    private final List<Converter.Factory> converterFactories = new ArrayList<>();
    //请求适配器集合
    private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
    //执行异步回调的线程切换
    private @Nullable Executor callbackExecutor;
    //是否提前解析方法注解标识
    private boolean validateEagerly;

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

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

    Builder(Retrofit retrofit) {
      platform = Platform.get();
      callFactory = retrofit.callFactory;
      baseUrl = retrofit.baseUrl;
      // Do not add the default BuiltIntConverters and platform-aware converters added by build().
      for (int i = 1,
          size = retrofit.converterFactories.size() - platform.defaultConverterFactoriesSize();
          i < size; i++) {
        converterFactories.add(retrofit.converterFactories.get(i));
      }
      // Do not add the default, platform-aware call adapters added by build().
      for (int i = 0,
          size = retrofit.callAdapterFactories.size() - platform.defaultCallAdapterFactoriesSize();
          i < size; i++) {
        callAdapterFactories.add(retrofit.callAdapterFactories.get(i));
      }

      callbackExecutor = retrofit.callbackExecutor;
      validateEagerly = retrofit.validateEagerly;
    }
    
    public Builder baseUrl(String baseUrl) {
      //判断传入的baseUrl是否为null
      checkNotNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl));
    }
    
    public Builder baseUrl(HttpUrl baseUrl) {
      //再一次判断baseUrl是否为null
      checkNotNull(baseUrl, "baseUrl == null");
      List<String> pathSegments = baseUrl.pathSegments();
      // 判断baseUrl是否以'/'结尾，如果不是直接抛出异常
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
    }
    
    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }
    
    ...
    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<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

      List<Converter.Factory> converterFactories = new ArrayList<>(
          1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
          
      converterFactories.add(new BuiltInConverters());
      converterFactories.addAll(this.converterFactories);
      converterFactories.addAll(platform.defaultConverterFactories());
      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }
  } 
}

从上面的代码我们可以看出，通过创建Retrofit.Builder对象运用Builder设计模式链式调用为Retrofit.Builder中的属性进行赋值,调用build方法时，将这些属性赋值给一个Retrofit对象，最后将这个Retrofit对象返回。我们看一下这里面的属性都是什么意思。

serviceMethodCache集合

这个集合的Key是一个Mehtod对象，Value是与Key相对应的ServiceMethod对象。ServiceMethod对象是根据Method解析之后获得，这里面包含了Method的方法注解、参数注解等一些列属性。我们从集合的名字就能看出来，这里面是将Method和对应ServiceMethod进行缓存的集合，这种方法我们在EventBus源码解析的时候就遇到过。这样做的目的就是为了加快运行速度，我们在今后的开发中也能加以借鉴并运用。有关Method和ServiceMethod都会在下文中进行讲解，这里如果不知道是什么意思也没关系。

Platform平台信息

这个对象是Retrofit.Builder对象中进行定义的。

  public static final class Builder {
    private final Platform platform;
    ...
    Builder(Retrofit retrofit) {
      platform = Platform.get();
    }
    ...
  }
    
class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }
  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      // 如果是Android平台
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      // 如果是Java平台
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }
  ...
}
复制代码

在这里我们可以看到这里会根据不同的平台信息返回对应的Platform对象，分别是Android和Java8,重点分析一下Android。

static class Android extends Platform {
    // 1、判断方法是否是默认方法，所谓默认方法是指是否是Object类中已经定义的方法
    //    如果是就返回true，否则返回false
    @IgnoreJRERequirement // Guarded by API check.
    @Override boolean isDefaultMethod(Method method) {
      if (Build.VERSION.SDK_INT < 24) {
        return false;
      }
      return method.isDefault();
    }
    
    @Override public Executor defaultCallbackExecutor() {
      // 2、获取一个Executor对象，这个对象代表了回调执行器
      return new MainThreadExecutor();
    }

    // 3、获得Android版本下默认的网络适配器集合
    @Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
        @Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      // 默认的请求适配器
      DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
      // 如果Android系统版本大于24，则会返回一个CompletableFutureCallAdapterFactory和DefaultCallAdapterFactory组成的集合。
      // 否则返回只有DefaultCallAdapterFactory对象的集合
      return Build.VERSION.SDK_INT >= 24
        ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
        : singletonList(executorFactory);
    }

    @Override int defaultCallAdapterFactoriesSize() {
      return Build.VERSION.SDK_INT >= 24 ? 2 : 1;
    }
    
    // 4、获取Android版本下默认的转换器集合
    @Override List<? extends Converter.Factory> defaultConverterFactories() {
      // 如果Android系统版本大于24，则会返回只有CompletableFutureCallAdapterFactory对象的集合
      // 否则返回一个长度为0的集合
      return Build.VERSION.SDK_INT >= 24
          ? singletonList(OptionalConverterFactory.INSTANCE)
          : Collections.<Converter.Factory>emptyList();
    }

    @Override int defaultConverterFactoriesSize() {
      return Build.VERSION.SDK_INT >= 24 ? 1 : 0;
    }
    
    // 2.1 这里返回的是Android主线程的回调
    // 也就是说当网络请求完成后会回调到Android主线程中去，这也是Retrofit和OkHttp的不同点之一
    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

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

1、判断传入的Method对象是否是默认方法
2、获取执行回调器，这里默认的是将网络请求结果回调到Android主线程中。
3、获得Android版本下默认的网络适配器集合，这里会根据Android版本号进行返回。
4、获取Android版本下默认的转换器集合，它也是会根据Android版本号进行返回。

callFactory对象

我们从单词的表面意思可以知道这个是请求工厂类，这个请求工厂类okhttp3的Call类型，这也说明了Retrofit是基于okhttp进行封装的。定义callFactory对象我们可以调用Retrofit.Builder.callFactory方法进行设置,在Retrofit.Builder.build方法中会将这个对象赋值个Retrofit对象。

public final class Retrofit {
  ...
  public static final class Builder {
    private @Nullable okhttp3.Call.Factory callFactory;
    ...
    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }
    ...
    public Retrofit build() {
      ...
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
      ...
    }
  }
  ...
}

我们可以看到当我们没有调用Retrofit.Builder.callFactory方法时，会给我们默认设置一个OkHttpClient对象

converterFactories转换器集合

converterFactories集合内部存放的都是Converter.Factory对象，我们可以调用Retrofit.Builder.addConverterFactory方法进行添加。

public final class Retrofit {
 ...
 public static final class Builder {
    private final List<Converter.Factory> converterFactories = new ArrayList<>();
    ...
    public Builder addConverterFactory(Converter.Factory factory) {
      // 检查factory是否为null，然后加入到集合中
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }
    ...
   public Retrofit build() {
      List<Converter.Factory> converterFactories = new ArrayList<>(
          1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());

      // Add the built-in converter factory first. This prevents overriding its behavior but also
      // ensures correct behavior when using converters that consume all types.
      // 首先添加BuiltInConverters
      converterFactories.add(new BuiltInConverters());
      // 然后添加调用addConverterFactory方法传入的Converter.Factory的集合
      converterFactories.addAll(this.converterFactories);
      // 最后添加platform默认的Converter.Factory集合
      converterFactories.addAll(platform.defaultConverterFactories());

      // 根据converterFactories创建一个不可变集合传入
      return new Retrofit(..., ..., unmodifiableList(converterFactories),
          ..., ..., ...);
   }
 }
 ...
}

callAdapterFactories请求适配器集合

callAdapterFactories集合中存放的是CallAdapter.Factory对象，调用Retrofit.Builder.addCallAdapterFactory方法来设置。

public final class Retrofit {
 ...
 public static final class Builder {
    private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
    ...
    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      callAdapterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }
    ...
   public Retrofit build() {
      List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      // 这里不仅添加了调用addCallAdapterFactory方法时设置的CallAdapter.Factory对象
      // 同时还添加了platform中默认的CallAdapter.Factory对象
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
      
      // 根据callAdapterFactories创建一个不可变的集合传入
      return new Retrofit(..., ..., ...,
          unmodifiableList(callAdapterFactories), ..., ...);
   }
 }
 ...
}
复制代码

CallAdapter.Factory从字面意思可以看出是请求适配器，有关于请求适配器是什么，也会放到下文中进行探究。

callbackExecutor回调执行器

设置回调执行器我们可以通过Retrofit.Builder.callbackExecutor来设置，默认的会使用Platform的回调执行器，也就是会将请求的执行结果回调到Android主线程中。

public final class Retrofit {
 ...
 public static final class Builder {
    private @Nullable Executor callbackExecutor;
    ...
    public Builder callbackExecutor(Executor executor) {
      this.callbackExecutor = checkNotNull(executor, "executor == null");
      return this;
    }
    ...
    public Retrofit build() {
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        // 默认为platform中的回调执行器，会将请求结果回调到Android主线程
        callbackExecutor = platform.defaultCallbackExecutor();
      }
      return new Retrofit(..., ..., ...,
          ..., callbackExecutor, ...);
    }
 }
 ...
}
复制代码

validateEagerly提前验证方法标识

这个标识表示是否需要提前验证HTTP API接口中的方法，我们通过调用Retrofit.Builder.validateEagerly方法进行设置，默认为false。

public final class Retrofit {
 ...
 public static final class Builder {
    private boolean validateEagerly;
    ...
    public Builder validateEagerly(boolean validateEagerly) {
      this.validateEagerly = validateEagerly;
      return this;
    }
    ...
    public Retrofit build() {
      ...
      return new Retrofit(..., ..., ...,
          ..., ..., validateEagerly);
    }
 }
 ...
}
复制代码

到这里我们已经把Retrofit.Buidler中的属性分析完了，但是我们还遗留了两个问题：CallAdapter.Factory和Converter.Factory。这两个类到底是做什么的？这里来看一下。

CallAdapter.Factory

既然我们已经知道这个类是用来进行请求适配的，那么我们看一下里面是怎么运行的。

// 将响应类型为R的Call调整为T类型
public interface CallAdapter<R, T> {
  // 返回此适配器将HTTP响应正文转换为Java时使用的值类型对象。 
  // 例如, Call <Repo>的响应类型是Repo。 这个类型用于准备传递给adapt的call。
  Type responseType();
  // 这个方法是将Call<R>对象转成代理类T
  T adapt(Call<R> call);
  //CallAdapter工厂，retrofit默认的DefaultCallAdapterFactory其中不对Call做处理，是直接返回Call。
  abstract class Factory {
    // 在这个方法中判断returnType是否是我们支持的类型，
    // DefaultCallAdapterFactory没有做处理，因为在定义HTTP API接口中的方式时，returnType 即为Call<Requestbody>
    // RxJavaCallAdapterFactory 就是判断returnType是不是Observable<?> 类型
    // 不支持时返回null
    // 返回值必须是Custom并且带有泛型（参数类型），根据HTTP API接口中的方法返回值，确定returnType
    // 如： CustomCall<String> getCategories()，那确定returnType就是CustomCall<String>
    public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);
        
    // 用于获取泛型的参数 如 Call<Requestbody> 中 Requestbody
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    
    // 用于获取泛型的原始类型
    // 如Call<Requestbody>拿到的原始类型就是Call
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}
复制代码

看了这么多代码，可能还是有点云里雾里，我们找两个例子看一下。

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  @Override public @Nullable CallAdapter<?, ?> get(
        Type returnType, Annotation[] annotations, Retrofit retrofit) {
    
    // 如果返回值不是Call类型返回空
    // 也就是说我们在定义HTTP API接口中的方法时，返回值不是Call<?>类型的，将不会处理
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return ...;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        return ...;
      }
    };
  }
  ...
}

我们经常会看到Retrofit + RxJava进行网络封装，如果要将Retrofit和RxJava结合到一起就需要RxJavaCallAdapterFactory。

public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
  ...
  @Override public @Nullable CallAdapter<?, ?> get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    Class<?> rawType = getRawType(returnType);
    boolean isSingle = rawType == Single.class;
    boolean isCompletable = rawType == Completable.class;
    // 如果返回值不是Observable类型返回空
    // 也就是说我们在定义HTTP API接口中的方法时，返回值不是Observable<?>类型的，将不会处理
    if (rawType != Observable.class && !isSingle && !isCompletable) {
      return null;
    }
    ...
  }
}

经过上面两个例子我们应该对CallAdapter.Factory有所了解了，这里来解释一下吧。

Converter.Factory

从上面我们也知道Converter.Factory适用于转换的，我们看下源码，看看它到底是怎么转换的。

// 将F类型转成T类型
public interface Converter<F, T> {
  @Nullable T convert(F value) throws IOException;
  abstract class Factory {
    // 判断能否将API方法的返回类型从ResponseBody 转换为type
    // 如果不能直接返回null，反之返回对应的Converter.Factory对象
    // type是由CallAdapter 接口里面的responseType()函数返回的。
    public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
        Annotation[] annotations, Retrofit retrofit) {
      return null;
    }
    // 将API方法的输入参数类型从 type转换为requestBody
    // 用于转换被注解@Body, @Part 和 @PartMap标记的类型
    public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }

    // 将API方法的输入参数类型从 type 转换为String
    // 用于转换被注解 @Header, @HeaderMap, @Path, @Query 和 @QueryMap 标记的类型
    public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
    
    // 从type中提取index处泛型参数的上界
    // 例如Map<String, ? extends Runnable>索引为1处返回Runnable
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    
    // 从type中提取原始类类型
    // 例如：List<? extends Runnable>返回的是List.class
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

看完之后还是有点懵懵哒，我们还是找一个列子，还记的我们调用Retrofit.Builder.addConverterFactory传入的GsonConverterFactory吗，看一下。

// 这个Converter.Factory类使用Gson来解析Json
public final class GsonConverterFactory extends Converter.Factory {
  // 使用默认的Gson对象来创建GsonConverterFactory
  // 通过Gson将对象序列化或者反序列化成Json字符串
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  public static GsonConverterFactory create(Gson gson) {
    // 检查传入的gson对象是否为空
    // 如果为空直接抛出异常
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
  }

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

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

// 将API方法的返回类型从ResponseBody 转换为type
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }
  
  @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      T result = adapter.read(jsonReader);
      if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
        throw new JsonIOException("JSON document was not fully consumed.");
      }
      return result;
    } finally {
      value.close();
    }
  }
}

// 将API方法的输入参数类型从 type转换为requestBody
final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
  private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
  private static final Charset UTF_8 = Charset.forName("UTF-8");
  
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }
  
  @Override public RequestBody convert(T value) throws IOException {
    Buffer buffer = new Buffer();
    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
    JsonWriter jsonWriter = gson.newJsonWriter(writer);
    adapter.write(jsonWriter, value);
    jsonWriter.close();
    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
  }
}

从GsonRequestBodyConverter的例子中我们总结一下Converter.Factory的作用：

调用Retrofit.create方法

public final class Retrofit {
  ...
  public <T> T create(final Class<T> service) {
    
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      // 1 验证HTTP API接口中的方法
      eagerlyValidateMethods(service);
    }
    // 2 动态代理，整个Retrofit的核心之一
    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 (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }
  ...
}

注释1：eagerlyValidateMethods(Class<?> service)

    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }

这里是注释2处的代码，validateEagerly这个变量在之前的代码注释中已经给出了解释，它是对方法进行提前验证的标识，一般为false，但是我们还是需要看一下这个方法中是怎么进行验证的。

  private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    //获得接口中所有定义的方法，并遍历
    for (Method method : service.getDeclaredMethods()) {
      // 1、判断是否如果是default方法，Android平台返回false
      // 2、判断方法是否是静态方法
      if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
        // 如果符合条件，直接加载
        loadServiceMethod(method);
      }
    }
  }
复制代码

在eagerlyValidateMethods方法中也是做了两件事：

1、找出接口中的所有方法，看看是否符合条件。
2、如果符合条件，直接加载方法。

public final class Retrofit {
  //缓存集合，支持多线程访问、线程安全
  //key：Method
  //value：Method对应的ServiceMethod
  private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
  ...
  ServiceMethod<?> loadServiceMethod(Method method) {
    // 1、首先从方法缓存集合中获取
    ServiceMethod<?> result = serviceMethodCache.get(method);
    // 2、如果有，直接返回
    if (result != null) return result;
    
    synchronized (serviceMethodCache) {
      // 3、在再次确认缓存中的是否有方法
      result = serviceMethodCache.get(method);
      if (result == null) {
        // 4、对方法的注解进行解析
        result = ServiceMethod.parseAnnotations(this, method);
        // 5、将方法传到方法缓存集合中
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }
}

loadServiceMethod这里做了三步事情：

1、根据传入的Method从缓存集合中获取对应的ServiceMethod对象，如果有，直接返回；如果没有，对集合进行加锁，再次获取。这种方法将对象缓存起来的做法在分析EventBus源码的时候就见过，目的就是为了提高效率。
2、如果上一步中没有获取到ServiceMethod对象，将对Method进行解析。
3、将Method和它对应的ServiceMethod对象存入到缓存集合中，返回结果。

abstract class ServiceMethod<T> {
  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

注释2: 动态代理

public final class Retrofit {
  ...
  public <T> T create(final Class<T> service) {
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          // 1、这里返回的是Android平台
          private final Platform platform = Platform.get();
          // 2、创建一个Object数组，长度为0
          private final Object[] emptyArgs = new Object[0];
          @Override public @Nullable Object invoke(Object proxy, Method method,
              @Nullable Object[] args) throws Throwable {
            // 3、如果该方法是来自Object的方法，则遵从正常调用。
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // 4、在Android平台始终返回false
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 5、加载方法
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });  
  }
  ...
}

当调用retrofit.create(ServiceApi.class)实际上会生成一个ServiceApi的代理类对象。从前面的基础知识准备中我们知道，当调用代理类对象中的方法时，最终会调用创建代理类对象所传入的第三个参数InvocationHandler.invoke方法回调中去，在这个回调中对方法进行处理。retrofit.create(ServiceApi.class)方法的主要流程已经在上面的代码注释中给出，这个方法最重要的一步是最后的加载方法，我们来看一下。

  ServiceMethod<?> loadServiceMethod(Method method) {
    ServiceMethod<?> result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

abstract class ServiceMethod<T> {
  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    // 1、根据传入的retrofit和method对象封装成RequestFactory
    // 这一步主要是进行解析注解
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
    // 2、获取方法的returnType
    Type returnType = method.getGenericReturnType();
    // 3、对方法的returnType进行验证
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
    // 4、对方法的注解进行解析，并封装成一个ServiceMethod对象
    // 这里返回的是HttpServiceMethod对象，他是ServiceMethod的子类
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

这个方法我们也见过，当时只是加深了一下印象，并没有对其进行探究。这个方法中做了四步操作，它们对应的操作已经在上面代码的注释中给出。我们重点来看一下第一步和第四步。

RequestFactory.parseAnnotations(retrofit, method)

这个方法主要是根据传入的retrofit对象和method对象封装成RequestFactory对象。

final class RequestFactory {
  static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
  }
  // method对象
  private final Method method;
  // 基础url
  private final HttpUrl baseUrl;
  // 请求方法
  final String httpMethod;
  // 相对url，它与基础url组成请求路径
  private final @Nullable String relativeUrl;
  // 请求头
  private final @Nullable Headers headers;
  // 表示具体请求中的媒体类型信息
  private final @Nullable MediaType contentType;
  // 是否有请求体
  private final boolean hasBody;
  // 是否是Form表单提交
  private final boolean isFormEncoded;
  // 是否支持文件上传的Form表单
  private final boolean isMultipart;
  // 
  private final ParameterHandler<?>[] parameterHandlers;
  // 是否是kotlin挂起函数
  final boolean isKotlinSuspendFunction;
  
   /**
   * Inspects the annotations on an interface method to construct a reusable service method. This
   * requires potentially-expensive reflection so it is best to build each service method only once
   * and reuse it. Builders cannot be reused.
   */
  // 检查接口方法上的注释以构造可重用的服务方法。这需要潜在的昂贵反射，因此最好只构建一次每个服务方法并重用它。
  // 构建器不能重用。
  static final class Builder {
    private static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
    private static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
    private static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
    // 传入的retrofit对象
    final Retrofit retrofit;
    // 传入的method对象
    final Method method;
    // method对象中的注解
    final Annotation[] methodAnnotations;
    // method中参数注解数组
    final Annotation[][] parameterAnnotationsArray;
    // method中参数类型数组
    final Type[] parameterTypes;
    
    boolean gotField;
    boolean gotPart;
    boolean gotBody;
    boolean gotPath;
    boolean gotQuery;
    boolean gotQueryName;
    boolean gotQueryMap;
    boolean gotUrl;
    @Nullable String httpMethod;
    boolean hasBody;
    boolean isFormEncoded;
    boolean isMultipart;
    @Nullable String relativeUrl;
    @Nullable Headers headers;
    @Nullable MediaType contentType;
    @Nullable Set<String> relativeUrlParamNames;
    @Nullable ParameterHandler<?>[] parameterHandlers;
    boolean isKotlinSuspendFunction;
    
    Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      // 获取方法注解
      this.methodAnnotations = method.getAnnotations();
      // 获取方法参数类型
      this.parameterTypes = method.getGenericParameterTypes();
      // 获取方法注解数组
      this.parameterAnnotationsArray = method.getParameterAnnotations();
    }
    
    RequestFactory build() {
      // 遍历注解，对注解进行解析
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      if (httpMethod == null) {
        throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(method,
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError(method, "FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }
      
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
      }

      if (relativeUrl == null && !gotUrl) {
        throw methodError(method, "Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError(method, "Non-body HTTP method cannot contain @Body.");
      }
      
      if (isFormEncoded && !gotField) {
        throw methodError(method, "Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError(method, "Multipart method must contain at least one @Part.");
      }
      
      // 返回一个RequestFactory对象
      return new RequestFactory(this);
    }
    
    // 对注解进行解析
    private void parseMethodAnnotation(Annotation annotation) {
      // 判断解析类型，根据注解的类型进行相应的解析
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
      } else if (annotation instanceof PATCH) {
        parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
      } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
      } else if (annotation instanceof PUT) {
        parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
      } else if (annotation instanceof OPTIONS) {
        parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
      } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
      } else if (annotation instanceof retrofit2.http.Headers) {
        String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
        if (headersToParse.length == 0) {
          throw methodError(method, "@Headers annotation is empty.");
        }
        headers = parseHeaders(headersToParse);
      } else if (annotation instanceof Multipart) {
        if (isFormEncoded) {
          throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isMultipart = true;
      } else if (annotation instanceof FormUrlEncoded) {
        if (isMultipart) {
          throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isFormEncoded = true;
      }
    }
    
    //解析Http请求方法和路径
    private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      ...
    }
    
    // 解析请求头
    private Headers parseHeaders(String[] headers) {
      ...
    }
    ...
  }
  ...
}

1、创建一个RequestFactory.Builder对象，同时传入Retrofit对象和Method对象。
2、创建完RequestFactory.Builder对象之后，会对Method对象的注解进行解析，解析的同时会对Buidler对象进行初始化。
3、最后通过build方法，创建一个RequestFactory对象，并进行初始化

HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory)

在得到RequestFactory对象之后，会调用HttpServiceMethod.parseAnnotations方法，将获取的RequestFactory传入，我们看一下这里面都是做了什么操作。

/** Adapts an invocation of an interface method into an HTTP call. */
// 将接口方法的调用调整为HTTP请求
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
  /**
   * Inspects the annotations on an interface method to construct a reusable service method that
   * speaks HTTP. This requires potentially-expensive reflection so it is best to build each service
   * method only once and reuse it.
   */
  // 检查接口方法上的注释，以构造一个可重用的服务方法，该服务方法表示HTTP。
  // 这需要潜在的昂贵反射，因此最好只构建一次每个服务方法并重用它。
  static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;

    // 获得所有方法上的所有注解
    Annotation[] annotations = method.getAnnotations();
    // 方法返回值类型
    Type adapterType;
    // 是否是kotlin挂起函数
    if (isKotlinSuspendFunction) {
      ...
    } else {
      // 获取方法返回类型
      adapterType = method.getGenericReturnType();
    }
    
    // 1、获取CallAdapter对象
    // 根据之前的分析，这里获得的是DefaultCallAdapterFactory
    CallAdapter<ResponseT, ReturnT> callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    // 校验返回类型是否正确
    Type responseType = callAdapter.responseType();
    // 返回类型不能为okhttp3.Response类型
    if (responseType == okhttp3.Response.class) {
      throw methodError(method, "'"
          + getRawType(responseType).getName()
          + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    // 返回类型不能是Response，必须要包含泛型才行,类似于Response<String>
    if (responseType == Response.class) {
      throw methodError(method, "Response must include generic type (e.g., Response<String>)");
    }
    // TODO support Unit for Kotlin?
    if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
      throw methodError(method, "HEAD method must use Void as response type.");
    }
    // 2、获得Converter对象
    // 由于我们设置了GsonConverterFactory，所以这里获得的是GsonConverterFactory对象
    Converter<ResponseBody, ResponseT> responseConverter =
        createResponseConverter(retrofit, method, responseType);
        
    // 获取一个okhttp3.Call.Factory对象，其实就是一个OkHttpClient对象
    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      ...
    } else {
      ...
    }
  }

  private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
      Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
    try {
      // 4、从retrofit中根据returnType和annotations获取CallAdapter
      return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
    } catch (RuntimeException e) { // Wide exception range because factories are user code.
      throw methodError(method, e, "Unable to create call adapter for %s", returnType);
    }
  }
  
  private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
      Retrofit retrofit, Method method, Type responseType) {
    Annotation[] annotations = method.getAnnotations();
    try {
      // 5、从retrofit中根据responseType和annotations获取Converter
      return retrofit.responseBodyConverter(responseType, annotations);
    } catch (RuntimeException e) { // Wide exception range because factories are user code.
      throw methodError(method, e, "Unable to create converter for %s", responseType);
    }
  }
}

public final class Retrofit {
...
  // 创建CallAdapter对象
  public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    // 调用nextCallAdapter传入skipPast、returnType、annotations
    // 注意：这里传入的skipPast为null
    return nextCallAdapter(null, returnType, annotations);
  }
  
  public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    // 检查一下returnType和annotations是否为null
    checkNotNull(returnType, "returnType == null");
    checkNotNull(annotations, "annotations == null");
    
    // 这里找到callAdapterFactories集合的起始位置
    // 由于skipPast为null所以获得的index为-1，然后加上1，起始位置还是0
    // 开始遍历集合
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      // 我们在分析CallAdapter.Factory时知道，调用get方法表示了，
      // 判断returnType是否是该CallAdapter.Factory支持的类型
      // 如果不支持将会返回null
      // 反之会返回对应的CallAdapter.Factory
      // 由于没有额外设置，所以这里返回的是DefaultCallAdapterFactory
      CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      // 如果有直接返回
      if (adapter != null) {
        return adapter;
      }
    }
    
    // 到这里说明没有对应的CallAdapter.Factory
    // 拼接错误信息
    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());
  }
  
  ...
  
  // 创建Converter对象
  public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
    // 调用nextResponseBodyConverter传入skipPast、returnType、annotations
    // 注意：这里传入的skipPast为null
    return nextResponseBodyConverter(null, type, annotations);
  }
  
  public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
      @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
    // 检查一下returnType和annotations是否为null
    checkNotNull(type, "type == null");
    checkNotNull(annotations, "annotations == null");
    // 这里找到converterFactories集合的起始位置
    // 由于skipPast为null所以获得的index为-1，然后加上1，起始位置还是0
    // 开始遍历集合
    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      // 我们在分析Converter.Factory时知道，调用responseBodyConverter方法表示了，
      // 判断能否将API方法的返回类型从ResponseBody 转换为type
      // 如果不能直接返回null，
      // 返回对应的Converter.Factory对象,我们之前设置的是GsonConverterFactory，所以这里返回的是GsonConverterFactory
      Converter<ResponseBody, ?> converter =
          converterFactories.get(i).responseBodyConverter(type, annotations, this);
      if (converter != null) {
        // 如果有直接返回
        return (Converter<ResponseBody, T>) converter;
      }
    }

    // 到这里说明没有对应的Converter.Factory
    // 拼接错误信息
    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());
  }
...
}

这里由于代码过长，所以我们分步分析，在上面代码中有5处比较重要的注释，首先看一下注释1和注释2，它们分别是用来获取CallAdapter.Factory和Converter.Factory,分别对应了注释4和注释5处。注释4和注释5都是从retrofit对象中获取，具体的操作需要看上段代码的下半部分，最终获取的是DefaultCallAdapterFactory和GsonConverterFactory，具体流程已经在注释中给出。
我们来看一下注释3处的操作,下面是注释3处的代码

abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
  static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    ...
    // 获取一个okhttp3.Call.Factory对象，其实就是一个OkHttpClient对象
    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {
      // 新建一个CallAdapted对象，传入requestFactory、callFactory、responseConverter、callAdapter
      // 最后返回出去
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      ...
    } else {
      ...
    }
  }
  
  ...
  
  HttpServiceMethod(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
      Converter<ResponseBody, ResponseT> responseConverter) {
    this.requestFactory = requestFactory;
    this.callFactory = callFactory;
    this.responseConverter = responseConverter;
  }
  
  @Override final @Nullable ReturnT invoke(Object[] args) {
    Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    // 这里首先找的是子类的adapt方法
    // 因为创建的是CallAdapted，所以会调用CallAdapted的adapt放方法
    return adapt(call, args);
  }
  
  protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);
  
  // CallAdapted继承自HttpServiceMethod
  static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
    private final CallAdapter<ResponseT, ReturnT> callAdapter;
    
    // CallAdapted构造方法
    CallAdapted(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
        Converter<ResponseBody, ResponseT> responseConverter,
        CallAdapter<ResponseT, ReturnT> callAdapter) {
      // 调用父类的构造方法，也就是HttpServiceMethod的构造方法
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }

    @Override protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
      // 返回callAdapter.adapt的结果
      return callAdapter.adapt(call);
    }
  }
  ...
}

这里我们需要把注释3处的过程捋一捋，由于这个过程跟之前的分析联系比较紧密，所以会有点绕：

1、新建一个CallAdapted对象，传入requestFactory、callFactory、responseConverter、callAdapter。
2、创建CallAdapted对象时调用其构造方法，由于它继承自HttpServiceMethod，又调用了HttpServiceMethod的构造方法，将参数传入。
3、我们在之前的动态代理最后一步会调用return loadServiceMethod(method).invoke(...)方法之后，又回调用HttpServiceMethod.adapt方法。这个方法在HttpServiceMethod中属于抽象方法，所以最终会调用其子类CallAdapted.adapt方法。
4、在CallAdapted.adapt的方法中会调用callAdapter.adapt方法，在分析CallAdapte.Factory时，我们知道这个方法是将Call<R>对象转成代理类T。我们没有设置CallAdapte.Factory，所以使用的是DefaultCallAdapterFactory，所以又调用了DefaultCallAdapterFactory中的adapt方法,并将OkHttpCall传入了。

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  private final @Nullable Executor callbackExecutor;
  // 这个构造方法在Platform的Android子类中的defaultCallAdapterFactories方法中已经被调用。
  DefaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    //callbackExecutor为MainThreadExecutor，也就是说会将响应回调到Android主线程去
    this.callbackExecutor = callbackExecutor;
  }
  // 
  @Override public @Nullable CallAdapter<?, ?> get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    // 如果不是Call类型不予处理
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
    }
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
    // 查看注解是否包含SkipCallbackExecutor类型，我们在使用时并没有使用SkipCallbackExecutor的注解
    // 所以这里的executor不为null
    final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
        ? null
        : callbackExecutor;
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        // 判断executor是否为空，如果为空返回Call,这个call属于OkHttpCall
        // 如果不为空返回ExecutorCallbackCall
        return executor == null
            ? call
            : new ExecutorCallbackCall<>(executor, call);
      }
    };
  }
  ...
}

static final class ExecutorCallbackCall<T> implements Call<T> {
  ...
  }

1、在Platform的子类Android中，已经创建了DefaultCallAdapterFactory对象，并且传入了MainThreadExecutor，这保证了响应会被回调到Android主线程。
2、之前在获取CallAdapter类型的时候，已经调用了DefaultCallAdapterFactory.get方法，所以executor对象不为空，并且返回了一个匿名的CallAdapter对象。
3、在上面我们调用DefaultCallAdapterFactory.adapt方法时，就是调用了这个匿名对象的adapt方法，这里返回的是ExecutorCallbackCall对象。也就是说我们在做网络请求时就是使用这个ExecutorCallbackCall对象。

执行请求

我们在上面的分析中知道，其实是ExecutorCallbackCall对象进行网络请求，所以看一下它的源码。

  static final class ExecutorCallbackCall<T> implements Call<T> {
    // callbackExecutor属于MainThreadExecutor
    final Executor callbackExecutor;
    final Call<T> delegate;
    
    // 异步请求
    @Override public void enqueue(final Callback<T> callback) {
      checkNotNull(callback, "callback == null");
      // 根据同步请求我们知道delegate就是一个OkhttpCall对象
      // 调用OkhttpCall.exqueue方法执行异步请求
      delegate.enqueue(new Callback<T>() {
        // 获取响应的回调
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          // 进行线程切换
          // callbackExecutor就是MainThreadExecutor，其内部是通过主线程的Handler将Runnable发送到主线程去
          // 从而达到切换线程的效果
          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);
            }
          });
        }
      });
    }
  }

final class OkHttpCall<T> implements Call<T> {
  
  // 异步请求方法
  @Override public void enqueue(final Callback<T> callback) {
    checkNotNull(callback, "callback == null");

    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      ...
      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          // 创建Call对象
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          throwIfFatal(t);
          failure = creationFailure = t;
        }
      }
    }
    
    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

    if (canceled) {
      call.cancel();
    }
    // 执行异步请求
    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) {
          throwIfFatal(e);
          callFailure(e);
          return;
        }

        try {
          // 请求成功的回调
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          throwIfFatal(t);
          t.printStackTrace(); // TODO this is not great
        }
      }
      
      @Override public void onFailure(okhttp3.Call call, IOException e) {
        // 请求失败
        callFailure(e);
      }

      private void callFailure(Throwable e) {
        try {
          // 请求失败回调
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          throwIfFatal(t);
          t.printStackTrace(); // TODO this is not great
        }
      }
    });
  }
  
  private okhttp3.Call createRawCall() throws IOException {
    // requestFactory根据args创建一个request对象
    // 将request对象分装成一个Call对象
    okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }
}

总结

到这里我们已经把Retrofit的源码分析了一遍，这里涉及大量的涉及模式，通过阅读Retrofit的源码了解，更深入理解这些设计模式使用.

小图包

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Retrofit源码解析

一简单使用引入依赖，implementation 'com.squareup.okhttp3:okhttp:3.14.9'implementation 'com.squareup.retrofit2:retrofit:2.9.0'implementation 'com.squareup.retrofit2:converter-gson:2.9.0'implementation 'com.google.code.gson:gson:2.8.6'复制代码定义接口WanApi，int
复制链接

扫一扫