Retrofit原理解析

问题：

1、什么是Retrofit?
2、为什么要用Retrofit？
3、Retrofit原理？

问题1：什么是Retrofit?

Retrofit是squareup公司开源的一个网络请求工具框架，是一种用于Android和java进行网络请求的类型安全客户端。简单理解就是它是一种用于网络请求的工具框架，仅适用于Android和java。
细心的同学会提出疑问怎么是网络请求工具而不是网络请求呢？其实Retrofit对okhttp进行封装，方便网络请求的调用，真正实现网络请求的是okhttp，进行原来解析时会进行应证。

问题2：为什么要用Retrofit？

1、okhttp进行网络请求相对而言偏底层，使用还是比较麻烦，而Retrofit就是为了简便使用okhttp而开发的工具框架，Retrofit还提供了对请求、响应、okhttpclient等进行扩展
2、Retrofit实现了Restful api的设计风格

问题3：Retrofit原理

下面先对Retrofit核心源码进行解析，再对Retrofit原理进行总结：
使用Retrofit时，一般都是先build一个Retrofit实例：

Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(HttpConst.HOST)
                .addConverterFactory(CustomGsonConverter.create(new GsonBuilder()
                        .disableHtmlEscaping()
                        .create()))
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .client(buildOkHttp(builder))
                .build();

3.1、我们看下Retrofit.Builder的build方法

public Retrofit build() {
      //http url前缀，一般是域名
      if (baseUrl == null) {
        //如果baseUrl为空则抛出异常
        throw new IllegalStateException("Base URL required.");
      }
      //callFactory的实现类是OkHttpClient
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
         //如果callFactory 为空则创建一个默认的OkHttpClient
        callFactory = new OkHttpClient();
      }
      //http响应回调执行器
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        //callbackExecutor为空，则使用平台的默认回调执行器
        callbackExecutor = platform.defaultCallbackExecutor();
      }
      
      //网络请求适配器工厂类，并添加平台的默认请求请求适配器工厂类
      // Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
      
      //网络响应内容解析工厂类，并添加BuiltInConverters
      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories =
          new ArrayList<>(1 + this.converterFactories.size());

      // Add the built-in converter factory first. This prevents overriding its behavior but also
      // ensures correct behavior when using converters that consume all types.
      converterFactories.add(new BuiltInConverters());
      converterFactories.addAll(this.converterFactories);
      //根据配置参数，构建Retrofit
      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }

上面的代码，可以总结构建Retrofit可配置的主要参数有：
a、baseUrl：http url 前缀，一般是域名，这个是必现要配置的
b、OkHttpClient: 可以不配置，如果配置了必现不为空，如果没有配置则默认创建一个新的OkHttpClient
c、callAdapterFactory: http请求适配器工厂类
d、converterFactory: http网络请求响应内容解析工厂类
3.2、build方法代码中有个platform，我们看下其实现：

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

Builder(Retrofit retrofit) {
      platform = Platform.get();
      //....省略
}

Platform.get的实现：

private static final Platform PLATFORM = findPlatform();

static Platform get() {
    return PLATFORM;
}

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) {
    }
    return new Platform();
  }

findPlatform方法是确定当前是Android还是java，它首先尝试调用Android的API，如果是Android则创建Android平台对象并返回；否则创建Java平台并返回
3.3、Retrofit的create方法
一般创建Retrofit之后，就通过create创建api请求的代理类，我们看下create方法的实现：

/**
@params service 网络请求代理类接口
*/
public <T> T create(final Class<T> service) {
    //校验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, @Nullable Object[] args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            //如果是Object对象，则直接调用Object的方法
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            
            //如果调用的是默认方法，直接调用
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //对网络请求方法进行包装生成ServiceMethod
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            //生成网络请求对象
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            //通过adapt方法进行网络请求
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

上面的代码我们可以看到Retrofit的create方法，使用了动态代理的机制，动态的创建网络请求接口的代理类，通过生成的代理类调用接口方法发起网络请求会进入InvocationHandler的invoke方法，在invoke方法中使用serviceMethod.adapt进行网络请求。
3.4、我们看下ServiceMethod的构建过程build方法：

public ServiceMethod build() {
      //创建网络请求适配器callAdapter
      callAdapter = createCallAdapter();
      //获取网络请求响应内容属类型
      responseType = callAdapter.responseType();
      //网络请求响应内容不允许是Response和okhttp3的response对象
      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?");
      }
      //创建网络请求响应内容解析器
      responseConverter = createResponseConverter();
      
      //解析api注解信息，得到url、头部、请求内容等
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
      //retrofit语义解析，如果请求方法不是get\post\head\delete等则抛出异常
      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }
      //retrofit语义解析，如果没有内容体而实际又有则抛出异常
      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }
      //注解中请求参数个数
      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);
        }
         //注解参数列表
        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }
        //从注解中解析出http头部
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }
      //相对路径为空抛出异常
      if (relativeUrl == null && !gotUrl) {
        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
      }
      //使用了form或者multipart，而没有body则抛出异常
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError("Non-body HTTP method cannot contain @Body.");
      }
      //使用了form而没有field则抛出异常
      if (isFormEncoded && !gotField) {
        throw methodError("Form-encoded method must contain at least one @Field.");
      }
      //使用了multipart而没有part则抛出异常
      if (isMultipart && !gotPart) {
        throw methodError("Multipart method must contain at least one @Part.");
      }
      //创建ServiceMethod对象
      return new ServiceMethod<>(this);
    }

