首先构建Retrofit,baseUrl配置域名，然后添加了一个CallApdaterFactory和一个ConverterFactory,
Retrofit.Builder builder =new Retrofit.Builder();
builder.baseUrl(ApiService.SERVER_URL)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient).builder.build()
而在把okHttpClient配置成Retrofit的Callfactory,这个okHttpClient是有okhttp框架配置来的，如下
OkHttpClient.Builder builder =new OkHttpClient.Builder();
builder.addNetworkInterceptor(cacheInterceptor)
.addInterceptor(cacheInterceptor)
.addInterceptor(new SaveCookieInterceptor())
.addInterceptor(new AddCookieInterceptor())
.cache(HttpCache.getCache())
.connectTimeout(60 *1000, TimeUnit.MILLISECONDS)
.readTimeout(60 *1000, TimeUnit.MILLISECONDS）
.build()
这样就构建出一个基本的Retrofit类，然后我们构建一个ApiService，再调用Retrofit.create(Apiservice.class)
public interface ApiService {
String SERVER_URL ="https://www.wanandroid.com";
@FormUrlEncoded
@POST("user/login")
Observable<BaseResponse> login(@Field("username") String username,@Field("password") String password);
}
构建一个ApiManager,当我们需要发送一个login请求时只需要调用ApiManager.login方法就行了，这么简单；
public class ApiManager {
private final ApiServiceapiService;
private final Applicationapplication;
public ApiManager(ApiService apiService, Application application) {
this.apiService = apiService;
this.application = application;
}
private void doAsyncRxRequest(Observable observable,LifecycleTransformer bind,SimpleCallback simpleCallback){
observable.flatMap(new BaseResponseFunc())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.compose(bind)
.subscribe(new ExceptionSubscriber(simpleCallback,application));
}
public void login(String username, String password, LifecycleTransformer bind, SimpleCallback simpleCallback){
doAsyncRxRequest(apiService.login(username,password),bind,simpleCallback);
}
}
What？这就完了，那个apiService哪里来的，哪里实现了？observable又是什么鬼？别急，下面一一道来，上面的ApiService是由Retrofit来实现的，记得上面我们构建Retrofit后最终调用了他的create(ApiService.class)方法吧，我们走进该方法，该方法主要返回一个动态代理，该代理为ApiService的一个实现
return (T) Proxy.newProxyInstance(service.getClassLoader(),new Class[] { service },
new InvocationHandler() {
private final Platformplatform = 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);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method,service, proxy, args);
}
ServiceMethod serviceMethod = (ServiceMethod) loadServiceMethod(method);
OkHttpCall okHttpCall =new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
}
);
我们重点放在最后三条代码，第一条中loadServiceMethod（method）方法，该方法做了5事，
第一，从Retrofit的RxJava2CallAdapterFactory中获取对应的CallAdapter（RxJava2CallAdapterFactory）
第二，从Retrofit的ConverterFactory中获取对应的Converter<ResponseBody, ?>
第三，解析对应请求方法的注解来获取请求接口的realUrl
第四，构建一个ParameterHandler[]包含对应请求方法的ParameterHandler，用于拼接请求参数
第五，从Retrofit中获取Callfactory，也就是OkhttpClient
第二条中new 一个OkhttpCall并把serviceMethod和请求参数args传进去,而这个OkhttpCall中有个enqueue（callback）方法，该方法主要5件事：
第一，调用ServiceMethod的ParameterHandler拼接请求参数得到Request
第二，获取ServiceMethod中的callfactory，调用其newCall（request）来获取Okhttp中的RealCall
第三，通过RealCall发起请求,获取响应Response
第四，调用serviceMethod的Converter<ResponseBody, ?>把response转成需要的实体，而这个实体就是 ApiService中的BaseResponse.
第五，调用参数中的callback来回调自己和BaseResponse。
第三条serviceMethod.callAdapter.adapt(okHttpCall)，该方法主要做了1件事，通过callAdapter（也就是RxJava2CallAdapterFactory中的RxJava2CallAdapter）把okHttpCall转成一个Observable并返回（该Observable也就是ApiService.login方法在Retrofit.create(ApService.class)中的代理方法的返参）；
这里就说异步请求，Observable为CallEnqueueObservable（okHttpcall），当这个Observable调用subscribe时（也就是ApiManager.login方法调用链的最后一个），会调用到subscribeActual方法，构建一个CallBack（用来给RxJava2中的observer来做回调处理），然后调用第二条中的okhttpcall.enqueue（callback）方法，最终通过callback的回调，让observer调用next(BaseResponse)来根据业务逻辑处理这个实体，至此一个完整的retrofit+okhttp+rxjava联动请求完成。
