Retrofit的使用与深入学习（下）

注意：以下分析都是基于Retrofit2

转载请注明出处：http://blog.csdn.net/evan_man/article/details/51320637

    本节是《Retrofit的使用与深入学习》的进阶版本，着重讲解一下Retrofit中的Converter.Factory和CallAdapter.Factory两个对象。正式介绍之前，首先回顾一下这两个抽象类都定义了哪些方法：

public interface CallAdapter {
  Type responseType();   //该请求适配器返回的数据类型
   T adapt(Call call);  //该请求适配器对原始Call的再次封装，如Call到Observable，这里的Call在retrofit2中都是OkHttpCall对象
  abstract class Factory {
    public abstract CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit); //获取网络请求适配器
    protected static Type getParameterUpperBound(int index, ParameterizedType type) { return Utils.getParameterUpperBound(index, type); } 
    //Example：完成Map 到  Runnable的转变；第i个参数的最上层的数据类型
    protected static Class getRawType(Type type) {  return Utils.getRawType(type); }
     //Example：完成List 到 List.class的转变;  即得到最外层的那个数据类型
  }
}

public interface Converter {
  T convert(F value) throws IOException;
  abstract class Factory {
    public Converter responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) { return null; } //对响应数据的转换
    public Converter requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { return null; } //对请求数据的转换
    public Converter stringConverter(Type type, Annotation[] annotations, Retrofit retrofit) {  return null;  }  //String类型转换
  }
}

    本节我们将先对Retrofit默认网络请求适配器ExecutorCallAdapterFactory和RxJavaCallAdapterFactory进行介绍，随后介绍Retrofit的默认内容转换器BuiltInConverters和GsonConverterFactory。在此需要在此强调的是Retrofit的ArrayList adapterFactories集合中ExecutorCallAdapterFactory位于该集合的末尾。Retrofit的ArrayList converterFactories集合中BuiltInConverters位于该集合的首位。在接口方法Method向ServiceMethod的转化过程中，都是从adapterFactories和converterFactories集合的首位开始往后找的，因此集合中的工厂位置越靠前就拥有越高的使用权限，因为GsonConverterFactory它能对任何数据都可以进行转换(最多转换异常嘛)，因此Retrofit作者特别强调一定将GsonConverterFactory添加到Retrofit的converterFactories集合的末尾。

ExecutorCallAdapterFactory.class

final class ExecutorCallAdapterFactory extends CallAdapter.Factory

ExecutorCallAdapterFactory()@ExecutorCallAdapterFactory.class

类只有一个域，即回调方法执行器

final Executor callbackExecutor;
ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
}

只有一个用于返回CallAdapter>对象的get方法

get()@ExecutorCallAdapterFactory.class

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

1、创建一个回调请求执行器，该执行器实现了Call接口

static final class ExecutorCallbackCall implements Call

ExecutorCallbackCall.class@ExecutorCallAdapterFactory.class

final Executor callbackExecutor; //回调方法执行器
final Call delegate;//网络请求实体
ExecutorCallbackCall(Executor callbackExecutor, Call delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
}
@Override public boolean isExecuted() { return delegate.isExecuted(); }
@Override public Call clone() {  return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone()); }
@Override public Request request() { return delegate.request(); }

@Override public Response execute() throws IOException {  return delegate.execute(); } //note1
@Override public void enqueue(final Callback callback) {//note2
      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()) {  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); } 
          });
        }
      });
}

1、同步请求直接调用OkHttpCall的同名方法去执行

2、异步请求将相应的结果交给callbackExecutor回调执行器去执行

    综上我们对ExecutorCallAdapterFactory.class的总结就是，该对象存储一个回调执行器；通过该工厂的get方法得到的CallAdapter对象类型是固定的，跟returnType，annotations等参数都没有关系。CallAdapter对象的adapt方法返回的Call对象基本透明，网络请求都是通过调用adapt传入参数Call对象的同名方法。

RxJavaCallAdapterFactory.class

public final class RxJavaCallAdapterFactory extends CallAdapter.Factory

