Kotlin系列

Android协程的使用

2020-10-11  本文已影响0人  超人TIGA
网络请求

现在比较流行的网络框架,就是retrofit,而且retrofit从2.6版本开始,实现了对协程的支持,其实可以理解为retrofit对suspend关键字的支持。
以前如果是使用retrofit来实现网络请求,一般都有这么几个步骤:1、初始化retrofit 2、初始化Api代理接口 3、请求并在回调中处理结果

    private fun initRetrofit() {
        val okHttpClient = OkHttpClient.Builder().sslSocketFactory(
            TrustAllSSLSocketFactory.newInstance(),
            TrustAllSSLSocketFactory.TrustAllCertsManager()
        )
        retrofit = Retrofit.Builder()
            .baseUrl("https://api.github.com/")
            .client(okHttpClient.build())
            .addConverterFactory(GsonConverterFactory.create())
            .build()
        api = retrofit.create(GitHubApi::class.java)
    }
interface GitHubApi {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user")user:String):Call<List<Repo>>
}

    private fun requestByNormal() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            api.listRepos("TonyDash")
                .enqueue(object : Callback<List<Repo>> {
                    override fun onFailure(call: Call<List<Repo>>, t: Throwable) {
                        textView.text = "requestByNormal onFailure"
                    }

                    override fun onResponse(
                        call: Call<List<Repo>>,
                        response: Response<List<Repo>>
                    ) {
                        textView.text = response.body()?.get(0)?.name
                    }

                })
        }
    }

这样就完成了一次网络请求了。那如果使用协程的话,需要怎么实现呢?其实,在上面的基础上稍作修改,就可以变成协程,初始化retrofit部分不需要改动,先改api接口的定义:

interface GitHubApi {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user")user:String):Call<List<Repo>>
    @GET("users/{user}/repos")
    suspend fun listReposKt(@Path("user")user:String):List<Repo>
}

listRepoKt就是支持协程的api,可以看到,区别就只有方法的前面多了一个suspend关键字,suspend的作用就是标记这个为挂起函数。最后来看请求部分:

    private fun requestByKt() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            GlobalScope.launch(Dispatchers.Main) {
                val repos = api.listReposKt("TonyDash")
                textView.text ="KT${repos[0].name}"
            }
        }
    }

这样就利用协程完成了一次网络请求了。可以明显看到,在请求数据的部分,少了回调,只需要肉眼看上去的按顺序写,就完成了异线程执行网络请求并主线程更新UI控件的工作,单个请求可能感觉差异不大,但是如果有一个需求你必须请求多个接口,并且多个接口还是有因果关系的,那就会有一种回调地狱的感觉,而且后期维护起来也相对麻烦,万一忘了以前是为什么这么写的呢?还有如果细心的话可以发现,利用回调处理结果的请求方法,有一个onFailure来处理请求的异常情况,那协程呢?协程怎么处理异常,下面我们单独讲。

异常处理

使用try catch来捕捉异常,由于kotlin取消了check exception机制,所以要捕捉异常,我们只能使用try catch来捕捉协程内的异常。

    private fun requestByKt() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            GlobalScope.launch(Dispatchers.Main) {
                try {
                    val repos = api.listReposKt("TonyDash")
                    textView.text = "KT${repos[0].name}"
                } catch (e: Exception) {
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
RxJava与协程

网络请求,一般都会使用retrofit、rxjava、OKhttp等。首先不管用没用过,我们要明白这些东西是要来做什么的,其实retrofit和OKhttp基本一样,你可以理解为网络代理,就是你告诉它调用哪个接口,它返回你结果,至于过程,如果你没那个需要,不管也行。至于rxjava,可以理解为一个工具箱,主要用于多线程并发任务的管理,还有事件流。那先用rxjava实现网络请求怎么做?

interface GitHubApi {
    fun listReposRx(@Path("user")user:String): Single<List<Repo>>
}

返回值修改为Single,就完成了api的修改了。

    private fun initRetrofit() {
        val okHttpClient = OkHttpClient.Builder().sslSocketFactory(
            TrustAllSSLSocketFactory.newInstance(),
            TrustAllSSLSocketFactory.TrustAllCertsManager()
        )
        retrofit = Retrofit.Builder()
            .baseUrl("https://api.github.com/")
            .client(okHttpClient.build())
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io()))//使用rxjava是加上这一句
            .build()
        api = retrofit.create(GitHubApi::class.java)
    }

同时初始化retrofit是,需要加上addCallAdapterFactory,这里我默认为全部的网络请求,都在io线程执行。

    private fun requestByRx() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            api.listReposRx("TonyDash")
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(object : SingleObserver<List<Repo>> {
                    override fun onSuccess(t: List<Repo>) {
                        textView.text = "Rx${t[0].name}"
                    }

                    override fun onSubscribe(d: Disposable) {
                        textView.text = "onSubscribe"
                    }

                    override fun onError(e: Throwable) {
                        textView.text = e.message?:"onError"
                    }
                })
        }
    }

