Retrofit源码分析

Retrofit 的创建过程

在上一篇文章中使用了 Retrofit 进行简单的网络请求，首先就要建立相对应的请求接口。

public interface ApiManager {

    @GET("Login")
    Call getData(@Query("account") String name, @Query("psw") String pw);

} 

而我们通过以下的模式进行 Retrofit 的创建：

Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://192.168.56.1:8080/RetrofitTest/")
            .addConverterFactory(GsonConverterFactory.create())
            .build();

那么接下来就从 这里从 Builder() 分析起

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

再进入 Platform 的 get() 方法 ：

private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

get() 方法返回了 PLATFORM ， 而这个 PLATFORM 的赋值是由 findPlatform() 返回的，所以接下来看看 findPlatform()

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("org.robovm.apple.foundation.NSObject");
      return new IOS();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

上面的执行的就是根据不同的运行平台来提供不同的线程池。

接下来就看看 build() 方法。

public Retrofit build() {

    //baseUrl是必须指定的
    if (baseUrl == null) {
    throw new IllegalStateException("Base URL required.");
    }
    
    // 默认构造的 callFactory 为 OkHttpClient() 
    okhttp3.Call.Factory callFactory = this.callFactory;
    if (callFactory == null) {
    callFactory = new OkHttpClient();
    }
    
    // callbackExecutor 用来将回调传递到UI线程
    Executor callbackExecutor = this.callbackExecutor;
    if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
    }
    
    //  adapterFactories 用来存储对call进行转化的对象
    List adapterFactories = new ArrayList<>(this.adapterFactories);
    adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
    
    // converterFactories 用于存储转化数据的对象
    List converterFactories = new ArrayList<>(this.converterFactories);
    
    //最后返回 一个 Retrofit 对象
    return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
      callbackExecutor, validateEagerly);
}

Call 的创建过程

接下来我们通常就是生成接口的动态代理对象

ApiManager apiManager = retrofit.create(ApiManager.class);
Call data = apiManager.getDataUrl("Login", "123123", "123123"); 

那么接下来就看看 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, 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);
        }
        //注 1
        ServiceMethod serviceMethod = loadServiceMethod(method);
        OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
        return serviceMethod.callAdapter.adapt(okHttpCall);
      }
    });
}  

在 create() 里面 ，我们可以明显看到返回了 Proxy.newProxyInstance 动态代理对象。 在 invoke ( Object proxy, Method method, Object... args ) 方法中，第一个参数是代理对象，第二个参数是调用方法，第三个参数是方法参数。在我们的调用
ApiManager的getDataUrl()的方法时候，实际上调用的就是invoke()方法。而在注1那里其实就是我们定义的 getDataUrl() 方法。

那么就看看 loadServiceMethod(Method method) 方法 干了什么。

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，把ServiceMethod放入 serviceMethodCache 里面。

下面看看 ServiceMethod 是如何建立的。

public ServiceMethod build() {

  // 注 1 
  callAdapter = createCallAdapter();
  // 注 2
  responseType = callAdapter.responseType();
  if (responseType == Response.class || responseType == okhttp3.Response.class) {
    throw methodError("'"
        + Utils.getRawType(responseType).getName()
        + "' is not a valid response body type. Did you mean ResponseBody?");
  }
  // 注 3
  responseConverter = createResponseConverter();

  for (Annotation annotation : methodAnnotations) {
    // 注 4
    parseMethodAnnotation(annotation);
  }

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

  .....

  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];
    if (Utils.hasUnresolvableType(parameterType)) {
      throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
          parameterType);
    }
    //注 5
    Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
    if (parameterAnnotations == null) {
      throw parameterError(p, "No Retrofit annotation found.");
    }

    parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
  }

  .......

  return new ServiceMethod<>(this);
}

注1 ：

createCallAdapter(); 然后继续往下看

private CallAdapter createCallAdapter() {
  ...
    return 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) {
    ....
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      CallAdapter adapter = adapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
    ....
}

最后 adapter 其实就是 adapterFactories 里面的。而这个 adapterFactories 就算是 一开始我们构建 Retrofit 时调用 build() 方法是设置的。

Retrofit -> build() 方法 里面

List adapterFactories = new ArrayList<>(this.adapterFactories);
  adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

那么继续看 defaultCallAdapterFactory 是什么。 点进代码，我们看到了其实他就是 ExecutorCallAdapterFactory 。

知道了adapterFactories是什么，那么他所被调用的就是 get() 方法。

那么就看看 ExecutorCallAdapterFactory 的 get() 又干了什么。

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>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public  Call adapt(Call call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
}

get 方法得到了 CallAdapter ，而 CallAdapter 的 responseType 就是 我们 传进去要返回的 Call 里面的 LoginResult 。 adapt() 会返回一个 ExecutorCallbackCall ，他会将call的回调转发到UI线程 。

注 2

那么继续回到 ServiceMethod 方法里面。

responseType = callAdapter.responseType();

那么这个拿到的就是我们的真实类型： LoginResult 。

注 3

responseConverter = createResponseConverter();

