目前打算选用Retrofit2+RxJava2作为网络请求框架,下面从源码角度分析下这两个框架是怎么粘合在一起的。
看完本文,你将会看到:
- 动态代理模式在Retrofit中的运用。
- 抽象工厂模式在Retrofit中的运用。
- RxJava2如何和Retrofit结合实现网络请求模块。
使用Retrofit实现网络请求
定义一个Service接口
//https://api.douban.com/v2/book/1220562
public interface IDoubanService {
@GET("/v2/{book}/{bookId}")
Call<Book> getBookInfo(@Path("book") String book, @Path("bookId") String bookId);
@GET("/v2/{book}/{bookId}")
Observable<Book> getBookInfoObservable(@Path("book") String book, @Path("bookId") String bookId);
}
接口中的方法就是我们实际要执行的网络请求,方法的返回值就是CallAdapter的返回值,如果没有的话,默认返回Call对象。
如果我们自定义了一个返回类型,并且没有加上对应的CallAdapterFactory的话,那么抛出异常,如下:
Caused by: java.lang.IllegalArgumentException: Unable to create call adapter for class java.lang.String
使用Retrofit创建接口的动态代理
final String bookId = "1220562";
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.douban.com/")
// 将Response通过GSON转成POJO
.addConverterFactory(GsonConverterFactory.create())
// 将接口方法根据类型返回
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.client(new OkHttpClient())
.build();
// 使用Retrofit创建接口的代理对象
IDoubanService service = retrofit.create(IDoubanService.class);
Call<Book> call = service.getBookInfo("book", bookId);
// 使用Call对象获取网络请求结果
Response<Book> response = call.execute();
Book book = response.body();
上面的示例中使用的Call进行获取的网络请求,实际上我们可以通过CallAdapterFactory这种抽象工厂来创建我们自己的返回类型,稍后详细分析。
Retrofit中的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();
@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.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
// Platform这个类用来区分平台,如果是Java8的话,接口中会有default方法
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
// 将这个反射的方法封装成ServiceMethod
// ServiceMethod会将接口中的注解进行解析
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
// 创建真实的Call对象
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
ServiceMethod中的createCallAdapter()用于获取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);
}
// 返回值不能是void
if (returnType == void.class) {
throw methodError("Service methods cannot return void.");
}
Annotation[] annotations = method.getAnnotations();
try {
//noinspection unchecked
// 最终会从Retrofit的CallAdapter中进行查找,还记得之前的addCallAdapterFactroy()抽象工厂么?
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#nextCallAdapter(),在这个方法中,会进行遍历,将Annotion和returnType传入,直到有一个Factroy能够返回非空的CallAdapter
/**
* Returns a call adapter for interface methods that return {@code returnType}, or null if it
* cannot be handled by this factory.
*/
// 这个方法需要返回非空的CallAdapter
public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
Retrofit retrofit);
RxJava2ConvertFactory的实现
核心的get()
@Override
public 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);
}
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 + "<Foo> or " + name + "<? extends Foo>");
}
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<Foo> or Response<? extends Foo>");
}
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);
isResult = true;
} else {
responseType = observableType;
isBody = true;
}
// 一般情况返回一个 RxJava2CallAdapter
return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
isSingle, isMaybe, false);
}
RxJava2CallAdapter中的adaper()
CallAdapter中有一个核心方法是adapt(),作用是将Call对象转化成任意的类型
/**
* Returns an instance of {@code T} which delegates to {@code call}.
* <p>
* For example, given an instance for a hypothetical utility, {@code Async}, this instance would
* return a new {@code Async<R>} which invoked {@code call} when run.
* <pre><code>
* @Override
* public <R> Async<R> adapt(final Call<R> call) {
* return Async.create(new Callable<Response<R>>() {
* @Override
* public Response<R> call() throws Exception {
* return call.execute();
* }
* });
* }
* </code></pre>
*/
T adapt(Call<R> call);
RxJava2CallAdapter中的实现
// 此处就将Call对象转换成Observable了
@Override public Object adapt(Call<R> call) {
// 先创建一个Observable对象,根据是否是异步,默认情况下不是异步
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 observable;
}
RxJava进行网络请求
RxJava接受网络请求的过程如下
observable
// 网络请求在IO线程执行
.subscribeOn(Schedulers.io())
// 回调到主线程
.observeOn(AndroidSchedulers.mainThread())
.subscribe((book) -> {
mTvText.setText(String.valueOf(book));
});
Retrofit+Factory将网络请求抽象成了一个Observable对象,那么我们可以通过RxJava这样的方法操作网络请求了。
Retrofit返回Observable的实现是CallExecuteObservable或者CallEnqueueObservable,我们看下这个Observable的实现。
final class CallExecuteObservable<T> extends Observable<Response<T>> {
private final Call<T> originalCall;
CallExecuteObservable(Call<T> originalCall) {
this.originalCall = originalCall;
}
// 如果在Observeable中进行订阅操作,那么实际会调用到这个方法
@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();
observer.onSubscribe(new CallDisposable(call));
boolean terminated = false;
try {
// 会调用Call执行网络请求,获取Response对象
Response<T> response = call.execute();
if (!call.isCanceled()) {
observer.onNext(response);
}
if (!call.isCanceled()) {
terminated = true;
observer.onComplete();
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
if (terminated) {
RxJavaPlugins.onError(t);
} else if (!call.isCanceled()) {
try {
observer.onError(t);
} catch (Throwable inner) {
Exceptions.throwIfFatal(inner);
RxJavaPlugins.onError(new CompositeException(t, inner));
}
}
}
}
private static final class CallDisposable implements Disposable {
private final Call<?> call;
CallDisposable(Call<?> call) {
this.call = call;
}
@Override public void dispose() {
call.cancel();
}
@Override public boolean isDisposed() {
return call.isCanceled();
}
}
}