最后就是请求部分,大致上跟传统的回调方式类似,多的部分就是对于线程切换的指定,利用observeOn指定了结果再主线程执行,结果也同样是在回调方法中处理。这样一看感觉变化不大,但是如果有个需求,需要2个接口,把2个接口的结果显示出来呢?
如果不用rxjava,也能做,就是结果嵌套,在上一个接口的结果回调中,继续执行下一个接口的逻辑。这样的写法,看上去就相对的麻烦,而且不清晰。
如果使用协程,应该怎么写?

    private fun requestByKtAsync(){
        if (::retrofit.isInitialized && ::api.isInitialized) {
            GlobalScope.launch(Dispatchers.Main) {
                try {
                    val async1 = async { api.listReposKt("TonyDash") }
                    val async2 = async { api.listReposKt("TonyDash") }
                    textView.text = "${async1.await()[0].name} requestByKtAsync ${async2.await()[0].name}"
                }catch (e:Exception){
                    textView.text = e.message ?: "error"
                }
            }
        }
    }

这里可以看到,使用了async,这里的async其实也是一个协程,而await()就是把方法挂起了,等到2个请求都有结果了,再赋值给textview。
可以看到协程的优势是:简洁,去掉了回调;还有就是代码的写法上,相对的简单。
相同的地方就是:大家都可以切换线程;都不需要嵌套调用。

协程的缺点

我个人的观点,凡是越简单好用的,就等于别人帮你做了更多的事情,也就是说,性能损耗会大一些,例如suspend关键字,其实就是如何找回对应的线程进行处理逻辑,其实是一个复杂的过程,就会相对地有性能的损耗,但是这个损耗相比于协程带来的好处,我觉得可以忽略。
协程能必须使用try catch来捕捉异常,我个人觉得这里也算是一个小小的麻烦吧,不算缺点。

协程泄漏

还有一个常见的场景我们需要注意,我们的耗时操作都是维持一段时间的,那如果这段时间内,用户把activity关闭了,因为网络请求内部是一个活跃的线程,并且持有activity的对象,那这个就会造成内存泄漏。所以在不用的时候,我们应该把协程取消掉。

    private fun requestByKtAsync(){
        if (::retrofit.isInitialized && ::api.isInitialized) {
            jobKtAsync = GlobalScope.launch(Dispatchers.Main) {
                try {
                    val async1 = async { api.listReposKt("TonyDash") }
                    val async2 = async { api.listReposKt("TonyDash") }
                    textView.text = "${async1.await()[0].name} requestByKtAsync ${async2.await()[0].name}"
                }catch (e:Exception){
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        if (::jobKt.isInitialized){
            jobKt.cancel()
        }
        if (::jobKtAsync.isInitialized){
            jobKtAsync.cancel()
        }
    }
CoroutineScope

上面的代码,一直用到都是GlobalScope.launch,我也说过GlobalScope其实一般用于调试,实际上不这么写,而且这样不方便管理,我们可以创建一个全局统一管理的协程,在ondestroy的时候,统一取消协程。

class PracticeActivity2 : AppCompatActivity() {
    ...
    private val mainScope = MainScope()
    ...
}
    private fun requestByKtAsync(){
        if (::retrofit.isInitialized && ::api.isInitialized) {
            mainScope.launch(Dispatchers.Main) {
                try {
                    val async1 = async { api.listReposKt("TonyDash") }
                    val async2 = async { api.listReposKt("TonyDash") }
                    textView.text = "${async1.await()[0].name} requestByKtAsync ${async2.await()[0].name}"
                }catch (e:Exception){
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        mainScope.cancel()
    }

除此之外,我们甚至能使用jetpack来更加方便地使用,利用ktx的扩展属性。

    // Lifecycles only (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
    private fun requestByKt() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            lifecycleScope.launch(Dispatchers.Main) {
                try {
                    val repos = api.listReposKt("TonyDash")
                    textView.text = "KT${repos[0].name}"
                } catch (e: Exception) {
                    textView.text = e.message ?: "error"
                }
            }
        }
    }

这样使用lifecycleScope来启动协程,甚至连ondestroy中都不需要我们手动去取消协程,因为kotlin已经帮我们做了。另外ktx还有一些方便的api方法给我们使用,例如launchWhenCreated、launchWhenResumed、launchWhenStarted等。


image.png
总结:

协程和线程分别是什么?
对于kotlin for android而言,协程就是一个线程的框架,用于处理并发任务的。
协程和线程的优缺点?
优势:好用、简洁、去掉了回调使得逻辑清晰,而且自动切换线程。
缺点:相对的新,需要学习成本

例子demo:https://github.com/TonyDash/coroutines.git

上一篇下一篇

猜你喜欢

热点阅读