Retrofit2 简单解读

Retrofit2 简单解读

Retrofit2的组成 一个是retorfit2.utils 下面的的都是注解的java类，GET,POST 等都是和http请求有关系
剩下了几个类就是对retrofit的实现，代码比较少容易阅读。

Retrofit2 一般都是和okhttp结合来实现网络请求，实际上是一个工具类实际的网络请求使用了okhttp的请求，retrofit是将一个java接口->http的请求，使用okhttp去发送请求。 内部的细节

@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  public <T> T create(final Class<T> 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, 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);
            }
            return loadMethodHandler(method).invoke(args);
          }
        });
  }
 在使用上我们是create(API.class)，api.class 是一个接口没有具体的实现类，这里使用代理模式，前者第一个if判断只是判断如果是对象的方法直接调他实现类方法，第二个if 不清楚 内部默认返回一个false ，因为我们大多数传递的是一个接口，最终都被拦截，进一个loadMethodHandler 方法

  MethodHandler loadMethodHandler(Method method) {
    MethodHandler handler;
    synchronized (methodHandlerCache) {
      handler = methodHandlerCache.get(method);
      if (handler == null) {
        handler = MethodHandler.create(this, method);
        methodHandlerCache.put(method, handler);
      }
    }
    return handler;
  }

  static MethodHandler create(Retrofit retrofit, Method method) {
    CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
    Type responseType = callAdapter.responseType();
    if (responseType == Response.class || responseType == okhttp3.Response.class) {
      throw Utils.methodError(method, "'"
          + Types.getRawType(responseType).getName()
          + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    Converter<ResponseBody, ?> responseConverter =
        createResponseConverter(method, retrofit, responseType);
    RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
    return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
        responseConverter);
  }

MethodHandler 他内部的类 是以下三个，每一个MethodHandler对应每一个请求和他的相关配置
  privr;ate final okhttp3.Call.Factory callFactory;实际上就是okhttpclicnt
  private final RequestFactory requestFactory;//okhttp中的Request，内部有okhttpRequest的类
  private final CallAdapter<?> callAdapter;是对call的代理，call
  private final Converter<ResponseBody, ?> responseConverter;//返回的结果，ResponseBody是okHttp报下的类
对于responseConverter，requestFactory 这两个的内部容易看懂 ，可以结合之前对注解的简单理解可以查看。不具体贴代码，就是根据每个方法带有的参数和注解构建相应request

对于 Converter 这个类，为了将Retrofit添加请求和响应的数据编码和解析，有GsonResponseBodyConverter和GsonRequestBodyConverter去解析数据

而对于callAdapter，callFactory
以callFactory 来说Retrofit是构建者模式去处理内部也有一个callFactory
  public static final class Builder {
    private okhttp3.Call.Factory callFactory;
    private BaseUrl baseUrl;
    private List<Converter.Factory> converterFactories = new ArrayList<>();
    private List<CallAdapter.Factory> 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();
      }

实际就是请求的httpclient

这是一个call对象
public interface Call<T> extends Cloneable {
  Response  <T> execute() throws IOException;

  void enqueue(Callback<T> callback);

  boolean isExecuted();


  void cancel();


  boolean isCanceled();


  Call<T> clone();

  Request request();
  }

callAdapter 世界上调用了call方法
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();

  @Override
  public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }

    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

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

 这是MethodHadler在被调用的时候还是调用了call
 这MethoHandler的方法
 Object invoke(Object... args) {
    return callAdapter.adapt(
        new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));
  }