RequestFactory#Builder
RequestFactory build() {
      //解析方法上面的注解    
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      //...
        
      //解析方法参数中的注解        
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p]);
      }

      //...

      return new RequestFactory(this);
    }
    
    RequestFactory#Builder
    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);
      } ...其它类型的请求
    }
    
    //解析参数注解,要遍历每个参数，因为每个参数都可能有注解
    private ParameterHandler<?> parseParameter(
        int p, Type parameterType, @Nullable Annotation[] annotations) {
      ParameterHandler<?> result = null;
      if (annotations != null) {
        for (Annotation annotation : annotations) {
          ParameterHandler<?> annotationAction =
              parseParameterAnnotation(p, parameterType, annotations, annotation);

          ...
      }
     ...
      return result;
    }
    
    //解析参数注解:贼长的遍历解析，写框架不仅需要架构经验，还是一个体力活
    @Nullable
    private ParameterHandler<?> parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {
      if (annotation instanceof Url) {
        ...
      } else if (annotation instanceof Path) {
        ...
      } else if (annotation instanceof Query) {
        ...
      } else ...

      return null; // Not a Retrofit annotation.
    }

6. ServiceMethod#parseAnnotations=>HttpServiceMethod#parseAnnotations=>HttpServiceMethod#createCallAdapter:目的：解析方法的返回值，确认CallAdapter。

#ServiceMethod
abstract class ServiceMethod<T> {
  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    //上一步有分析
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    //...
    
    //入口，生成HttpServiceMethod对象
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }


}
  

//HttpServiceMethod#parseAnnotations
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    //重点：入口
    CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
    
    //...

    //根据callAdapter构建Converter包装类
    Converter<ResponseBody, ResponseT> responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    //构建HttpServiceMethod
    return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
  }
  
  //HttpServiceMethod
  private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
      Retrofit retrofit, Method method) {
      Type returnType = method.getGenericReturnType();
      //根据返回值获取CallAdapter
      return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
  }

 //Retrofit
 public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }
  
  // Retrofit
  public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    //...
    
    //遍历callAdapterFactories，这个是我们设置retrofit的时候Retrofit#Builder#addCallAdapterFactory
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }

   //...
  }

//ServiceMethod
abstract class ServiceMethod<T> {
  //动态代理最后调用的方法
  abstract T invoke(Object[] args);
}

final class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
  //最终动态代理调用的方法        
  @Override ReturnT invoke(Object[] args) {
    return callAdapter.adapt(
        new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
  }
}

//RxJava2CallAdapter,这是一个CallAdapter其中的一个实现
final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {
 
  @Override public Object adapt(Call<R> call) {
    //这里取做真正的调用
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return RxJavaPlugins.onAssembly(observable);
  }
}


final class CallEnqueueObservable<T> extends Observable<Response<T>> {
  private final Call<T> originalCall;

  CallEnqueueObservable(Call<T> originalCall) {
    this.originalCall = originalCall;
  }

  @Override protected void subscribeActual(Observer<? super Response<T>> observer) {
    // Since Call is a one-shot type, clone it for each new observer.
    Call<T> call = originalCall.clone();
    CallCallback<T> callback = new CallCallback<>(call, observer);
    observer.onSubscribe(callback);
    if (!callback.isDisposed()) {
      //最后的call API    
      call.enqueue(callback);
    }
  }