Retrofit2.0的使用之自定义CallAdapter.Factory

上一篇说到自定义Converter.Factory，那么很显然的在开发中我们也可能需要自定义CallAdapter,以实现我们的需求。例如：我们想要获取响应头信息进行某些操作，当然你可以你可以使用Response< T >或Result< T >作为响应实体类，但是如果我们这么写的话，那么在每个响应结果回调的地方都需要处理响应头，显然这是很麻烦的。因此，我们可以在CallAdapter里统一处理我们的响应头信息。

1. 创建自定义的适配器工厂继承自CallAdapter.Factory；
2. 创建自定义的适配器继承自CallAdapter< T >;
3. 创建自定义的回调处理类CustomCall< R >。

一、创建适配器工厂

class MyCallAdapterFactory extends CallAdapter.Factory {    //这里写步骤2、3的内容和一些必要的初始化 参考RxJavaCallAdapter //这个决定了你将采取什么样的CallAdapter @Override public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {        //获取returnType的原始类型  如 CustomCall<R>        Class<?> rawType = getRawType(returnType);        //返回值的类型必须是CustomCall<>  并且带有泛型        if (rawType == CustomCall.class && returnType instanceof ParameterizedType) {            //获取returnType泛型的类型  如Call<MovieDataBean>中的MovieDataBean            Type callReturnType = getParameterUpperBound(0, (ParameterizedType) returnType);            //使用CustomCallAdapter转换处理数据            return new CustomCallAdapter(callReturnType);        } else {            return null;        }    }}

代码中的注释已经比较清晰了，不做赘述；想了解更多的请参考RxJavaCallAdapter的源码。上面代码，提到了new CustomCallAdapter(callReturnType)这就是我们的自定义CallAdapter了，下面来一段示例代码意思一下。

二、自定义的CallAdapter

/***其实这个类也是啥也没写 最终还是由CustomCall完成的*/ class CustomCallAdapter implements CallAdapter<CustomCall<?>> {        private final Type responseType;        // 下面的 responseType 方法需要数据的类型        CustomCallAdapter(Type responseType) {            this.responseType = responseType;        }        @Override        public Type responseType() {            return responseType;        }        @Override        public <R> CustomCall<?> adapt(Call<R> call) {            //由我们自定义的CustomCall<> 处理数据            return new CustomCall<>(call);        }    }

CustomCall< R > 才是真正处理数据的类

//这个类只做一个大致流程的实例 没有什么实际意义class CustomCall<R> {        public final Call<R> call;        public CustomCall(Call<R> call) {            this.call = call;        }        // 提供一个同步获取数据的方法        public R get() throws IOException {            return call.execute().body();        }    }

这个自定义就差不多了。

下面再来一个参考RxJavaCallAdapter创建的一个CallAdapterFactory：

public final class MyRxCallAdapter extends CallAdapter.Factory     public static MyRxCallAdapter create() {        return new MyRxCallAdapter(null);    }    public static MyRxCallAdapter createWithScheduler(Scheduler scheduler) {        if (scheduler == null) throw new NullPointerException("scheduler == null");        return new MyRxCallAdapter(scheduler);    }    private final Scheduler scheduler;    private MyRxCallAdapter(Scheduler scheduler) {        this.scheduler = scheduler;    }    //获取不同的CallAdapter    @Override    public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {        //获取returnType的原始类型        Class<?> rawType = getRawType(returnType);        //获取类名        String canonicalName = rawType.getCanonicalName();        //是否是以下两种类型        boolean isSingle = "rx.Single".equals(canonicalName);        boolean isCompletable = "rx.Completable".equals(canonicalName);        if (rawType != Observable.class && !isSingle && !isCompletable) {            return null;        }        if (!isCompletable && !(returnType instanceof ParameterizedType)) {            String name = isSingle ? "Single" : "Observable";            throw new IllegalStateException(name + " return type must be parameterized"                    + " as " + name + "<Foo> or " + name + "<? extends Foo>");        }        if (isCompletable) {            // Add Completable-converter wrapper from a separate class. This defers classloading such that            // regular Observable operation can be leveraged without relying on this unstable RxJava API.            // Note that this has to be done separately since Completable doesn't have a parametrized            // type.//            return CompletableHelper.createCallAdapter(scheduler);        }        CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType, scheduler);        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, Scheduler scheduler) {        //获取returnType的 泛型参数类型  ParameterizedType-->>泛型        Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);        //获取observableType的原始类的类型        Class<?> rawObservableType = getRawType(observableType);        //返回值是Response<T> 使用ResponseCallAdapter        //我们使用Response<T> 作为返回类型  Observable<Response<T>>        //Response 把Headers、code等一些响应数据放到response里一起返回到我们的回调里（xxSubscriber）        if (rawObservableType == Response.class) {            //毋庸置疑 必须是泛型类型            if (!(observableType instanceof ParameterizedType)) {                throw new IllegalStateException("Response must be parameterized"                        + " as Response<Foo> or Response<? extends Foo>");            }            //获取observableType的泛型参数的类型            Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);            return new ResponseCallAdapter(responseType, scheduler);        }        //返回值是 Result<T> 使用ResultCallAdapter        //我们使用Result<T> 作为返回类型 Observable<Result<T>>        //Result 包含了Response中的所有信息，额外还有error信息        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, scheduler);        }        //返回值是普通的Object 使用SimpleCallAdapter  Observable<T>、Observable<HttpResult<T>>....        //(我们的自定义CallAdapter)其实在SimpleCallAdapter中 还是将Response<HttpResult<T>>转换成了HttpResult<T> 在我们的回调里移除了Response包含的信息        //在原RxJavaCallAdapter中使用 OperatorMapResponseToBodyOrError 把原Response<T> 转换成我们自己声明的类型或错误异常类型        return new SimpleCallAdapter(observableType, scheduler);    }    //结果回调  在这里定义了回调流程 onNext() onError()(如果有异常则 onError() 然后return) onComplete();    static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {        private final Call<T> originalCall;        CallOnSubscribe(Call<T> originalCall) {            this.originalCall = originalCall;        }        @Override        public void call(final Subscriber<? super Response<T>> subscriber) {            // Since Call is a one-shot type, clone it for each new subscriber.            final Call<T> call = originalCall.clone();            // Attempt to cancel the call if it is still in-flight on unsubscription.            subscriber.add(Subscriptions.create(new Action0() {                @Override                public void call() {                    call.cancel();                }            }));            try {                Response<T> response = call.execute();                if (!subscriber.isUnsubscribed()) {                    subscriber.onNext(response);                }            } catch (Throwable t) {                Exceptions.throwIfFatal(t);                if (!subscriber.isUnsubscribed()) {                    subscriber.onError(t);                }                return;            }            if (!subscriber.isUnsubscribed()) {                subscriber.onCompleted();            }        }    }    static final class ResponseCallAdapter implements CallAdapter<Observable<?>> {        private final Type responseType;        private final Scheduler scheduler;        ResponseCallAdapter(Type responseType, Scheduler scheduler) {            this.responseType = responseType;            this.scheduler = scheduler;        }        @Override        public Type responseType() {            return responseType;        }        @Override        public <R> Observable<Response<R>> adapt(Call<R> call) {            Observable<Response<R>> observable = Observable.create(new CallOnSubscribe<>(call));            if (scheduler != null) {                return observable.subscribeOn(scheduler);            }            return observable;        }    }    static final class SimpleCallAdapter implements CallAdapter<Observable<?>> {        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 <R> Observable<R> adapt(Call<R> call) {            Observable<R> observable = Observable.create(new CallOnSubscribe<>(call))                    .flatMap(new Func1<Response<R>, Observable<R>>(){                        @Override                        public Observable<R> call(Response<R> rResponse) {                            //在这里可以获取响应头信息统一处理处理你的逻辑                            return null;                        }                    });            if (scheduler != null) {                return observable.subscribeOn(scheduler);            }            return observable;        }    }    static final class ResultCallAdapter implements CallAdapter<Observable<?>> {        private final Type responseType;        private final Scheduler scheduler;        ResultCallAdapter(Type responseType, Scheduler scheduler) {            this.responseType = responseType;            this.scheduler = scheduler;        }        @Override        public Type responseType() {            return responseType;        }        @Override        public <R> Observable<Result<R>> adapt(Call<R> call) {            Observable<Result<R>> observable = Observable.create(new CallOnSubscribe<>(call)) //                    .map(new Func1<Response<R>, Result<R>>() {                        @Override                        public Result<R> call(Response<R> response) {                            return Result.response(response);                        }                    }).onErrorReturn(new Func1<Throwable, Result<R>>() {                        @Override                        public Result<R> call(Throwable throwable) {                            return Result.error(throwable);                        }                    });            if (scheduler != null) {                return observable.subscribeOn(scheduler);            }            return observable;        }    }}

代码中已经有了很多注释了，我也懒得讲了。这个地方我主要用的是SimpleCallAdapter。