Jetpack第五篇：实战Retrofit+协程+LiveDat

这篇是一个简单的实战，用前面的学到的东西写一个简单的网络请求框架。
如果对LiveData，ViewMode等不太了解的可以看下：
Jetpack第二篇：Lifecycles - 简书 (jianshu.com)
Jetpack第三篇：LiveData - 简书 (jianshu.com)
Jetpack第四篇：ViewModel - 简书 (jianshu.com)

这篇文章就用Retrofit+协程+LiveData+ViewMode搭建一个网络请求组件。
这个是最简单的一个demo，可以在这个基础上适当的进行封装来。

1、主要内容

主要内容

• 导入依赖
• RetrofitManger：主要用于Retrofit初始化
• LiveData：数据分发
• ViewModel：数据获取（使用ViewModel协程的拓展函数）

2、导入依赖

注意：我这边使用的依赖都是当时最新，并不是现在最新。

    // kotlin （我这里用的是Kotlin语言）
    implementation 'androidx.core:core-ktx:1.3.2'
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    implementation 'androidx.appcompat:appcompat:1.2.0'

    // lifecycle
    implementation 'androidx.lifecycle:lifecycle-common-java8:2.3.0-alpha01'

    // liveData
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.3.0-alpha01'

    // ViewModel
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.0-alpha01'

    // 协程
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.4"

    // 网络请求
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.7.2'

3、网络请求相关

RetrofitManger 我们使用retrofit2.9.0的版本，retrofit2.6.0版本就可以使用suspend关键字能和携程比较好的组合使用。RetrofitManger中初始化了Retrofit、Okhttp等等一些配置，我这边的Api接口使用的是单例模式防止整个应用中产生大量的Retrofit对象，保证只有一个Api对象的产生。

我这里用的接口是：wanAndroid的公开Api接口。

object RetrofitManger {

    var mApi: AppApi? = null

    private const val CONNECTION_TIME_OUT = 10L
    private const val READ_TIME_OUT = 10L

    var API_URL = "https://www.wanandroid.com"

    fun getApiService(): AppApi {
        if (mApi == null) {
            synchronized(this) {
                if (mApi == null) {
                    val okHttpClient =
                        buildOkHttpClient()
                    mApi =
                        buildRetrofit(
                            API_URL,
                            okHttpClient
                        ).create(AppApi::class.java)
                }
            }
        }
        return mApi!!
    }

    private fun buildOkHttpClient(): OkHttpClient.Builder {
        val logging = HttpLoggingInterceptor()
        logging.level = HttpLoggingInterceptor.Level.BODY
        return OkHttpClient.Builder()
            .addInterceptor(logging)
            .connectTimeout(CONNECTION_TIME_OUT, TimeUnit.SECONDS)
            .readTimeout(READ_TIME_OUT, TimeUnit.SECONDS)
            .proxy(Proxy.NO_PROXY)
    }

    private fun buildRetrofit(baseUrl: String, builder: OkHttpClient.Builder): Retrofit {
        val client = builder.build()

        return Retrofit.Builder()
            .baseUrl(baseUrl)
            .addConverterFactory(GsonConverterFactory.create())
            .client(client).build()
    }
}

Response:

class Response<T>(
    val data: T?,
    val info: Int,
    val msg: String
)

Api:
可以看到使用suspend标记的方法，标记这个是一个携程使用的异步方法。

interface AppApi {

    // 和协程联用
    @GET("article/list/{page}/json")
    suspend fun getArticleList(@Path("page") page: Int): Response<ArticleListBean>
}

4、封装ViewModel

在ViewModel中封装了获取数据的方法，和LiveData。LiveData用于观察数据的变化，当获取到数据时，使用postValue将数据分发给Activity。
同时封装了异常处理的方法：

class CoroutinesViewModel : ViewModel() {

    val api by lazy { RetrofitManger.getApiService() }
    var articlesLiveData: MutableLiveData<MutableList<ArticleBean>> = MutableLiveData()

    var apiError:MutableLiveData<Throwable> = MutableLiveData()

    fun getArticles(page: Int) {

        val exception = CoroutineExceptionHandler { coroutineContext, throwable ->
            apiError.postValue(throwable)
            Log.i("CoroutinesViewModel",throwable.message!!)
        }

        viewModelScope.launch(exception) {
            val respose = api.getArticleList(page)
            if (respose.info == 0) {
                articlesLiveData.postValue(respose.data?.datas)
            } else {
                articlesLiveData.postValue(mutableListOf())
            }
        }
    }

}

4.1、viewModelScope.launch

这个是ViewModel的拓展方法，携程自己也提供了Launch方法，但是建议用ViewModel提供的方法，因为这个地方有个注释This scope will be canceled when ViewModel will be cleared这个意思是当ViewModel被销毁时，这个携程会自己取消。

/**
 * [CoroutineScope] tied to this [ViewModel].
 * This scope will be canceled when ViewModel will be cleared, i.e [ViewModel.onCleared] is called
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
 */
val ViewModel.viewModelScope: CoroutineScope
        get() {
            val scope: CoroutineScope? = this.getTag(JOB_KEY)
            if (scope != null) {
                return scope
            }
            return setTagIfAbsent(JOB_KEY,
                CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate))
        }

internal class CloseableCoroutineScope(context: CoroutineContext) : Closeable, CoroutineScope {
    override val coroutineContext: CoroutineContext = context

    override fun close() {
        coroutineContext.cancel()
    }
}

5、Activity数据展示

初始化ViewModel，接收livedata分发的数据。

class MainActivity : AppCompatActivity() {

    private val viewModel by lazy { ViewModelProvider(this).get(CoroutinesViewModel::class.java) }

    private var textShowData:TextView? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()
        startObserver()
    }

    private fun initView() {
        val btnGetData = findViewById<Button>(R.id.btnGetData)
        btnGetData.setOnClickListener {
            viewModel.getArticles(1)
        }
        textShowData = findViewById<TextView>(R.id.tvInfo)
    }

    private fun startObserver() {
        viewModel.articlesLiveData.observe(this, Observer {
            it.run {
                if (this.size > 0) {
                    val text = StringBuilder()
                    this.forEach {
                        text.append(it.title+"\n")
                    }
                    textShowData?.text = text
                }
            }
        })

        viewModel.apiError.observe(this, Observer {

        })
    }
}

运行结果：

image.png

6、最后总结

以上的封装思路如果对LiveData、ViewModel、携程、Retrofit有一定理解的同学，看起来确实觉得思路清晰，简单明了。所以如果想比较好的理解这套封装，需要先把LiveData、ViewModel、携程、Retrofit这几个组件先去有简单的了解。

源码：源码是有的的，好像简书一贴github链接就会不让发，就很头大。