看看Retrofit2.0运行方式

写下这篇你文章，主要是纪念自己的无知和善良，以及要好好学习啊。 都说Retrofit是大Android目前最简单的网络请求框架，和RxJava结合简直就是天人合一，的确，项目中用来一下，的确好用，好玩，也好快(这要靠OkHttp的功劳)，写下这个纪念一下Retrofit2.0的工作流程，菜鸟大神勿喷。

首先，gradle配置：

    compile 'io.reactivex:rxjava:1.1.0'    compile 'io.reactivex:rxandroid:1.1.0'    compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4'    compile 'com.squareup.retrofit2:converter-gson:2.0.0-beta4'    compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4'    compile 'com.squareup.okhttp3:logging-interceptor:3.1.2'

Retrofit工具类：

public static <T> T createService(Class<T> clazz) {        if (retrofit == null) {            synchronized (RetrofitUtil.class) {                Retrofit.Builder builder = new Retrofit.Builder();                retrofit = builder.baseUrl(Constant.BASE_IP)                        .client(okHttpClient)                        .addConverterFactory(gsonConverterFactory)                        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())                        .build();            }        }        return retrofit.create(clazz);    }

列出一个项目的接口：

    /**     * 获取商品信息     * @param optionsMap     * @return     */    @GET(Constant.BASE_ACTION)    Observable<ProductDetailBean> getProductInfo(@QueryMap Map<String,String> optionsMap) ;

然后MVP模式中使用：

        UserRetrofitUtil.                createService(UserRequestService.class).                getProductInfo(strParamters).                observeOn(AndroidSchedulers.mainThread()).                subscribeOn(Schedulers.io()).subscribe(new Subscriber<ProductDetailBean>() {            @Override            public void onCompleted() {                getMvpView().hideLoading();            }            @Override            public void onError(Throwable e) {                LogUtils.d("upload error..." + e);                showErrorPage();            }            @Override            public void onNext(ProductDetailBean stateBean) {                LogUtils.d("upload success" + stateBean);                getMvpView().setDataFromRemoteSource(stateBean);            }        });

好了，现在要看大招了，一点一点去分析Retrofit的运行过程了：
1.看Retrofit#create()方法：

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

放心，去掉一大坨方法，只有loadMethodHandler(method).invoke(args)有用：

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

终于Retrofit中一个最重要的类MethodHanlder出现了，就因为它我们就可以随便在我们的方法加上注解，就可以进行网络请求了，稍等会深入说明，methodHandlerCache是一个Map类型的容器，loadMethodHandler方法很明显，获得MethodHanlder。

2.MethodHandler类，来看其create方法：

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存在四个参数：okhttp3.Call.Factory ，RequestFactory，CallAdapter，Converter。基本上这四个参数值就是Retrofit的精髓了：
2.1 okhttp2.Call.Factory：来源retrofit.callFactory(),好看源码：

//Retrofit2.0类中： public okhttp3.Call.Factory callFactory() {    return callFactory;  }

在Retrofit#Builder内部类中存在这样一句话：

      **okhttp3.Call.Factory callFactory = this.callFactory;      if (callFactory == null) {        callFactory = new OkHttpClient();      }**      // Make a defensive copy of the adapters and add the default Call adapter.      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);      adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));      // Make a defensive copy of the converters.      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);      **return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,          callbackExecutor, validateEagerly);**

好了，此时我们Factory就是OkHttpClient了，那么OkHttpClient又是个什么鸟玩意呢？ 不急，进去看看吧：

哦哦哦哦哦，对不起啊，去到了Ok3.0的包里面了，好吧我们越界了，现在就简单了解一下这个OkHttpClient应该是关于请求的吧客户端吧(不是叫client吗，需要用到了再去看了吧)，参数1到此为止。

2.2 RequestFactory：

RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit)

那么现在可以看看这里面写啥吧：

static RequestFactory parse(Method method, Type responseType, Retrofit retrofit) {    RequestFactoryParser parser = new RequestFactoryParser(method);    Annotation[] methodAnnotations = method.getAnnotations();    parser.parseMethodAnnotations(responseType, methodAnnotations);    parser.parseParameters(retrofit, methodAnnotations);    return parser.toRequestFactory(retrofit.baseUrl());  }