RxJavaCallAdapterFactory()@RxJavaCallAdapterFactory.class

private final Scheduler scheduler;
private RxJavaCallAdapterFactory(Scheduler scheduler) {
    this.scheduler = scheduler;
}
public static RxJavaCallAdapterFactory create() {
    return new RxJavaCallAdapterFactory(null);
}

scheduler默认是一个null，用于设计Observable.subscribeOn(scheduler)；即Subscriber对象的onStart方法执行线程，一般没什么卵用。

get()@RxJavaCallAdapterFactory.class

public CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    Class rawType = getRawType(returnType); //note1
    String canonicalName = rawType.getCanonicalName(); //note2
    boolean isSingle = "rx.Single".equals(canonicalName); //note3
    boolean isCompletable = "rx.Completable".equals(canonicalName);
    if (rawType != Observable.class && !isSingle && !isCompletable) { //note4
      return null;
    }
    if (!isCompletable && !(returnType instanceof ParameterizedType)) {
      String name = isSingle ? "Single" : "Observable";
      throw new IllegalStateException(name + " return type must be parameterized" + " as " + name + " or " + name + ""); 
    }
    if (isCompletable) {  
      return CompletableHelper.createCallAdapter(scheduler);
    }
    CallAdapter> callAdapter = getCallAdapter(returnType, scheduler); //note5
    if (isSingle) {
      return SingleHelper.makeSingle(callAdapter);
    }
    return callAdapter;
}

1、获取返回值类型的最外层的类；对于List就会得到List.class;

2、返回该类含包名的名字；参考

3、是否是rx.Single 、rx.Completable两个类

4、如果返回值类型最外层不是rx.Single 、rx.Completable、Observable则该RxJavaCallAdapterFactory不对其进行处理；将交给Retrofit的adapterFactories集合中的下一个CallAdapter.Factory进行处理。

5、对于Completable Single Observable我们只介绍最后一个Observable

getCallAdapter()@RxJavaCallAdapterFactory.class

private CallAdapter> getCallAdapter(Type returnType, Scheduler scheduler) {
    Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType); //note1
    Class rawObservableType = getRawType(observableType); //note2
    if (rawObservableType == Response.class) {
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized"  + " as Response or Response"); 
      }
      Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType); //note3
      return new ResponseCallAdapter(responseType, scheduler); //note4
    }
    if (rawObservableType == Result.class) {
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Result must be parameterized"  + " as Result or Result"); 
      }
      Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
      return new ResultCallAdapter(responseType, scheduler); //note5
    }
    return new SimpleCallAdapter(observableType, scheduler); //note6
  }

1、Observable> 到Response的转变；

2、Response 到 Response的转变；

3、Response 到 T 的转变；

4、Observable>创建一个ResponseCallAdapter对象

5、Observable>创建一个ResultCallAdapter对象

6、默认创建一个SimpleCallAdapter对象，先对该对象进行介绍

SimpleCallAdapter.class@RxJavaCallAdapterFactory.class

static final class SimpleCallAdapter implements CallAdapter> {
    private final Type responseType;
    private final Scheduler scheduler;
    SimpleCallAdapter(Type responseType, Scheduler scheduler) {
      this.responseType = responseType;
      this.scheduler = scheduler;
    }
    @Override public Type responseType() {
      return responseType;
    }
    @Override public  Observable adapt(Call call) {
      Observable observable = Observable.create(new CallOnSubscribe<>(call)) // note1
          .lift(OperatorMapResponseToBodyOrError.instance()); //note2
      if (scheduler != null) {
        return observable.subscribeOn(scheduler); //note3
      }
      return observable;
    }
}

哈哈哈，很熟悉的RxJava操作——lift&Operator，如果看到这里你没有眼前一亮或者不懂博主的自言自语，那么十分推荐去看看本人的另外一篇博客《RxJava的使用与深入学习》,因为接下来的讲解都是默认你知道RxJava的内部工作原理进行讲解的，不然你也可以硬着头皮往下看。

