Retrofit原理（三）：Response响应处理

继续回到我们的create()方法

public <T> T create(final Class<T> 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();private final Object[] emptyArgs = new Object[0];@Override public @Nullable Object invoke(Object proxy, Method method,@Nullable 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);}if (platform.isDefaultMethod(method)) {return platform.invokeDefaultMethod(method, service, proxy, args);}return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);}});}

这次我们进入invoke里面，发现还是那个ServiceMethod

abstract class ServiceMethod<T> {static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);Type returnType = method.getGenericReturnType();if (Utils.hasUnresolvableType(returnType)) {throw methodError(method,"Method return type must not include a type variable or wildcard: %s", returnType);}if (returnType == void.class) {throw methodError(method, "Service methods cannot return void.");}return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);}abstract @Nullable T invoke(Object[] args);
}

invoke()是一个抽象方法，再进入实现方法
HttpServiceMethod

  @Override final @Nullable ReturnT invoke(Object[] args) {//这里接收了Call，也就是OkHttp里面的Call回调Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);//return adapt(call, args);}protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);

然后进入HttpServiceMethon的内部类CallAdapted，里面对adapt进行了实现

  static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {private final CallAdapter<ResponseT, ReturnT> callAdapter;CallAdapted(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,Converter<ResponseBody, ResponseT> responseConverter,CallAdapter<ResponseT, ReturnT> callAdapter) {super(requestFactory, callFactory, responseConverter);this.callAdapter = callAdapter;}//这个callAdapter个人猜测是类似于Converter的作用，不过这个是转换Response@Override protected ReturnT adapt(Call<ResponseT> call, Object[] args) {return callAdapter.adapt(call);}}//R表示接收的类型，T表示转换的类型
public interface CallAdapter<R, T> {...T adapt(Call<R> call);...
}

这里也就暗示了可以配合RxJava的Observeble。
来看看他的实现类，发现有很多，不过我们进入默认的实现类去看
DefaultCallAdapterFactory

@Override public Call<Object> adapt(Call<Object> call) {return executor == null? call: new ExecutorCallbackCall<>(executor, call);}

发现没有做任何的封装，这里再进入ExecutorCallbackCall，发现是DefaultCallAdapterFactory的内部类,而且实现自Call接口
包括enqueue，也就是发送异步请求

@Override public void enqueue(final Callback<T> callback) {checkNotNull(callback, "callback == null");delegate.enqueue(new Callback<T>() {//和OkHttp的使用如出一辙@Override public void onResponse(Call<T> call, final Response<T> response) {callbackExecutor.execute(new Runnable() {@Override public void run() {if (delegate.isCanceled()) {// Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));} else {callback.onResponse(ExecutorCallbackCall.this, response);}}});}@Override public void onFailure(Call<T> call, final Throwable t) {callbackExecutor.execute(new Runnable() {@Override public void run() {callback.onFailure(ExecutorCallbackCall.this, t);}});}});}

好了，再回到CallAdapted里面的Factory内部抽象类

abstract class Factory {/*** Returns a call adapter for interface methods that return {@code returnType}, or null if it* cannot be handled by this factory.*///这个就是放回CallAdaptedpublic abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,Retrofit retrofit);/*** Extract the upper bound of the generic parameter at {@code index} from {@code type}. For* example, index 1 of {@code Map} returns {@code Runnable}.*/protected static Type getParameterUpperBound(int index, ParameterizedType type) {return Utils.getParameterUpperBound(index, type);}/*** Extract the raw class type from {@code type}. For example, the type representing* {@code List} returns {@code List.class}.*/protected static Class<?> getRawType(Type type) {return Utils.getRawType(type);}}

再回到DefaultCallAdapterFactory

@Override public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {//如果返回类型不是Call，直接返回nullif (getRawType(returnType) != Call.class) {return null;}//如果不是参数化类型抛出异常，因为是要是范型嘛if (!(returnType instanceof ParameterizedType)) {throw new IllegalArgumentException("Call return type must be parameterized as Call or Call");}//这里是获取第一个范型参数，注意returnType和responseType的区别final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)? null: callbackExecutor;return new CallAdapter<Object, Call<?>>() {@Override public Type responseType() {return responseType;}@Override public Call<Object> adapt(Call<Object> call) {return executor == null? call: new ExecutorCallbackCall<>(executor, call);}};}

后面也就是执行OKhttp的方法。

支持RxJava

下面来看是怎么支持RxJava的
返回值改用Observable，Repository是一个bean，获取Github仓库的

@GET("/repos/{owner}/{repo}")Observable<Repository> repo(@Path("owner") String owner,@Path("repo") String repo);

同时还需要添加addCallAdapterFactory(RxJava2CallAdapterFactory.create())

//发现这里的实现和CallAdapter如出一辙
@Override public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {Class<?> rawType = getRawType(returnType);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);}
//判断是否是RxJava支持的类型boolean isFlowable = rawType == Flowable.class;boolean isSingle = rawType == Single.class;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 + " or " + name + "");}Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);Class<?> rawObservableType = getRawType(observableType);if (rawObservableType == Response.class) {if (!(observableType instanceof ParameterizedType)) {throw new IllegalStateException("Response must be parameterized"+ " as Response or Response");}responseType = getParameterUpperBound(0, (ParameterizedType) observableType);} else if (rawObservableType == Result.class) {if (!(observableType instanceof ParameterizedType)) {throw new IllegalStateException("Result must be parameterized"+ " as Result or Result");}responseType = getParameterUpperBound(0, (ParameterizedType) observableType);isResult = true;} else {responseType = observableType;isBody = true;}//这里调用的也和上面一样，return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,isSingle, isMaybe, false);}

再进如Rxjava2CallAdapter里的adapt方法，这里完成返回值的适配，基本支持Rxjava的所有类型，也包括Response

@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);}

剩下的部分也就是Rxjava的流程了

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！