同样 createResponseConverter 会去遍历 converterFactories 。而这个 converterFactories 里面 就是构建 Retrofit 时所调用的 addConverterFactory(GsonConverterFactory.create()) 时传进去的 GsonConverterFactory ，表示返回的数据支持转换为 JSON 对象 。

注 4

遍历parseMethodAnnotation方法来对请求方式，比如GET，POST和请求地址进行解析。

注 5

对方法中的参数注解进行解析，比如@Query，@Part。

最后得以创建 ServiceMethod 。

接下来回到：Retrofit 里的 create() ，

ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);

loadServiceMethod() 上面已经说完了，最后会创建并返回 ServiceMethod 。

在create() 最后返回的是 serviceMethod.callAdapter.adapt(okHttpCall);
而 adapt () 方法前面讲过

@Override public  Call adapt(Call call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }

会返回 ExecutorCallbackCall 。那么就看看 ExecutorCallbackCall 做了什么吧。

ExecutorCallbackCall(Executor callbackExecutor, Call delegate) {
  this.callbackExecutor = callbackExecutor;
  this.delegate = delegate;
}

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

  delegate.enqueue(new Callback() {
    @Override public void onResponse(Call call, final Response response) {
      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 call, final Throwable t) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          callback.onFailure(ExecutorCallbackCall.this, t);
        }
      });
    }
  });
}

很明显 ， ExecutorCallbackCall 这个就是 对 Call 的封装，当我们调用到 Call 对象的时候， enqueue 会被调用 。 而调用 enqueue 方法时 ，最终调用的就是delegate 对象的 enqueue ，而这个 就是 传进去的 okHttpCall 。

在 delegate.enqueue() 里面，在获得响应后，调用的就是 callbackExecutor.execute() ，很明显这个 callbackExecutor.execute() 会使得 Runnable 在主线程进行回调 。

Call的 enqueue() 方法 。

上面已经建立了 Call ， 那么接下我们的用法就是用 enqueue() 进行网络请求。

call.enqueue(new Callback() {
        @Override
        public void onResponse(Call call, Response response) {
            if (response.isSuccessful()) {
               .....
            } else {
               ....
            }

        }

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

那么就进去看看 call.enqueue 干了什么吧。

Call 是一个接口 ， 由上文我们可以得知最后返回的 Call 就是 OkHttpCall 。

那么就看看 OkHttpCall 里的 enqueue 做了什么吧。

@Override public void enqueue(final Callback callback) {
    ....
    okhttp3.Call call;
    ....

    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response response;
        try {
          // 注 1
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        ....
      }

      private void callFailure(Throwable e) {
        ...
          callback.onFailure(OkHttpCall.this, e);
        ...
      }

      private void callSuccess(Response response) {
        ....
          callback.onResponse(OkHttpCall.this, response);
        ....
      }
    });
  }

在 enqueue 里面 其实就是调用了 okhttp3.Call.enqueue() 来执行网络请求。

注 1

enqueue() 进行了网络请求。在这里面调用了 parseResponse 来解析结果。

Response 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();

    int code = rawResponse.code();
    if (code < 200 || code >= 300) {
      try {
        // Buffer the entire body to avoid future I/O.
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        rawBody.close();
      }
    }

    if (code == 204 || code == 205) {
      return Response.success(null, rawResponse);
    }

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      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;
    }
  }

  public void cancel() {
    canceled = true;

    okhttp3.Call call;
    synchronized (this) {
      call = rawCall;
    }
    if (call != null) {
      call.cancel();
    }
  }

解析返回数据就是根据不同的返回状态码code 进行不同的操作。

如果顺利的话，那么就会到达执行这一行代码

serviceMethod.toResponse(catchingBody);

ServiceMethod.java

T toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
}

而这个 responseConverter 是通过 createResponseConverter();返回的

而这个 createResponseConverter() 最后会调用以下方法来生成 responseConverter 。

public  Converter nextResponseBodyConverter(Converter.Factory skipPast,

....

for (int i = start, count = converterFactories.size(); i < count; i++) {
  Converter converter =
      converterFactories.get(i).responseBodyConverter(type, annotations, this);
  if (converter != null) {
    //noinspection unchecked
    return (Converter) converter;
  }
}

.....
}

converterFactories 就是之前传进去的 GsonConverterFactory ，而最后生成 responseConverter 这个对象就是调用了 GsonConverterFactory里面的responseBodyConverter()方法。

那么就看看 GsonConverterFactory里面的responseBodyConverter()方法。

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

那么调用 responseConverter.convert(body) 时 实际调用的就是 GsonResponseBodyConverter 的 convert 方法。

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

上面 GsonResponseBodyConverter 的 convert 方法里最终将会把数据转换成 JSON 格式。

回到 OkHttpCall 类里面。

 return Response.success(body, rawResponse);

最后就会把格式好的JSON对象封装在 Response.success() 里面。返回到 (okhttp3.Call) call.enqueue 方法 里面。

如果网络请求成功将会调用 callSuccess(response);

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

那么就会进行回调到UI线程。

retrofit 里面的网络请求其实就是封装了 OkHttp ，网络请求的细节全部交给了 OkHttp 来进行。