1、CallOnSubscribe<>(Call call)一猜就知道在OnSubscribe的call方法中会利用参数call获取一个最原始的网络Response数据,不信你看CallOnSubscribe.class的call方法源码 (后面有给出)；

2、OperatorMapResponseToBodyOrError是对Subscribe对象的一次封装，封装后的Subscribe对象会对前面得到的Response进行一定的预处理后（从Operator的名字来看就是对Response状态进行判断），再传递给后面的Subscribe对象进行处理；

3、如果scheduler不为空则用该scheduler设置Observable的subscribe方法的执行线程

CallOnSubscribe.class@RxJavaCallAdapterFactory.class

static final class CallOnSubscribe implements Observable.OnSubscribe> {
    private final Call originalCall; //note1
    CallOnSubscribe(Call originalCall) {
      this.originalCall = originalCall;
    }
    @Override public void call(final Subscriber> subscriber) { //note1.5
      Call call = originalCall.clone();
      RequestArbiter requestArbiter = new RequestArbiter<>(call, subscriber); //note2
      subscriber.add(requestArbiter);
      subscriber.setProducer(requestArbiter); //note3
    }
}

1、构造该方法是传入的OkHttpCall对象，用于执行网络请求

1.5、该SubscribeOn能处理的Subscribe对象是Subscriber> 类型

2、利用OkHttpCall和Subscriber>创建一个事件生成对象

3、一般该方法的结果就是调用requestArbiter.request(Integer.MAX_VALUE);所以我们接下来看看RequestArbiter类的request方法是如何定义的。

RequestArbiter.class@RxJavaCallAdapterFactory.class

static final class RequestArbiter extends AtomicBoolean implements Subscription, Producer {
    private final Call call; //构造该对象时传入的OkHttpCall
    private final Subscriber> subscriber; //构造该对象时传入的Subscriber>
    RequestArbiter(Call call, Subscriber> subscriber) {
      this.call = call;
      this.subscriber = subscriber;
    }
    @Override public void request(long n) {
      if (n < 0) throw new IllegalArgumentException("n < 0: " + n);
      if (n == 0) return; // Nothing to do when requesting 0.
      if (!compareAndSet(false, true)) return; // Request was already triggered.
      try {
        Response response = call.execute(); //note1
        if (!subscriber.isUnsubscribed()) { subscriber.onNext(response); }  //note2
      } catch (Throwable t) {
        Exceptions.throwIfFatal(t);
        if (!subscriber.isUnsubscribed()) { subscriber.onError(t);}  //note3
        return;
      }
       if (!subscriber.isUnsubscribed()) { subscriber.onCompleted(); }  //note4
    }
    @Override public void unsubscribe() {  call.cancel(); }  //note5
    @Override public boolean isUnsubscribed() {   return call.isCanceled(); }  //note6
}

1、通过OkHttpCall的execute——同步请求，获取Response对象

2、如果当前subscribe没有解绑，调用Subscriber>的onNext方法处理上面得到的Response对象

3、如果当前subscribe没有解绑，调用Subscriber>的onError方法处理异常t

4、如果当前subscribe没有解绑，调用Subscriber>的onCompleted()方法

5、如果当前subscribe要求解绑，调用OkHttpCall的cancel()方法断开连接

6、判断一个subscribe是否解绑，实则是判断OkHttpCall是否断开连接

发现没，如果使用Observable进行网络访问，那么一旦Subscribe解除绑定就会断开网络连接，而且不再接收任何网络信息，这也是为什么Retrofit作者建议在Activity和Fragment中使用Retrofit+RxJava时一定要在onDestiny方法中调用subscription.unsubscribe()方法解除绑定的原因，即断开网络连接，回收网络资源。

到此为止我们分析完了[email protected]的note1，得到的Observable 能接收Subscriber>类型的订阅者。接着我们继续分析note2的.lift(OperatorMapResponseToBodyOrError.instance())操作。

OperatorMapResponseToBodyOrError.class

final class OperatorMapResponseToBodyOrError implements Operator> {
  private static final OperatorMapResponseToBodyOrError