（网络请求的封装，在本模块中主要是Retrofit和RxJava还有OkHttp的配合。
由于基础知识不够，有些原理并不是太懂，有部分主观的想法，望斧正。）

导读

一、准备
1）创建RetrofitProvider类
2）创建用于网络请求的接口和一个适配于网络请求返回数据的类
二、进行网络请求和返回的数据处理
1）网络请求
2）请求数据的处理
三、这种封装的优点

一、准备

1）准备RetrofitProvider

顾名思义，这是可以为我们提供一个retrofit对象的一个类
Q:为什么要弄这么一个类呢？
A:实现代码复用。
整个项目中的网络请求有一个最基本也最重要的共同点，他们的BASE_URL是一样的。利用这一点设计了这个类，专门为我们提供特定的retrofit。

这个类的代码大概可以分成两部分：构造器和单例。

构造器：

    private Retrofit mRetrofit;

    private RetrofitProvider() {
        
        ...//此处省略一些Interceptor的相关代码

        OkHttpClient.Builder clientbuilder = new OkHttpClient.Builder()
 //               .addInterceptor(loggingInterceptor)
 //               .addInterceptor(signInterceptor)
 //               .addNetworkInterceptor(new StethoInterceptor())
 //               .addInterceptor(new UaInterceptor())
                .retryOnConnectionFailure(true)
                .connectTimeout(30, TimeUnit.SECONDS);

        ...

        OkHttpClient client = clientbuilder.build();

        ...//此处省略代理配置的一些代码    
    
        Retrofit.Builder builder = new Retrofit.Builder()
                .baseUrl(baseurl)
                .client(client)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create());

        mRetrofit = builder.build();
    }

可以看到先用OkHttpBuilder.Builder创建了一个retryOnConnectedFailure为true（即网络请求失败了以后再重新请求）和connectTimeout为30seconds（连接默认超时为三十秒）的client。然后再将client传进retrofitBuilder里面去，最后调用builder.build()得到我们需要的retrofit。

省略部分：
HttpLoggingInterceptor：用于记录应用中的网络请求的信息。
SignInterceptor、UaInterceptor：处理host错误问题
还有一些关于代理的代码。

单例

   private static class SingletonHolder {
        private static final RetrofitProvider INSTANCE = new RetrofitProvider();
    }

    public static Retrofit getRetrofit() {
        return SingletonHolder.INSTANCE.mRetrofit;
    }

细心的小伙伴们可能已经发现了，上文中RetrofitProvider的构造器居然是private的！这就是单例模式的一个特点，因为单例类必须创建自己的唯一实例。当一个全局使用的类被频繁的创建和销毁的时候，单例是一种不错的设计模式：当我需要retrofit时，直接调用RetrofitProvider.getRetrofit()即可，而不是在每一次需要它的时候，创建一堆buider再build()。

2）Api接口&适配于请求返回数据的类

接口：

  interface GpaApi {
    @GET("gpa")
    fun get(): Single<Response<GpaBean>>

    @FormUrlEncoded
    @POST("gpa/evaluate")
    fun evaluate(@FieldMap params: Map<String, String>): Single<Response<String>>
}

Single:可以理解成一个没有onComplete的Observable...?

数据类

data class GpaBean(val stat: Stat, val data: List<Term>, val updated_at: String, val session: String)
....

与网络请求返回的值的名称和类型要匹配上

---

二、网络请求和数据处理

1）GPAProvider

我们只看其中的一段代码，里面主要有一个updateGpaLiveData的函数

private val api = RetrofitProvider.getRetrofit().create(GpaApi::class.java)
...

    fun updateGpaLiveData(useCache: Boolean = true, silent: Boolean = false) {
        async(UI) {
            val remote = bg {
                api.get().toBlocking().value()?.data
            }

            if (useCache) {
                bg {
                    Hawk.get<GpaBean?>(HAWK_KEY_GPA, null)
                }.await()?.let {
                    gpaLiveData.value = it
                    if (!silent) successLiveData.value = ConsumableMessage("从缓存中拿到了你的 GPA")
                }
            }

            remote.await()?.let {
                if (it.updated_at != gpaLiveData.value?.updated_at) {
                    gpaLiveData.value = it
                    if (!silent) successLiveData.value = ConsumableMessage("你的 GPA 有更新喔")
                    Hawk.put<GpaBean>(HAWK_KEY_GPA, it)
                } else {
                    if (!silent) successLiveData.value = ConsumableMessage("你的 GPA 已经是最新的了")
                }

                CommonPrefUtil.setGpaToken(it.session)
            }

        }.invokeOnCompletion {
            it?.let {
                errorLiveData.value = ConsumableMessage("好像出了什么问题，${it.message}")
            }
        }
    }

先用retrofit创建api

private val api = RetrofitProvider.getRetrofit().create(GpaApi::class.java)

再调用api的@GET方法

 api.get()

我们就可以得到网络请求的返回值了！不过呢
哪有这么简单。。。

往前翻一下你就会看见emmm我们get()函数的返回值是Single<Response<GpaBean>>，所以我们要给它去个壳，拿出我们需要的GpaBean.data