ServiceMeothd的构建过程主要有：

创建网络请求适配器callAdapter
解析出网络请求的返回类型
创建网络请求响应内容解析器responseConverter
对请求Api方法进行解析，解析的内容是获取方法中注解信息
然后对解析出的注解内容进行Retrofit的语义校验和解析，包括：请求方法是否合法、语法是否正确、解析出http头部和请求参数列表等

接着是使用ServiceMethod的adapt进行网络请求，我们看看adapt的实现：

T adapt(Call<R> call) {
    return callAdapter.adapt(call);
  }

adapt的实现是调用网络请求适配器callAdapt的adapt方法进行网络请求
3.5、我们看下callAdapter的创建实现：

private CallAdapter<T, R> createCallAdapter() {
      //获取网络请求接口方法的返回类型
      Type returnType = method.getGenericReturnType();
      //对类型进行校验
      if (Utils.hasUnresolvableType(returnType)) {
        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 {
        //noinspection unchecked
        //通过Retrofit的callAdapter发放创建CallAdapter
        return (CallAdapter<T, R>) 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方法是如何创建CalllAdapter的：

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

Retrofit的callAdapter方法调用nextCallAdapter来创建CallAdapter的，我们继续nextCallAdapter的实现：

public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    //校验网络请求接口方法的返回类型不能为空
    checkNotNull(returnType, "returnType == null");
    //校验网络请求接口方法的注解不能为空
    checkNotNull(annotations, "annotations == null");
    //遍历callAdapterFactories，使用其工厂类进行创建，哪个创建成功则直接返回
    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;
      }
    }
    //无法创建callAdapter抛出异常
    StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
        .append(returnType)
        .append(".\n");
    if (skipPast != null) {
      builder.append("  Skipped:");
      for (int i = 0; i < start; i++) {
        builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
      }
      builder.append('\n');
    }
    builder.append("  Tried:");
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
    }
    throw new IllegalArgumentException(builder.toString());
  }

nextCallAdapter使用CallAdapter工厂类的实现类的get方法进行创建CallAdapter的，我们一般用的是RxJava2CallAdapterFactory，所以我们直接看RxJava2CallAdapterFactory的get方法实现
3.6、RxJava2CallAdapterFactory的get方法实现

@Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    //获取网络请求接口方法的返回类型的泛型，比如Flowable<Response<String>>，则返回Flowable
    Class<?> rawType = getRawType(returnType);
    //判断返回类型是否是Completable
    if (rawType == Completable.class) {
      // Completable is not parameterized (which is what the rest of this method deals with) so it
      // can only be created with a single configuration.
      return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
          false, true);
    }
    //返回类型是否是Flowable
    boolean isFlowable = rawType == Flowable.class;
    //返回类型是否是Single
    boolean isSingle = rawType == Single.class;
    //返回类型是否是Maybe
    boolean isMaybe = rawType == Maybe.class;
    if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
      return null;
    }

    boolean isResult = false;
    boolean isBody = false;
    Type responseType;
    //如果返回类型不是合法的泛型则抛出异常
    if (!(returnType instanceof ParameterizedType)) {
      String name = isFlowable ? "Flowable"
          : isSingle ? "Single"
          : isMaybe ? "Maybe" : "Observable";
      throw new IllegalStateException(name + " return type must be parameterized"
          + " as " + name + "<Foo> or " + name + "<? extends Foo>");
    }
    //返回返回类型的上界，其实就是Response<?>，比如Flowable<Response<String>>则返回Response<String>
    Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
    //获取泛型的类型，比如Response<String>则返回Response
    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>");
      }
      //获取http响应内容类型，比如Response<String>则返回String
      responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
    } else if (rawObservableType == Result.class) {
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Result must be parameterized"
            + " as Result<Foo> or Result<? extends Foo>");
      }
      responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
      //返回内容是Result
      isResult = true;
    } else {
      responseType = observableType;
      //返回内容是body类型
      isBody = true;
    }
    //创建RxJava2CallAdapter
    return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
        isSingle, isMaybe, false);
  }

