Retrofit1.9源码解析（二）

Retrofit已经出到2.0了，但项目里的是1.9所以就来分析下它的源码。

要讲Retrofit,就必须要知道动态代理模式建造者模式。一开始使用的时，须要设置参数，如果没有设置，就用默认的。

restAdapter = new RestAdapter.Builder()
        .setEndpoint( "" )
        .setLogLevel(RestAdapter.LogLevel. FULL )
        .setClient( new OkClient(getClient()))
        .setLog( new RestAdapter.Log() {
            @Override
            public void log (String msg) {
                Log.i( TAG , msg) ;
            }
        })

        .build();

private void ensureSaneDefaults () {
  if ( converter == null ) {
    converter = Platform.get().defaultConverter() ;
  }
  if ( clientProvider == null ) {
    clientProvider = Platform.get().defaultClient() ;
  }
  if ( httpExecutor == null ) {
    httpExecutor = Platform.get().defaultHttpExecutor() ;
  }
  if ( callbackExecutor == null ) {
    callbackExecutor = Platform.get().defaultCallbackExecutor() ;
  }
  if ( errorHandler == null ) {
    errorHandler = ErrorHandler. DEFAULT ;
  }
  if ( log == null ) {
    log = Platform.get().defaultLog() ;
  }
  if ( requestInterceptor == null ) {
    requestInterceptor = RequestInterceptor. NONE ;
  }

}

设置好参数之后，就只需要通过以下代码就能得到clazz接口的代理，这里必须是接口。以前对代理模式以为只有在有实现者时才能使用，而Retrofit告诉我不只如此，虽然没有实现类，但通过代理已经实现了每个方法，具体做什么，是由框架自己决定的。

restAdapter .create(clazz) ;

从下面代码可以看出，重点是RestHandler.

public < T > T create (Class< T > service) {
  Utils.validateServiceClass(service) ;
  return ( T ) Proxy. newProxyInstance(service.getClassLoader() , new Class<?>[] { service } ,
      new RestHandler(getMethodInfoCache(service))) ;

}

首先是获取这个接口的缓存，如果已经解析过，就直接get，否则就新建个map，有个重点类RestMethodInfo。在RestMethodInfo里会判断两种情况，一种是返回值，一种是Callback回调，在这里只能使用一种。

/** Loads {@link #responseObjectType}. Returns {@code true} if method is synchronous. */
private ResponseType parseResponseType () {
  // Synchronous methods have a non-void return type.
  // Observable methods have a return type of Observable.
  Type returnType = method .getGenericReturnType() ;

  // Asynchronous methods should have a Callback type as the last argument.
  Type lastArgType = null;
  Class<?> lastArgClass = null;
  Type[] parameterTypes = method .getGenericParameterTypes() ;
  if (parameterTypes. length > 0 ) {
    Type typeToCheck = parameterTypes[parameterTypes. length - 1 ] ;
    lastArgType = typeToCheck ;
    if (typeToCheck instanceof ParameterizedType) {
      typeToCheck = ((ParameterizedType) typeToCheck).getRawType() ;
    }
    if (typeToCheck instanceof Class) {
      lastArgClass = (Class<?>) typeToCheck ;
    }
  }

  boolean hasReturnType = returnType != void . class;
  boolean hasCallback = lastArgClass != null && Callback. class .isAssignableFrom(lastArgClass ) ;

  // Check for invalid configurations.
  if (hasReturnType && hasCallback) {
    throw methodError( "Must have return type or Callback as last argument, not both." ) ;
  }
  if (!hasReturnType && !hasCallback) {
    throw methodError( "Must have either a return type or Callback as last argument." ) ;
  }

  if (hasReturnType) {
    if (Platform. HAS_RX_JAVA ) {
      Class rawReturnType = Types.getRawType (returnType) ;
      if (RxSupport. isObservable(rawReturnType)) {
        returnType = RxSupport.getObservableType (returnType , rawReturnType) ;
        responseObjectType = getParameterUpperBound((ParameterizedType) returnType) ;
        return ResponseType. OBSERVABLE ;
      }
    }
    responseObjectType = returnType ;
    return ResponseType. OBJECT ;
  }

  lastArgType = Types.getSupertype(lastArgType , Types.getRawType(lastArgType) , Callback. class ) ;
  if (lastArgType instanceof ParameterizedType) {
    responseObjectType = getParameterUpperBound((ParameterizedType) lastArgType) ;
    return ResponseType. VOID ;
  }

  throw methodError( "Last parameter must be of type Callback<X> or Callback<? super X>." ) ;

}