比较简洁，但是不简单啊，这5行代码，需要对JAVA的反射知识非常的熟悉，第一次看到了很多方法是我们以前不常用的，这里我也不详细扯蛋了，毕竟这不是重点。
来看parser.parseMethodAnnotations(responseType, methodAnnotations)：

private void parseMethodAnnotations(Type responseType, Annotation[] methodAnnotations) {    for (Annotation annotation : methodAnnotations) {      if (annotation instanceof DELETE) {        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);      } else if (annotation instanceof GET) {        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);      }       ........      //此处省略n多字  }

来看看我们熟悉的@GET解析方法：parseHttpMethodAndPath(“GET”, ((GET) annotation).value(), false);

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {    if (this.httpMethod != null) {      throw methodError(method, "Only one HTTP method is allowed. Found: %s and %s.",          this.httpMethod, httpMethod);    }    this.httpMethod = httpMethod;    this.hasBody = hasBody;    if (value.isEmpty()) {      return;    }    // Get the relative URL path and existing query string, if present.    int question = value.indexOf('?');    if (question != -1 && question < value.length() - 1) {      // Ensure the query string does not have any named parameters.      String queryParams = value.substring(question + 1);      Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);      if (queryParamMatcher.find()) {        throw methodError(method, "URL query string \"%s\" must not have replace block. "            + "For dynamic query parameters use @Query.", queryParams);      }    }    this.relativeUrl = value;    this.relativeUrlParamNames = parsePathParameters(value);  }

代码中主要是确定请求方法，HTTP中网络请求除了我们熟悉的GET/POST之外，还有DELETE/HEAD/PATCH/PUT/OPTIONS等等，别问我为什么，我也是看代码才知道的。

来看parser.parseParameters(retrofit, methodAnnotations);

private void parseParameters(Retrofit retrofit, Annotation[] methodAnnotations) {    Type[] parameterTypes = method.getGenericParameterTypes();    Annotation[][] parameterAnnotationsArray = method.getParameterAnnotations();    boolean gotField = false;    boolean gotPart = false;    boolean gotBody = false;    boolean gotPath = false;    boolean gotQuery = false;    boolean gotUrl = false;    int count = parameterAnnotationsArray.length;    RequestAction[] requestActions = new RequestAction[count];    for (int i = 0; i < count; i++) {      Type parameterType = parameterTypes[i];      if (Utils.hasUnresolvableType(parameterType)) {        throw parameterError(i, "Parameter type must not include a type variable or wildcard: %s",            parameterType);      }      Annotation[] parameterAnnotations = parameterAnnotationsArray[i];      if (parameterAnnotations != null) {        for (Annotation parameterAnnotation : parameterAnnotations) {          RequestAction action = null;          if (parameterAnnotation instanceof Url) {             .....//代码省略n多行             // 本方法主要是处理网络请求的参数，如下：         // @GET("/user/{user}/")         // Call GetUserInfo(@PATH("user") String userId);         // 使用动态代理，将userid=3的值，直接植入到/user/3/中[3为example]         // 所以本方法作用就是处理你使用的Retrofit的中相关注解 并将其封装成请求参数         // 代码很长，不过思路非常清晰，另外还需要一点Http相关的知识，不然有些判断会有点懵         // @Url @PATH @Query @QuertMap @Header @Field @FieldMap @Part @PartMap @Body     else if (parameterAnnotation instanceof Path) {             if (gotQuery) {              throw parameterError(i, "A @Path parameter must not come after a @Query.");            }            if (gotUrl) {              throw parameterError(i, "@Path parameters may not be used with @Url.");            }            if (relativeUrl == null) {              throw parameterError(i, "@Path can only be used with relative url on @%s",                  httpMethod);            }            gotPath = true;            Path path = (Path) parameterAnnotation;            String name = path.value();            validatePathName(i, name);            Converter<?, String> converter =                retrofit.stringConverter(parameterType, parameterAnnotations);            action = new RequestAction.Path<>(name, converter, path.encoded());          } else if (parameterAnnotation instanceof Query) {            Query query = (Query) parameterAnnotation;            String name = query.value();            boolean encoded = query.encoded();            Class<?> rawParameterType = Types.getRawType(parameterType);            if (Iterable.class.isAssignableFrom(rawParameterType)) {              if (!(parameterType instanceof ParameterizedType)) {                throw parameterError(i, rawParameterType.getSimpleName()                    + " must include generic type (e.g., "                    + rawParameterType.getSimpleName()                    + "<String>)");              }              ParameterizedType parameterizedType = (ParameterizedType) parameterType;              Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);              Converter<?, String> converter =                  retrofit.stringConverter(iterableType, parameterAnnotations);              action = new RequestAction.Query<>(name, converter, encoded).iterable();            } else if (rawParameterType.isArray()) {              Class<?> arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());              Converter<?, String> converter =                  retrofit.stringConverter(arrayComponentType, parameterAnnotations);              action = new RequestAction.Query<>(name, converter, encoded).array();            } else {              Converter<?, String> converter =                  retrofit.stringConverter(parameterType, parameterAnnotations);              action = new RequestAction.Query<>(name, converter, encoded);            }            gotQuery = true;          }           .......//代码省略n多行

RequestFactory基本上搞完了，原来就是因为它才让我们写请求如此的简单吧，再次感谢JW，上次还和他私信了，哈哈。。。。

3.现在就看MethodHandler的第三个参数：CallAdapter，这个比较恶心吧，个人感觉：

 //MethodHanlder#create方法中： CallAdapter<?> callAdapter = createCallAdapter(method, retrofit); //createCallAdapter方法： private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {    Type returnType = method.getGenericReturnType();    if (Utils.hasUnresolvableType(returnType)) {      throw Utils.methodError(method,          "Method return type must not include a type variable or wildcard: %s", returnType);    }    if (returnType == void.class) {      throw Utils.methodError(method, "Service methods cannot return void.");    }    Annotation[] annotations = method.getAnnotations();    try {      return retrofit.callAdapter(returnType, annotations);    } catch (RuntimeException e) { // Wide exception range because factories are user code.      throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);    }  }

在后来，我们又发现了还是请求了retrofit的callAdapter，进吧：

public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,      Annotation[] annotations) {    checkNotNull(returnType, "returnType == null");    checkNotNull(annotations, "annotations == null");    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;      }    }**   .....//此处省略n行

看加粗的地方，需要在adapterFactories里面找啊，好吧，找遍了Retrofit类，也没有发现adapterFactories里面被赋值了，突然在Retrofit#Builder中发现：

 public Builder addCallAdapterFactory(CallAdapter.Factory factory) {      adapterFactories.add(checkNotNull(factory, "factory == null"));      return this;    }//Retrofit#builder#build方法中//adapterFactories会优先添加用户添加的CallAdapter，最后会默认添加一个与平台有关的CallAdapterList<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));

这个addCallAdapterFactory是不是哪里用过呢，好吧，我原谅你的记性，看看我们的RetrofitUtils：

retrofit = builder.baseUrl(Constant.BASE_IP)                        .client(okHttpClient)                        .addConverterFactory(gsonConverterFactory)                        .**addCallAdapterFactory(RxJavaCallAdapterFactory.create())**                        .build();

现在这个RxJavaCallAdapterFactory.create()是什么鬼，这个Adapter相信很多人都知道其作用，就是把相关结果封装成我们喜欢操作的方式，进去看看啊：

public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {  /**   * TODO   */  public static RxJavaCallAdapterFactory create() {    return new RxJavaCallAdapterFactory();  }  private RxJavaCallAdapterFactory() {  }@Override  public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {    Class<?> rawType = getRawType(returnType);    boolean isSingle = "rx.Single".equals(rawType.getCanonicalName());    **if (rawType != Observable.class && !isSingle) {      return null;    }**    if (!(returnType instanceof ParameterizedType)) {      String name = isSingle ? "Single" : "Observable";      throw new IllegalStateException(name + " return type must be parameterized"          + " as " + name + "<Foo> or " + name + "<? extends Foo>");    }    CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType);    if (isSingle) {      // Add Single-converter wrapper from a separate class. This defers classloading such that      // regular Observable operation can be leveraged without relying on this unstable RxJava API.      return SingleHelper.makeSingle(callAdapter);    }    return callAdapter;  }  private CallAdapter<Observable<?>> getCallAdapter(Type returnType) {    Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);    Class<?> rawObservableType = getRawType(observableType);    if (rawObservableType == Response.class) {      if (!(observableType instanceof ParameterizedType)) {        throw new IllegalStateException("Response must be parameterized"            + " as Response<Foo> or Response<? extends Foo>");      }      Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);      return new ResponseCallAdapter(responseType);    }    if (rawObservableType == Result.class) {      if (!(observableType instanceof ParameterizedType)) {        throw new IllegalStateException("Result must be parameterized"            + " as Result<Foo> or Result<? extends Foo>");      }      Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);      return new ResultCallAdapter(responseType);    }    return new **SimpleCallAdapter**(observableType);  }static final class **SimpleCallAdapter** implements CallAdapter<Observable<?>> {    private final Type responseType;    SimpleCallAdapter(Type responseType) {      this.responseType = responseType;    }    @Override public Type responseType() {      return responseType;    }    @Override public <R> Observable<R> adapt(Call<R> call) {      return Observable.create(new CallOnSubscribe<>(call)) //          .flatMap(new Func1<Response<R>, Observable<R>>() {            @Override public Observable<R> call(Response<R> response) {              if (response.isSuccess()) {                return Observable.just(response.body());              }              return Observable.error(new HttpException(response));            }          });    }  }

这里又涉及到了RxJava里面，也不扯了，不是特别熟悉，但是能使用的水平就不丢人现眼了，主要是看public CallAdapter

adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));

现在来看Platform类，又是一个十分恶心的类：

class Platform {  private static final Platform PLATFORM = findPlatform();  static Platform get() {    return PLATFORM;  }  //根据各个平台的核心类来获取当前的平台  private static Platform findPlatform() {    try {      //获取当前Android      Class.forName("android.os.Build");      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) {    }    try {     //org.robovm.apple.foundation.NSObject     // NSObject基类foundation框架 这个是关于apple的平台 打住不讨论了      Class.forName("org.robovm.apple.foundation.NSObject");      return new IOS();    } catch (ClassNotFoundException ignored) {    }    return new Platform();  }

显然我们是Andorid了，来看Android了：

static class Android extends Platform {    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {      if (callbackExecutor == null) {        callbackExecutor = new MainThreadExecutor();      }      return new ExecutorCallAdapterFactory(callbackExecutor);    }    //终于看到了Android中熟悉的Handler，显然本Handler是UI线程中跟新UI所使用的，因此可以猜测    //MainThreadExecutor是用于请求之后，用于UI数据的    static class MainThreadExecutor implements Executor {      private final Handler handler = new Handler(Looper.getMainLooper());      @Override public void execute(Runnable r) {        handler.post(r);      }    }  }

4.MethodHandler中最后一个属性 Converter，当然这就是一种转换方式吧，将网络请求结果值转成我们想要的格式，我们比较熟悉的就是JSON/XML了吧，也是在Retrofit#Builder控制的，这里只需要到用的时候再说吧。

 public Builder addConverterFactory(Converter.Factory factory) {      converterFactories.add(checkNotNull(factory, "factory == null"));      return this;    }

好了，MethodHandler处理完了，再次回到Retorfit.create方法中：

public <T> T create(final Class<T> service) {     return loadMethodHandler(method).invoke(args);}

现在来看MethodHandler.invoke方法了：

Object invoke(Object... args) {    return callAdapter.adapt(        new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));  }

在Retrofit中：

//Retrofit#nextCallAdapter for (int i = start, count = adapterFactories.size(); i < count; i++) {      CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);      if (adapter != null) {        return adapter;      }    }

RxJavaAdapterFactory返回的null[具体原因可以看get值]，那么此时adapter就应该为new ExecutorCallAdapterFactory(MainThreadExecutor executor)了，原因看Platform平台中Android，这里就不说了，上面也写了有的。现在来看ExecutorCallAdapterFactory源码了：

final class ExecutorCallAdapterFactory extends CallAdapter.Factory {  final Executor callbackExecutor;  ExecutorCallAdapterFactory(Executor callbackExecutor) {    this.callbackExecutor = callbackExecutor;  }  //此时我们得到了get方法  @Override  public CallAdapter<Call<?>> 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) {        //调用了新的ExecutorCallbackCall类，        //此时callbackExecutor是MainThreadExecutor        //call是我们前面的OkHttpCall，原始是MethodHandler的invoke中一句话：        //***return callAdapter.adapt(        //new OkHttpCall<>(callFactory, requestFactory, args, responseConverter)); **        return new ExecutorCallbackCall<>(callbackExecutor, call);      }    };  }  static final class ExecutorCallbackCall<T> implements Call<T> {    final Executor callbackExecutor;    final Call<T> delegate;    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {      this.callbackExecutor = callbackExecutor;      this.delegate = delegate;    }    //这里delegate就是OkHttpCall，delegate的原意是代理的意思，enqueue方法也就是代理模式的一种写法    @Override public void enqueue(final Callback<T> callback) {      //这里将直接由delegate进行异步请求了，当返回结果时，callbackExecutor将作在UI线程中进行结果回调      delegate.enqueue(new Callback<T>() {        @Override public void onResponse(final Call<T> call, final Response<T> response) {          callbackExecutor.execute(new Runnable() {            @Override public void run() {              if (delegate.isCanceled()) {                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancelation                callback.onFailure(call, new IOException("Canceled"));              } else {                callback.onResponse(call, response);              }            }          });        }        @Override public void onFailure(final Call<T> call, final Throwable t) {          callbackExecutor.execute(new Runnable() {            @Override public void run() {              callback.onFailure(call, t);            }          });        }      });    }

现在我们来看OkHttpCall#enqueue方法：

@Override public void enqueue(final Callback<T> callback) {    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 {          //创建Call对象          call = rawCall = createRawCall();        } catch (Throwable t) {          failure = creationFailure = t;        }      }    }    if (failure != null) {      callback.onFailure(this, failure);      return;    }    if (canceled) {      call.cancel();    }    //这应该是**正式**的请求了，此时call将直接转移到了OKHttp中请求，具体的请求方式我感觉有时间我会去研究的    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);      }      @Override public void onFailure(okhttp3.Call call, IOException e) {        try {          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }      private void callFailure(Throwable e) {        try {          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }      private void callSuccess(Response<T> response) {        try {          callback.onResponse(OkHttpCall.this, response);        } catch (Throwable t) {          t.printStackTrace();        }      }    });  }

当然 我么来看这个call获取方法createRawCall：

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

此时我们知道了，MethodHandler中的第二个参数RequestFactory终于发挥作用了，在这里组装并通过OkHttp3进行网络请求了，requestFactory.create(args)也使用了builder模式：

//RequestFactory#create方法Request create(Object... args) throws IOException {    RequestBuilder requestBuilder =        new RequestBuilder(method, baseUrl.url(), relativeUrl, headers, contentType, hasBody,            isFormEncoded, isMultipart);    if (args != null) {      RequestAction[] actions = requestActions;      if (actions.length != args.length) {        throw new IllegalArgumentException("Argument count ("            + args.length            + ") doesn't match action count ("            + actions.length            + ")");      }      for (int i = 0, count = args.length; i < count; i++) {        actions[i].perform(requestBuilder, args[i]);      }    }    return requestBuilder.build();  }

当然还有parseResponse(rawResponse)方法，这就是我们将获取的ResponseBody转换成我们想要的格式：

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();    int code = rawResponse.code();    //当初就是因为没有看这里的源码，就写了issues给Jake Wharton 没过10mins 给我这个菜鸟回复了    //非常感动 立志要学好android啊....    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 = responseConverter.convert(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;    }  }

所有的方法也就基本上分析了一遍，还有很多地方没有仔细看，不过现在最主要的就是

//MethodHandler#Object invoke(Object... args) {    return callAdapter.adapt(        new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));  }

在adapt方法中：

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

在ExecutorCallbackCall中存在delegate.enqueue方法，此方法就是执行网络请求的过程。
那么我们触发了Retrofit的请求方式 就是call.enqueue/execute 了。。。。

写了很长时间，中间也想放弃了，也卡住好几次，但是慢慢坚持一下吧，菜鸟刚开始写源码分析，写得不好的地方大家见谅，有什么问题也可以提出来，大家共同进步。啦啦啦啦啦，