一、Retrofit是什么？

Retrofit 是一个 HTTP 网络请求框架的封装，网络请求的工作本质上是 OkHttp 完成，而 Retrofit 仅负责 网络请求接口的封装，所以你可以将Retrofit 看成是一个对OkHttp 封装的网络请求框架。
本篇文章也不但算介绍Retrofit 的基本用法，而是研究一下Retrofit源码，知其然也要知其所以然。

二、源码解析

    public interface  NetInterface {
    
        @GET("getSomething")
        Call<String> getCall(@Field("name") String name);
    }

    public   void testRetrofix(){
    
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://xxxx.com/") //设置网络请求的Url地址
                .addConverterFactory(GsonConverterFactory.create()) //设置数据解析器
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
        retrofit.create(TestRetrofit.NetInterface.class);
    }

首先build 的过程这里先不做分析。其仅仅是配置一些参数而已，在遇到这些参数的时候我们再讲。
retrofit.create(TestRetrofit.NetInterface.class); 创建一个NetInterface 的实例，我们知道NetInterface 是一个接口，其本身是不可以直接实例化的，这里实际是通过Java的动态代理创建了一个实现这个接口的类，Java创建的这个类虽然实现了这个接口，接口里面的每一个方法的实现都是通过InvocationHandler 通过用户哪一个方法被调用了，关于动态代理生成的代理我们放到最下面介绍，下面我们先看看create 的实现。

