Android协程的使用
网络请求
现在比较流行的网络框架,就是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而言,协程就是一个线程的框架,用于处理并发任务的。
协程和线程的优缺点?
优势:好用、简洁、去掉了回调使得逻辑清晰,而且自动切换线程。
缺点:相对的新,需要学习成本