api.get().toBlocking().value()?.data

嗯，还没完
对于网络请求这种耗时的工作，我们不能让它在主线程进行，不然会引起阻塞然后app崩掉.....

这时候kotlin的协程（coroutines）就出马了

咳咳咳不是这个。在下面~

async(UI) {
            val remote = bg {
                api.get().toBlocking().value()?.data
            }
            ... 
            remote.await()?.let {
            ...//数据的处理
            }
            ...
            }

        }

async（UI）表示在UI线程中进行，remote = bg{}
个人理解是bg后面代码块里面（一些耗时操作）的东西在后台运行。
remote.await()是等操作结束后返回的值，这里呢就是我们想要的data。

但是！

但是！

但是！

还是没有完

有些时候网络请求出问题了怎么办？？？我们返回来的是空的值怎么办？？？

调用

          .invokeOnCompletion {
            it?.let {
                errorLiveData.value = ConsumableMessage("好像出了什么问题，${it.message}")
            }
        }

对崩了的网络请求进行一个处理，嘻嘻好像还不算太难~
这么一来，对于网络请求的发起和数据处理就差不多了

等等，差不多了？？？说好的RxJava呢？？？
于是我翻来翻去翻到了这样一个文件：LiveDataExtensions.kt。。。

fun <T, U> LiveData<T>.map(func: (T) -> U): LiveData<U> = Transformations.map(this, func)

fun <T, U> LiveData<T>.switchMap(func: (T) -> LiveData<U>): LiveData<U> = Transformations.switchMap(this, func)

fun <T> LiveData<T>.bind(lifecycleOwner: LifecycleOwner, block: (T?) -> Unit) = observe(lifecycleOwner, Observer(block))

fun <T> LiveData<ConsumableMessage<T>>.consume(lifecycleOwner: LifecycleOwner, from: Int = ConsumableMessage.ANY, block: (T?) -> Unit) =
        observe(lifecycleOwner, Observer {
            if (it?.consumed == false && (ConsumableMessage.ANY == from || it.from == from)) {
                block(it.message)
                it.consumed = true
            }
        })

data class ConsumableMessage<out T>(val message: T, val from: Int = ANY, var consumed: Boolean = false) {
    companion object {
        const val ANY = -1
    }
}

看了一下LiveData的源码注释，LiveData is a data holder class that can be observed within a given lifecycle。我的理解是：当我们给它一个状态为ACTIVE的LifeCycleOwner的时候，它就是一个Observable，而上面一系列的函数是LiveData的拓展函数。
//语法糖
扩展函数：在不修改原来类的条件下，使用函数和属性，表现的就像是属于这个类一样，很神奇。以第一个为例，这里对于LiveData进行函数拓展，设置LiveData的map函数为Transformation的map函数，实现流的映射关系。

又顺蔓摸瓜爬到了这里~

 GpaProvider.gpaLiveData
                .map(GpaBean::stat)
                .map(Stat::total)
                .bind(lifecycleOwner) {
                    it?.let {
                        scoreTv.text = it.score.toString()
                        gpaTv.text = it.gpa.toString()
                        creditTv.text = it.credit.toString()
                    }
                }

gpaLiveData是我们用前面处理后的List<GPABean>.data,对于data我们要做进一步的处理。因为我们只需要data.stat.total,可以用.map()函数将流中的内容一一映射，最后用.bind()函数绑定一个lifecycleOwner（相当于onsubscribe()？），然后it.let{}(设置onNext()?)来更新view的内容（这个我只是感觉像RxJava，和我初步了解的有些不同。典型的流式结构，没有切换线程是因为没有耗时的操作...由于订阅关系，当网络请求返回的数据改变，view的内容也会变。。。但是刚接触RxJava对这里了解的不够，这个是一个猜测（溜））

也算是用到了RxJava？ （ 我继续学习去了再见~）
更：emmmm在tjuLibrary里面找到了典型的RxJava

public void bindLibrary(Action1<Integer> action1, String libpasswd) {

        libApi.bindLib(libpasswd)
                .map(ApiResponse::getData)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(s -> action1.call(-1), new RxErrorHandler(mContext));

    }

在io线程中，libApi调用了bindlib方法后由网络请求返回一个ApiResponse类的对象，然后对它调用.map(ApiResponse::getData)方法映射成为apiResponse.data。此时已完成耗时的操作，调回主线程，实现subscribe订阅关系（onNext：传进来的action，onError：new RxErrorHandler）

---

三、这样封装的优点

1）Retrofit可以配置client来实现网络请求，且请求的方法和参数注解都可以定制。
2）由于RxJava是流式结构链式调用，思路很清晰。
3）Retrofit负责网络请求和请求数据的粗略处理，RxJava负责数据的精密处理和UI更新。Retrofit和async（UI）结合优雅的处理了异步处理网络请求的问题，RxJava的Observable和Subscriber之间的subscribe很好的满足了view——“我监测到了某一方面的（显示的数据）变化，我要更新自己” 的需求