暂时只关注CallBack方式，的只需要CallBackRunnable那段代码就行。

private class RestHandler implements InvocationHandler {
  private final Map<Method , RestMethodInfo> methodDetailsCache ;

  RestHandler(Map<Method , RestMethodInfo> methodDetailsCache) {
    this . methodDetailsCache = methodDetailsCache ;
  }

  @SuppressWarnings ( "unchecked" ) //
  @Override public Object invoke (Object proxy , Method method , final 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) ;
    }

    // Load or create the details cache for the current method.
    final RestMethodInfo methodInfo = getMethodInfo( methodDetailsCache , method) ;

    if (methodInfo. isSynchronous ) {
      try {
        return invokeRequest( requestInterceptor , methodInfo , args) ;
      } catch (RetrofitError error) {
        Throwable newError = errorHandler .handleError(error) ;
        if (newError == null ) {
          throw new IllegalStateException( "Error handler returned null for wrapped exception." ,
              error) ;
        }
        throw newError ;
      }
    }

    if ( httpExecutor == null || callbackExecutor == null ) {
      throw new IllegalStateException( "Asynchronous invocation requires calling setExecutors." ) ;
    }

    if (methodInfo. isObservable ) {
      if ( rxSupport == null ) {
        if (Platform. HAS_RX_JAVA ) {
          rxSupport = new RxSupport( httpExecutor , errorHandler , requestInterceptor ) ;
        } else {
          throw new IllegalStateException( "Observable method found but no RxJava on classpath." ) ;
        }
      }
      return rxSupport .createRequestObservable( new RxSupport.Invoker() {
        @Override public ResponseWrapper invoke (RequestInterceptor requestInterceptor) {
          return (ResponseWrapper) invokeRequest(requestInterceptor , methodInfo , args ) ;
        }
      }) ;
    }

    // Apply the interceptor synchronously, recording the interception so we can replay it later.
    // This way we still defer argument serialization to the background thread.
    final RequestInterceptorTape interceptorTape = new RequestInterceptorTape() ;
    requestInterceptor .intercept(interceptorTape) ;

    Callback<?> callback = (Callback<?>) args[args. length - 1 ] ;
    httpExecutor .execute( new CallbackRunnable(callback , callbackExecutor , errorHandler ) {
      @Override public ResponseWrapper obtainResponse () {
        return (ResponseWrapper) invokeRequest( interceptorTape , methodInfo , args ) ;
      }
    }) ;
    return null; // Asynchronous methods should have return type of void.

  }

下面这个是CallBackRunnable的Run代码，注意到一开始就调用了obtainResponse()，也是在这里发送请求的，又交给了RestAdapter类执行。

@SuppressWarnings ( "unchecked" )
@Override public final void run () {
  try {
    final ResponseWrapper wrapper = obtainResponse() ;
    callbackExecutor .execute( new Runnable() {
      @Override public void run () {
        callback .success(( T ) wrapper . responseBody , wrapper . response ) ;
      }
    }) ;
  } catch (RetrofitError e) {
    Throwable cause = errorHandler .handleError(e) ;
    final RetrofitError handled = cause == e ? e : unexpectedError(e.getUrl() , cause) ;
    callbackExecutor .execute( new Runnable() {
      @Override public void run () {
        callback .failure( handled ) ;
      }
    }) ;
  }

}

在下面代码里，一开始就去解析这个方法的Annotation跟参数Annotation，得到这个url的请求方式，路径，头部等信息。再经过RequestBuider跟ServerUrl组装起来，最后交给Client请求，在这里目前是OKClient.这个是在PlatForm里得到的。最后就把返回结果转化后回调CallBack,这个是通过Retrofit的线程池来的：

