Retrofit源码浅析
2016-09-13 11:12
274 查看
Retrofit源码浅析
上一篇文章 Retrofit实践，我们只是对使用Retrofit做了初步了解，但是有两个内容，我们当时并没有深入分析，分别是：用于对RxJava支持的适配器 RxJavaCallAdapterFactory，以及 动态代理构造retrofit.create() ，下面我们就进行简单的分析：Retrofit源码浅析
RxJavaCallAdapterFactory
retrofitcreate
RxJavaCallAdapterFactory
上一篇文章，我们猜测，这个方式，实际的实现应该是通过flatMap() 或者 Map()操作符进行的，我们现在就来一看究竟。函数声明：
public final class RxJavaCallAdapterFactory extends CallAdapter.Factory
CallAdapter.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.
*/
public abstract CallAdapter<?> get(Type returnType, Annotation[] annotations,
Retrofit retrofit);
}
}返回一个调用适配器，用于接口方法的返回，好吧，有点绕口，其实也就是构造一个指定返回类型的适配器。我们来具体看下RxJavaCallAdapterFactory 中具体是怎么实现的：
@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
Class<?> rawType = getRawType(returnType); //获取返回指定的返回类型
String canonicalName = rawType.getCanonicalName(); //返回该类型完整类名
boolean isSingle = "rx.Single".equals(canonicalName); //是否包含Single包名
boolean isCompletable = "rx.Completable".equals(canonicalName); //是否包含Completable包名
//如果返回类型不是Observable、Single 或者 Completable中一种，直接返回，不处理
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) {
return CompletableHelper.createCallAdapter(scheduler);
}
//转换
CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType, scheduler);
if (isSingle) {
return SingleHelper.makeSingle(callAdapter);
}
return callAdapter;
}具体请参考注释，我们重点看下转换，也就是对模板类的具体实现：
private CallAdapter<Observable<?>> getCallAdapter(Type returnType, Scheduler scheduler) {
//observableType <rawObservableType <T>> 转换为rawObservableType <T> 比如 observable<Response<T>> 转换为 Response<T>
Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
Class<?> rawObservableType = getRawType(observableType); //rawObservableType <T> 到 rawObservableType 转换 比如 Response<T> 转换为 Response.class
if (rawObservableType == Response.class) { //Response类型处理
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Response must be parameterized"
+ " as Response<Foo> or Response<? extends Foo>");
}
Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType); //rawObservableType <T>转换到 T 比如 Response<T> 转换为 T
return new ResponseCallAdapter(responseType, scheduler);
}
if (rawObservableType == Result.class) { //Result类型处理
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Result must be parameterized"
+ " as Result<Foo> or Result<? extends Foo>");
}
Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType); //rawObservableType <T>转换到 T
return new ResultCallAdapter(responseType, scheduler);
}
//默认处理
return new SimpleCallAdapter(observableType, scheduler);
}接下来 我们来看下这三个XXXCallAdapter
ResponseCallAdapter
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对象，并指定订阅事件CallOnSubscribe<>(call)
Observable<Response<R>> observable = Observable.create(new CallOnSubscribe<>(call));
if (scheduler != null) {
//指定线程
return observable.subscribeOn(scheduler);
}
return observable;
}
}有木有一种很熟悉的感觉，终于到了我们之前讲过的RxJava操作了，我们重点看下CallOnSubscribe<>(call) 的操作
static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {
private final Call<T> originalCall;
CallOnSubscribe(Call<T> originalCall) {
this.originalCall = originalCall; //传入OkHttpCall对象，进行网络操作
}
@Override public void call(final Subscriber<? super Response<T>> subscriber) {
// Since Call is a one-shot type, clone it for each new subscriber.
Call<T> call = originalCall.clone();
// Wrap the call in a helper which handles both unsubscription and backpressure.
RequestArbiter<T> requestArbiter = new RequestArbiter<>(call, subscriber);
subscriber.add(requestArbiter);
subscriber.setProducer(requestArbiter);
}
}我们可以看到 是 重写了 Observable.OnSubscribe 的call方法，通过RequestArbiter生成一个事件生成对象，并加入到subscriber对象中，我们接着看RequestArbiter方法
static final class RequestArbiter<T> extends AtomicBoolean implements Subscription, Producer {
private final Call<T> call;
private final Subscriber<? super Response<T>> subscriber;
RequestArbiter(Call<T> call, Subscriber<? super Response<T>> subscriber) {
this.call = call; //初始化OkHttpCall
this.subscriber = subscriber; //初始化Subscriber<? super Response<T>>
}
@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<T> response = call.execute();
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response); //将网络返回值Response<T> 通过onNext方法回传
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
if (!subscriber.isUnsubscribed()) {
subscriber.onError(t); //将网络异常Throwable t 通过onError方法回传
}
return;
}
if (!subscriber.isUnsubscribed()) {
subscriber.onCompleted(); //完成网络操作，调用onCompleted方法
}
}
@Override public void unsubscribe() {
call.cancel(); //断开OkHttpCall连接
}
@Override public boolean isUnsubscribed() {
return call.isCanceled(); //判断OkHttpCall是否断开连接
}
}到此，就得到了能接收Subscriber
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)) //定义OnSubscribe事件
.map(new Func1<Response<R>, Result<R>>() {//将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;
}
}基本和ResponseCallAdapter 一样，不同的是将Response< T > 转换为 Result< T >
SimpleCallAdapter
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))
.lift(OperatorMapResponseToBodyOrError.<R>instance());
if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;
}
}这里和前面两个callAdapter的区别在于使用life() 进行了转换，我们具体看看这个转换有什么作用
final class OperatorMapResponseToBodyOrError<T> implements Operator<T, Response<T>> {
private static final OperatorMapResponseToBodyOrError<Object> INSTANCE =
new OperatorMapResponseToBodyOrError<>();
@SuppressWarnings("unchecked") // Safe because of erasure.
static <R> OperatorMapResponseToBodyOrError<R> instance() {
return (OperatorMapResponseToBodyOrError<R>) INSTANCE;
}
@Override public Subscriber<? super Response<T>> call(final Subscriber<? super T> child) {
return new Subscriber<Response<T>>(child) {
@Override public void onNext(Response<T> response) {
if (response.isSuccessful()) {
child.onNext(response.body());
} else {
child.onError(new HttpException(response));
}
}
@Override public void onCompleted() {
child.onCompleted();
}
@Override public void onError(Throwable e) {
child.onError(e);
}
};
}
}看函数声明就可以知道，其实就是把 Subscriber< ? super T > 转换成 Subscriber< ? super Response >， 也就是把后者的返回包装然后在前者里返回，算是做了一次封装。
到这里，我们发现，其实在这个OperatorMapResponseToBodyOrError条件限制下，SimpleCallAdapter 只接收Response.body，如果需要获得header,cookies，那么我们可以使用Observable< Response< T>>，代替Observable< T >
总结一下，RxJavaCallAdapterFactory会为返回值类型为Observable< ? >的方法创建一个CallAdapter < Observable< ? >> 对象，并根据Observable< ? >中？的数据类型创建不同的CallAdapter :
| Observable< ? > | CallAdapter |
|---|---|
| Observable< T > | SimpleCallAdapter |
| Observable< Response< T >> | ResponseCallAdapter |
| Observable< Result< T >> | ResultCallAdapter |
介绍了RxJavaCallAdapterFactory，我们接着讲讲 retrofit.create()
retrofit.create()
上一篇文章 我们说过 retrofit.create 是使用了动态代理的方式，对原有的方法进行加工，也就是在原有方法上加入OkHttp请求，现在我们来具体看看它的实现。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, 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);
}
ServiceMethod serviceMethod = loadServiceMethod(method); //1.
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args); //2.
return serviceMethod.callAdapter.adapt(okHttpCall);//3.
}
});
}由函数声明可以看出输入和返回值都是同样的类型，1.函数为接口的每个method创建了一个对应的ServiceMethod, 2.并使用这个ServiceMethod对象创建OkHttpCall, 3.并使用ServiceMethod实例的callAdapter来调用okhttpCall并返回指定返回类型的结果。
下面我们将对这三个过程详细说明：
1.Retrofit.loadServiceMethod
ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method); 1.1.
if (result == null) {
result = new ServiceMethod.Builder(this, method).build(); 1.2.
serviceMethodCache.put(method, result); 1.3.
}
}
return result;
}1.1. 从serviceMethodCache中获取serviceMethod实例
1.2. 如果获取不到，通过建造者模式创建serviceMethod实例
1.3. 将刚创建的serviceMethod实例存入Cache中，方便下次获取
说道这里，可能有童鞋要问，这个serviceMethod到底是什么？要知道一个类有什么作用，看他的变量就知道了
@ServiceMethod.java final okhttp3.Call.Factory callFactory; final CallAdapter<?> callAdapter; private final HttpUrl baseUrl; private final Converter<ResponseBody, T> responseConverter; private final String httpMethod; private final String relativeUrl; private final Headers headers; private final MediaType contentType; private final boolean hasBody; private final boolean isFormEncoded; private final boolean isMultipart; private final ParameterHandler<?>[] parameterHandlers;
现在是不是一目了然，其实，serviceMethod就是我们之前配置的callAdapter, FactoryAdapter以及一些相关网络请求的集合，用源码上的一句话概括
Adapts an invocation of an interface method into an HTTP call
将一个接口函数转换为HTTP请求
2.并使用这个ServiceMethod对象创建OkHttpCall
通过步骤一得到的ServiceMethod对象创建OkHttpCall。实际调用OkHttpCall的相关执行方法时最终是通过调用OkHttpCall内部通过ServiceMethod.callFactory方法创建的okhttp3.Call来执行网络请求。
3.并使用ServiceMethod实例的callAdapter来调用okhttpCall并返回指定返回类型的结果
这个也不用多说了，我们主要学习的RxJavaCallAdapterFactory 已经详细介绍，不清楚可以回去看多两眼。当然不同的CallAdapter用法不一样，用到的时候在学习都可以~
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 解锁Retrofit -- 浅析Retrofit源码
- Android网络开源库-Retrofit(六)源码浅析-上
- Retrofit源码设计模式解析（上）
- Android源码浅析（四）——我在Android开发中常用到的adb命令，Linux命令，源码编译命令
- Universal-ImageLoader源码流程浅析之（一）－－参数配置及主要参数说明
- android的观察者模式源码浅析
- Retrofit2 源码解析
- ansj源码浅析2
- 浅析C++标准库元组（tuple）源码
- SpringMVC之拦截器的源码浅析
- gstreamer核心源码走读typefind原理和对象关系浅析（三）
- Activiti源码浅析：Activiti的活动授权机制
- 浅析Android四大组件之一：ContentProvider 内容提供者 源码
- Android：这是一份全面 &amp; 详细的Retrofit 2.0 源码分析指南
- 三小时完成玩Android/看妹子客户端（Retrofit + RxJava ＋ OkHttp 附源码）
- Activiti源码浅析：Activity与Task
- Spring IOC 源码浅析
- Android 耳机插拔流程源码跟踪浅析
- retrofit源码分析
- Retrofit源码分析以及MVP框架封装使用