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