callbackExecutor .execute( new Runnable() {
  @Override public void run () {
    callback .success(( T ) wrapper . responseBody , wrapper . response ) ;
  }

});

  /**
   * Execute an HTTP request.
   *
   * @return HTTP response object of specified {@code type} or {@code null}.
   * @throws RetrofitError if any error occurs during the HTTP request.
   */
  private Object invokeRequest (RequestInterceptor requestInterceptor , RestMethodInfo methodInfo ,
      Object[] args) {
    String url = null;
    try {
      methodInfo.init() ; // Ensure all relevant method information has been loaded.

      String serverUrl = server .getUrl() ;
      RequestBuilder requestBuilder = new RequestBuilder(serverUrl , methodInfo , converter ) ;
      requestBuilder.setArguments(args) ;

      requestInterceptor.intercept(requestBuilder) ;

      Request request = requestBuilder.build() ;
      url = request.getUrl() ;

      if (!methodInfo. isSynchronous ) {
        // If we are executing asynchronously then update the current thread with a useful name.
        int substrEnd = url.indexOf( "?" , serverUrl.length()) ;
        if (substrEnd == - 1 ) {
          substrEnd = url.length() ;
        }
        Thread.currentThread ().setName( THREAD_PREFIX
            + url.substring(serverUrl.length() , substrEnd)) ;
      }

      if ( logLevel .log()) {
        // Log the request data.
        request = logAndReplaceRequest( "HTTP" , request , args) ;
      }

      Object profilerObject = null;
      if ( profiler != null ) {
        profilerObject = profiler .beforeCall() ;
      }

      long start = System.nanoTime() ;
      Response response = clientProvider .get().execute(request) ;
      long elapsedTime = TimeUnit. NANOSECONDS .toMillis(System.nanoTime() - start) ;

      int statusCode = response.getStatus() ;
      if ( profiler != null ) {
        RequestInformation requestInfo = getRequestInfo(serverUrl , methodInfo , request) ;
        //noinspection unchecked
        profiler .afterCall(requestInfo , elapsedTime , statusCode , profilerObject) ;
      }

      if ( logLevel .log()) {
        // Log the response data.
        response = logAndReplaceResponse(url , response , elapsedTime) ;
      }

      Type type = methodInfo. responseObjectType ;

      if (statusCode >= 200 && statusCode < 300 ) { // 2XX == successful request
        // Caller requested the raw Response object directly.
        if (type.equals(Response. class )) {
          if (!methodInfo. isStreaming ) {
            // Read the entire stream and replace with one backed by a byte[].
            response = Utils. readBodyToBytesIfNecessary(response) ;
          }

          if (methodInfo. isSynchronous ) {
            return response ;
          }
          return new ResponseWrapper(response , response) ;
        }

        TypedInput body = response.getBody() ;
        if (body == null ) {
          if (methodInfo. isSynchronous ) {
            return null;
          }
          return new ResponseWrapper(response , null ) ;
        }

        ExceptionCatchingTypedInput wrapped = new ExceptionCatchingTypedInput(body) ;
        try {
          Object convert = converter .fromBody(wrapped , type) ;
          logResponseBody(body , convert) ;
          if (methodInfo. isSynchronous ) {
            return convert ;
          }
          return new ResponseWrapper(response , convert) ;
        } catch (ConversionException e) {
          // If the underlying input stream threw an exception, propagate that rather than
          // indicating that it was a conversion exception.
          if (wrapped.threwException()) {
            throw wrapped.getThrownException() ;
          }

          // The response body was partially read by the converter. Replace it with null.
          response = Utils. replaceResponseBody(response , null ) ;

          throw RetrofitError. conversionError(url , response , converter , type , e) ;
        }
      }

      response = Utils.readBodyToBytesIfNecessary (response) ;
      throw RetrofitError. httpError(url , response , converter , type) ;
    } catch (RetrofitError e) {
      throw e ; // Pass through our own errors.
    } catch (IOException e) {
      if ( logLevel .log()) {
        logException(e , url) ;
      }
      throw RetrofitError.networkError(url , e) ;
    } catch (Throwable t) {
      if ( logLevel .log()) {
        logException(t , url) ;
      }
      throw RetrofitError.unexpectedError(url , t) ;
    } finally {
      if (!methodInfo. isSynchronous ) {
        Thread.currentThread ().setName( IDLE_THREAD_NAME ) ;
      }
    }
  }

}