RxJava2CallAdapterFactory的get返回创建Rxjava2CallAdapter的过程是：

对返回类型进行一层一层泛型的校验和解析
得到返回类型对应的RxJava类型信息，比如：是否是Flowable、Single、Maybe、Result、body等
创建Rxjava2CallAdapter
3.7、我们看RxJava2CallAdapter的adapt实现：
回到网络请求的流程，上面分析到网络请求是调用callAdapter的adapt方法，而我们一般配套使用的是Rxjava，而Rxjava中RxJava2CallAdapter是callAdapter的真实实现类，所有我们接下来看下RxJava2CallAdapter的Adapt方法：

@Override public Object adapt(Call<R> call) {
    //判断是否使用异步，异步我们使用的是异步实现
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);
    //根据3.6中解析出的Rxjava对应类型，是Flowable、Single、Maybe、Result、Body、Response，创建对应的Observable，我们一般使用的是Response
    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }
    
    //设置observable subscribe在哪个线程
    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }
    //设置背压处理方式，Flowable采用的是只保留最后的结果
    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }

Rxjava2CallAdapter的adapt只是构建observable，并返回observalbe，其对网络的请求是通过CallEnqueueObservable实现的
3.8、CallEnqueueObservable的实现

 @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);
    call.enqueue(callback);
  }

3.3中知道这里的originCall是OkHttpCall
3.9、OkHttpCall的enqueue实现

@Override 
public void enqueue(final Callback<T> callback) {
    checkNotNull(callback, "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对象
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          throwIfFatal(t);
          failure = creationFailure = t;
        }
      }
    }

    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

    if (canceled) {
      call.cancel();
    }
    //这里就是okhttp的最原始调用
    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
        Response<T> response;
        try {
          //对http响应内容进行解析
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }

        try {
          //回调网络请求成功
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        //回调网络请求失败
        callFailure(e);
      }

      private void callFailure(Throwable e) {
        try {
         //回调网络请求失败
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }

OkHttpCall的enqueue方法先根据注解中的信息、请求参数构建出okhttp真实的网络请求Call对象，接下来就是okhttp最原始的使用方式了，至于call是如何构建的，这里就不展开说明。
我们看到网络请求响应内容经过parseResponse方法进行解析，下面我们看下其实现。
3.10、网络响应内容解析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.
   //重新构建响应体，这个心的响应体不包含body内容，是为了方便传递
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();
    //获取http响应状态码
    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) {
      rawBody.close();
      return Response.success(null, rawResponse);
    }
    
    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      //调用serviceMethod的toResponse方法进行解析
      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;
    }
  }

上面的代码告诉我们真正的解析是通过ServiceMethod的toResponse方法进行解析的，接下来我们看下其实现：

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

ServiceMethod中通过responseConverter进行解析响应内容。

至此，我们已经解析完Retrofit的具体实现原理，我们可以梳理总结为：

使用构建模式创建Retrofit实例对象
使用动态代理模式，通过Retrofit实例对象的create方法动态创建网络请求接口的代理类
使用代理类调用方法发起网络请求时，会通过CallAdapterFactory创建的CallAdapter对象的adapt方法调用OkHttpCall的enqueue方法发起网络请求
OkHttpCall的enqueue方法先根据注解、请求参数等信息构建出OkHttpClient的网络请求Call对象，接着使用Call对象发起网络请求
网络请求回来时，使用ServiceMethod的toResponse方法中调用响应内容适配器的具体实现类的convert发放进行解析

Retrofit只是对网络请求进行封装的一个框架，它本身并不发起网络请求，为的是方便我们使用、优化我们网络请求的代码、对网络请求进行扩展（可以自定义请求适配器、响应内容解析器等）。

最后使用Retrofit需要注意一下细节：

必须要要配置baseUrl
定义网络请求必须是接口不能是类，且不能继承其他的接口
定义网络请求接口时，必须要遵循Retrofit的语义规则，比如：@GET对应@Query；@FormUrlEncoded对应@Field；@Multipart对应@Part等
如果配套使用Rxjava，则必须遵循RxJava语义
对应OkHttp头部的key不能null也不能为空字符串；value不能为null

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,319评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,801评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,567评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,156评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,019评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,090评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,500评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,192评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,474评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,566评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,338评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,212评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,572评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,890评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,169评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,478评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,661评论 2赞 335

Retrofit原理解析

问题：

问题1：什么是Retrofit?

问题2：为什么要用Retrofit？

问题3：Retrofit原理

推荐阅读更多精彩内容