Retrofit源码学习记录
1. Retrofit的创建过程
当我们使用Retrofit请求网络时，首先写请求接口
public interface IpService {
@GET("getIpInfo.php?ip=59.108.54.37")
Call<IpModel> getIpMsg();
}
接着，我们调用如下代码来创建Retrofit
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(url)
.addConverterFactory(GsonConverterFactory.create())
.build();
Retrofit是通过建造者模式构建出来的，我们看看第一行Builder()方法做了什么
Builder()方法
public Builder() {
this(Platform.get());
}
很简短，跟进get()方法
get()方法
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
一个静态的get()方法里返回的是PLATFORM，而PLATFORM又是由findPlatform()方法创建的，用处是根据不同运行平台提供不同的线程池
接下来看看创建Retrofit时调用的build()方法
build()方法
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
// Make a defensive copy of the converters.
List<Converter.Factory> converterFactories = new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
converterFactories.addAll(platform.defaultConverterFactories());
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
第1个if语句块中很明显，baseUrl是必须指定的，不然会抛异常
第2个if语句块中的callFactory默认为this.Factory。这个就是我们在构建Retrofit时调用callFactory()方法传进来的，如下所示
callFactory()方法
public Builder callFactory(okhttp3.Call.Factory factory) {
this.callFactory = checkNotNull(factory, "factory == null");
return this;
}
因此，如果需要对OkHttpClient进行设置，则可以构建OkHttpClient对象，然后调用callFactory()方法将设置好的OkHttpClient传进去
再回到上面的build()方法，接着说第2个if语句块，发现如果callFactory为null，就直接创建OkHttpClient
第3个if语句块中的callbackExecutor用来将回调传递到UI线程
第1个List<>集合对象callAdapterFactories主要用于存储对Call进行转化的对象
第2个List<>集合对象converterFactories主要用于存储转化数据对象，此前在创建Retrofit时我们调用的addConverterFactory(GsonConverterFactory.create())就是设置返回的数据支持转换为Gson对象，最终会返回配置好的Retrofit类
2. Call的创建过程
我们创建Retrofit实例并调用如下代码的来生成接口的动态代理对象
IpService ipService = retrofit.create(IpService.class);
我们来看看create()方法做了什么
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 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);
}
});
}
create()方法在第1个return处返回了一个Proxy.newProxyInstance动态代理对象。当我们调用IpService的getIpMsg()方法时，最终会调用InvocationHandler的invoke()方法，它有三个参数，第一个是代理对象，第二个是调用方法，第三个是方法参数。最后的loadServiceMethod(method)中的method就是我们定义的getIpMsg()方法，下面我们看看loadServiceMethod()方法做了什么
loadServiceMethod()方法
private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
从serviceMethodCache查询传入的method是否有缓存，如果有，就用缓存。如果没有，就创建一个，并加入serviceMethodCache缓存起来，下面看看ServiceMethod是如何构建的
ServiceMethod的parseAnnotations()方法
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 T invoke(Object[] args);
}
ServiceMethod是一个抽象类，返回的是它子类HttpServiceMethod的parseAnnotations()方法，如下
HttpServiceMethod的parseAnnotations()方法
final class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
/**
* Inspects the annotations on an interface method to construct a reusable service method that
* speaks HTTP. This requires potentially-expensive reflection so it is best to build each service
* method only once and reuse it.
*/
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
Type responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw methodError(method, "'"
+ Utils.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
throw methodError(method, "HEAD method must use Void as response type.");
}
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
}
在该方法中直接new HttpServiceMethod对象
HttpServiceMethod()方法
private HttpServiceMethod(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
CallAdapter<ResponseT, ReturnT> callAdapter,
Converter<ResponseBody, ResponseT> responseConverter) {
this.requestFactory = requestFactory;
this.callFactory = callFactory;
this.callAdapter = callAdapter;
this.responseConverter = responseConverter;
}
这里就是一个构造器，有一些属性
回到ServiceMethod的parseAnnotations()方法，我们发现callAdapter对象调用了createCallAdapter()方法，跟进看看里头做了什么
createCallAdapter()方法
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method) {
Type returnType = method.getGenericReturnType();
Annotation[] annotations = method.getAnnotations();
try {
//noinspection unchecked
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create call adapter for %s", returnType);
}
}
最后返回的是retroft.callAdapter()方法，继续跟进
callAdapter()方法
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
返回nextCallAdapter()方法
nextCallAdapter()方法
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
在第一个for循环里，还记得callAdapterFactories吗，adapter对象就是Retrofit的build()方法里（如下）的callAdapterFactories对象调用get()方法添加的
build()方法
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
callAdapterFactories列表默认添加defaultCallAdapterFactory()，他指的是ExecutorCallAdapterFactory
defaultCallAdapterFactory()方法
List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
if (callbackExecutor != null) {
return singletonList(new ExecutorCallAdapterFactory(callbackExecutor));
}
return singletonList(DefaultCallAdapterFactory.INSTANCE);
}
ExecutorCallAdapterFactory的get()方法如下
get()方法
@Override public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
get()方法会得到CallAdapter对象，它的responseType会返回数据的真实类型，比如传入的Call<IpMOdell>，responseType()方法就会返回IpModel。最后的adapt()方法会创建ExecutorCallbackCall，将call的回调转发至UI线程
回到上面ServiceMethod的parseAnnotations()方法，调用createResponseConverter()方法创建responseConverter对象
ServiceMethod的parseAnnotations()方法
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
我们看看这个方法做了什么
createResponseConverter()方法
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create converter for %s", responseType);
}
}
返回的是retrofit.responseBodyConverter()方法，点进去看
responseBodyConverter()方法
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);
}
继续跟进nextResponseBodyConverter()方法
nextResponseBodyConverter()方法
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
@Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
checkNotNull(type, "type == null");
checkNotNull(annotations, "annotations == null");
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<ResponseBody, T>) converter;
}
}
原来在这里遍历converterFactories列表存储的Converter.Factory，返回一个合适的converter用来转换对象。
此前我们在创建Retrofit时调用addConverterFactory(GsonConverterFactory.create())，这段代码将GsonConverterFactory添加到converterFactories列表中，表示返回的数据类型支持转换为JSON对象。
再次回到ServiceMethod类，查看这一行代码
ServiceMethod
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
观察RequestFactory的parseAnnotations()方法
RequestFactory的parseAnnotations()方法
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
return new Builder(retrofit, method).build();
}
查看返回的build()方法
RequestFactory的build()方法
RequestFactory build() {
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
...
不多截取，看看parseMethodAnnotation()方法
parseMethodAnnotation()方法
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {
parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
} else if (annotation instanceof HEAD) {
parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
} else if (annotation instanceof PATCH) {
parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
} else if (annotation instanceof POST) {
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
} else if (annotation instanceof PUT) {
parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
} else if (annotation instanceof OPTIONS) {
parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
} else if (annotation instanceof HTTP) {
HTTP http = (HTTP) annotation;
parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
} else if (annotation instanceof retrofit2.http.Headers) {
String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
if (headersToParse.length == 0) {
throw methodError(method, "@Headers annotation is empty.");
}
headers = parseHeaders(headersToParse);
} else if (annotation instanceof Multipart) {
if (isFormEncoded) {
throw methodError(method, "Only one encoding annotation is allowed.");
}
isMultipart = true;
} else if (annotation instanceof FormUrlEncoded) {
if (isMultipart) {
throw methodError(method, "Only one encoding annotation is allowed.");
}
isFormEncoded = true;
}
}
可以看到就是上一篇文章里我们学习过的HTTP请求注解，原来这个方法是用来解析地址和请求方式的
再回头去看看ExecutorCallAdapterFactory的adapt()方法，它创建了ExecutorCallbackCall，ExecutorCallbackCall部分代码如下
ExecutorCallbackCall
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
delegate.enqueue(new Callback<T>() {
@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);
}
});
}
});
}
可以看出这里就是ExecutorCallbackCall对Call的封装，主要通过callbackExecutor将请求回调到UI线程。我们在使用Retrofit时，得到Call对象后会调用它的enqueue()方法，其实调用的是ExecutorCallbackCall的enqueue()方法，从上面代码也可以看出最终调用的时delegate的enqueue()方法，而delegate就是传入的OkHttpCall
OkHttpCall的enqueue()方法
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
okhttp3.Call call;
Throwable failure;
...
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable e) {
throwIfFatal(e);
callFailure(e);
return;
}
...
截取部分，我们看看比较重要的parseResponse()方法
parseResponse()方法
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
// Remove the body's source (the only stateful object) so we can pass the response along.
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
int code = rawResponse.code();
if (code < 200 || code >= 300) {
try {
// Buffer the entire body to avoid future I/O.
ResponseBody bufferedBody = Utils.buffer(rawBody);
return Response.error(bufferedBody, rawResponse);
} finally {
rawBody.close();
}
}
if (code == 204 || code == 205) {
rawBody.close();
return Response.success(null, rawResponse);
}
ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
try {
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
// If the underlying source threw an exception, propagate that rather than indicating it was
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}
这个方法比较明显的是通过状态码code来执行操作，如果顺利，会调用responseConverter.convert()方法
convert()方法
@Nullable T convert(F value) throws IOException;
跟进如下
OptionalConverterFactory的convert()方法
@Override public Optional<T> convert(ResponseBody value) throws IOException {
return Optional.ofNullable(delegate.convert(value));
}
其实这里就是上文我们看的createResponseConverter方法返回的Converter了，因为由上文的方法跟进也是到这里结束，此前例子中我们用的是Gson，因此我们查看GsonConverterFactory里的代码是如何返回Converter的
GsonConverterFactory的responseBodyConverter()方法
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
返回GsonResponseBodyConverter，跟进
GsonResponseBodyConverter
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter<T> adapter;
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
T result = adapter.read(jsonReader);
if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
throw new JsonIOException("JSON document was not fully consumed.");
}
return result;
} finally {
value.close();
}
}
}
在中间的构造器里，最终，创建GsonResponseBodyConverter，并在下面的convert()方法里将回调数据转为JSON格式。Call的enqueue主要做的就是用OkHttp来请求网络，将返回的Response进行数据转换并回调给UI线程
Retrofit源码分析到此结束
我们简单串联一下用到的方法：
Retrofit的创建：
Builder()——get()——build()——callFactory()
Call的创建：
create()——loadServiceMethod()——ServiceMethod的parseAnnotations()——HttpServiceMethod的parseAnnotations()——HttpServiceMethod()
添加adapter对象：
ServiceMethod的parseAnnotations()——createCallAdapter()——callAdapter()——nextCallAdapter()——defaultCallAdapterFactory()——ExecutorCallAdapterFactory的get()
创建转换类型对象：
ServiceMethod的parseAnnotations()——createResponseConverter()——responseBodyConverter()——nextResponseBodyConverter()
解析请求和地址：
ServiceMethod的parseAnnotations()——RequestFactory的parseAnnotations()——RequestFactory的build()——parseMethodAnnotation()
回调和封装：
ExecutorCallAdapterFactory的adapt()——ExecutorCallbackCall类——OkHttpCall的enqueue()——parseResponse()——convert()
总结一下核心思想
Retrofit总的来说是对OkHttp的一层封装，先通过建造者模式构造Retrofit对象，在其build方法中创建了Retrofit的两个核心，即CallAdapter和Converter。前者用于适配返回的数据类型，配合RxJava时就可以返回Observable。后者就是转换器，主要负责把服务器返回的数据ResponseBody转化为 T 类型的对象
然后进入到Retrofit的设计思想里——动态代理，通过create方法创建接口代理对象实例，这个方法里做了一些判断，会根据不同条件选择进入正常流程invoke里或者loadServiceMethod.invoke
先简单介绍一下loadServiceMethod，这个方法它主要是将网络请求方法中的信息比如注解和参数，进行初步的处理。解析接口后又生成了一个RequestFactory请求工厂对象，并且利用这个RequestFactory对象创建了一个CallAdapter。invoke方法里则通过RequestFactory生成一个OkHttpCall对象，然后调用adapt方法，由内部的CallAdapted调用，而这个CallAdapted就是Retrofit动态代理创建的最核心的产物
CallAdapted是adapt方法的实现类，里面的变量callAdapter调用了一个同名adapt方法，存在于CallAdapter接口中。CallAdapter是根据returnType和annotations的类型，从callAdapterFactories工厂中进行查找，从而返回所对应的网络请求适配器。那么既然有查找，反过来寻找添加，添加在一开始的build方法里。添加调用适配器工厂的目的就是支持Call以外的服务方法返回类型，如支持Observable返回类型等（同理于Converter数据转换器）。在callAdapterFactories集合器添加一个默认适配器工厂时，也附带传进去了一个参数callbackExecutor，callbackExecutor是Java8或者Android平台的一个默认线程调度器，它的作用就是通过Handler把网络请求的后台线程切回到主线程。完成从网络请求到完成线程切换的过程
所以为什么Retrofit要使用动态代理呢？动态代理的优势是不用暴露真实的委托者，根据不同的委托创建不同的代理，通过代理去做事情。另外，封装OkHttp使得Retrofit弥补了其缺点，如繁琐的请求参数的配置。利用@GET、@POST、@Path、@Body等注解以及一些参数很简便的就构造出了请求。当Retrofit创建了不同的接口，动态代理就发挥出了作用。每当不同接口方法执行时，动态代理都会拦截该请求，对接口中的注解，参数进行解析，构建出不同的Request，最后则交给OkHttp去真正执行。Retrofit结合动态代理，不用关心真正的接口方法，对符合规范的接口进行统一化的管理，以统一的方式解析注解和参数，拼接成request
说了这么多，Retrofit的核心工作流程就是
- 动态代理中调用loadServiceMethod方法，解析接口方法中的注解，参数，头部信息等
- 依据接口方法的返回类型，从适配器工厂集合里进行查询，生成相应的适配器CallAdapter，区分是RxJava的Observable、Single还是Call或者其他类型，（适配器工厂集合的数据是由构建Retrofit时addCallAdapterFactory()添加，如无自定义，则添加Android平台默认适配器）。以相同的方式取出数据转换器Converter
- 利用上面生成的CallAdapter，调用invoke方法，创建OkHttpCall对象，即针对请求信息，利用OkHttp进行异步或者同步网络请求，并且对响应结果进行实体类转换
- 创建好OkHttpCall后，又利用上面查询到的适配器CallAdapter调用adapt，返回RxJava的Observable、Single或者Call对象。最后将线程从后台切换为主线程
本文摘抄自《Android进阶之光——刘望舒》，为自己学习路程中的记录，不以盈利为目的。
欢迎指正。