2.1 create

  public <T> T create(final Class<T> service) {
    
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
    
      eagerlyValidateMethods(service);
    }
    //newProxyInstance 创建一个动态代理类
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] {
     service },
        new InvocationHandler() {
    
          private final Platform platform = Platform.get();

		//method 表示被调用的方法，args 表示传递给这个方法的参数
          @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) {
    
            //例如 调用toString equal 等Object 的方法绘
              return method.invoke(this, args);
            }
            //android 这里返回false
            if (platform.isDefaultMethod(method)) {
    
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //这个是核心，放到后面将
            ServiceMethod serviceMethod = loadServiceMethod(method);
            //创建OKHttpCall
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

newProxyInstance 的第一个参数是classloader，这里不用过于关注这个对象，只需要知道这是用来加载类的就可以了，第二个参数是个数组，表示动态生成的类需要实现的接口，第三个参数InvocationHandler是一个回调，Java 动态生成的这个代理类会在每一个方法里面都调用InvocationHandler 的invoke 方法通知当前调用的方法（还有不清楚的参见文章的最后）。
例如

      TestRetrofit.NetInterface netInterface= retrofit.create(TestRetrofit.NetInterface.class);
      //调用
        netInterface.getCall("test");

netInterface 就是动态生成的代理类，这个代理类的getCall 方法里面就是直接调用InvocationHandler 的invoke 方法，其余的啥也没干，因此核心内容都在invoke 里面。

invoke内部首先判断用户调用的方法是不是定义在Object 类里面方法，也即是判断调用的是不是equal ，haseCode 等方法，

platform.isDefaultMethod(method) 与系统有关，这里是false，因此无需考虑。

loadServiceMethod 内部主要是通过反射获取当前调用的方法的一些信息，例如形参以及返回类型，然后根据参数类型与注解进行一些处理。

2.2 loadServiceMethod

  ServiceMethod loadServiceMethod(Method method) {
    
    ServiceMethod result;
    synchronized (serviceMethodCache) {
    
    //
      result = serviceMethodCache.get(method);
      if (result == null) {
    
      //第一次调用会走这里
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }
serviceMethodCache  是ServiceMethod的缓存，因为创建ServiceMethod 会通过反射获取调用方法的信息，我们知道Java的反射存在效率的问题，因此这里使用了缓存。
第一次调用某个方法的时候会创建一个对应的ServiceMethod

```java
//代码有删减
    public ServiceMethod build() {
    
    //创建callAdapter，
      callAdapter = createCallAdapter();
      //responseType 代表调用方法的返回值的泛型
      responseType = callAdapter.responseType();
      //泛型不可以是Response类型
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
    
      responseConverter = createResponseConverter();
      //methodAnnotations 是方法的注解，例如GET.POST
      for (Annotation annotation : methodAnnotations) {
    
        parseMethodAnnotation(annotation);
      }
      //parameterAnnotationsArray 是方法的参数上的注解，例如getCall 的
      // 第一个参数的注解Field
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
    
        Type parameterType = parameterTypes[p];
        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }
      return new ServiceMethod<>(this);
    }

这里结合
@GET(“getSomething”)
Call getCall(@Field(“name”) String name)来解释一个这个方法的内容。
createCallAdapter 会根据getCall的返回类型也就是Call 以及方法的注解也就是 @GET(“getSomething”) 获取一个CallAdaper。CallAdaper作用是将前文中的OkHttpCall 转换为函数的返回类型也即是Call。OkHttpCall 可以简单地看成是对OKhHttp的Call的一层封装，通过OkHttpCall 直接访问网络，返回数据。

下面我们看看createCallAdapter 的实现

    private CallAdapter<?> createCallAdapter() {
    
    //获取方法的返回类型，这里还是以getCall为例，
    //returnType 表示Call<String>
      Type returnType = method.getGenericReturnType();
      if (Utils.hasUnresolvableType(returnType)) {
    
      //例如Call<T> 由于T 是不可解析的类型，这里会报错，此处Call的泛型必须是一个
      //具体的类
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      //必须有返回类型
      if (returnType == void.class) {
    
        throw methodError("Service methods cannot return void.");
      }
      Annotation[] annotations = method.getAnnotations();
      try {
    
      //根据返回类型与注解获取对应的CallAdapter
        return retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) {
     // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }

上面的注释已经很清楚了，下面进入 retrofit.callAdapter(returnType, annotations); 看看

  public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
    
    return nextCallAdapter(null, returnType, annotations);
  }

  public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    
 	//
    int start = adapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
    
      CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
    
        return adapter;
      }
    }
	//代码有删减
  }

adapterFactories 保存着创建Retrofit的时候注册的CallAdapter.Factory，遍历所有的CallAdapter.Factory 的get 方法 判断能否处理用户调用的这个方法，注意这里找到第一个可用的Factory 就不会继续向下找了。

由于RxJavaCallAdapterFactory 的实现略显复杂，我们这里以默认的CallAdapter.Factory为例子

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

	//还是以上面的getCall 为例，returnType 表示Call<String>
	//这里getCallResponseType 就是获取Call的泛型也就是String
    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;
      }
    };
  }
}

也就是每一个返回值类型都必须有自己的CallAdapterFactory. 创建完了

2.2 createResponseConverter

在createCallAdapter 之后又调用了createResponseConverter以及处理方法形式参数的注解，
我们这里不分析形式参数的注解的处理，例如Filed 注解，这些都是根据固定的规则处理，有感兴趣的可以自行分析。此处只分析createResponseConverter，

createResponseConverter 返回一个Converter<ResponseBody, T> 对象，这个对象就是将ResponseBody类型转换了T类型，我们知道OKHttp 访问网络返回对象就是ResponseBody类型，而getCal 返回的Call的泛型是String, 这里就需要将ResponseBody 转换为String

    private Converter<ResponseBody, T> createResponseConverter() {
    
      Annotation[] annotations = method.getAnnotations();
      try {
    
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) {
     // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

retrofit.responseBodyConverter 就不展开看了，其与retrofit.callAdapter(returnType, annotations)的实现类似。
这里以GsonConverterFactory 为例子

  private GsonConverterFactory(Gson gson) {
    
    if (gson == null) throw new NullPointerException("gson == null");
    this.gson = 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);
  }

2.2 访问网络

        TestRetrofit.NetInterface netInterface= retrofit.create(TestRetrofit.NetInterface.class);
        retrofit2.Call  call=netInterface.getCall("test");
        call.enqueue(new retrofit2.Callback() {
    
            @Override
            public void onResponse(retrofit2.Call call, retrofit2.Response response) {
    
                
            }

            @Override
            public void onFailure(retrofit2.Call call, Throwable t) {
    

            }
        });

netInterface.getCall 创建Call的过程已经讲完了，下面我们看看具体访问网络以及获取数据之后转换的过程。
这个Call 实际是OkHttpCall

  @Override public void enqueue(final Callback<T> callback) {
    
    if (callback == null) throw new NullPointerException("callback == null");

    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
    
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
    
        try {
    
          //创建一个OKHTTP 的Call 也就是RealCall
          call = rawCall = createRawCall();
        } catch (Throwable t) {
    
          failure = creationFailure = t;
        }
      }
    }

    call.enqueue(new okhttp3.Callback() {
    
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
    
        Response<T> response;
        try {
    
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
    
          callFailure(e);
          return;
        }
        callSuccess(response);
      }
      //部分回调被删除

      private void callSuccess(Response<T> response) {
    
        try {
    
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
    
          t.printStackTrace();
        }
      }
    });
  }

可以看到这里实际就是创建一个OKHTTP的Call,然后通过这个Call 访问网络，对于OKHTTP这一部分不熟悉的可以参考我前面的文章。
当网络返回数据成功之后会调用parseResponse 来进行数据转换。

  Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    
    ResponseBody rawBody = rawResponse.body();

    // Remove the body's source (the only stateful object) so we can pass the response along.
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();
  //代码有删减
    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
    
     //ServiceMethod 参见前面的创建过程
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
    
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }

  /** Builds a method return value from an HTTP response body. */
  T toResponse(ResponseBody body) throws IOException {
    
    return responseConverter.convert(body);
  }

responseConverter 就是前面的createResponseConverter 内部创建的ResponseConverter ，也就是GsonResponseBodyConverter，我们看看GsonResponseBodyConverter 的conver 是将ResponseBody 转换为String类型。

//
  TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));

  @Override public T convert(ResponseBody value) throws IOException {
    
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
    
     //
      return adapter.read(jsonReader);
    } finally {
    
      value.close();
    }
  }

到了这里一切就很显然了，convert 方法内通过Gson 将服务器返回的json数据转换了一个对象。

总结