KotlinCoroutine在Android中的使用和封装

　　kotlin出来很多年，并被google被赋予Android首选开发语言的地位，还是有必要研究一下的，基础语法不再复述了，只简单聊聊kotlin中的核心内容之一：协程 Coroutine。
　　相关概念和API可以直接进入[官网](https://kotlinlang.org/)查询，
　　不过不推荐kotlin中文网，文章翻译的略显生硬，看了更容易迷惑。
　　本文不讲基础（基础我也不怎么清楚…），适合喜欢拿来主义的同学
　　协程作为轻量级的线程，是建立在线程之上的调度，比线程节省资源但不意味着不消耗资源，在Android这种系统资源相对珍贵的环境中，当异步繁琐的调用或者切换线程，如何及时的回收也是必要的工作。
　　### 一、添加依赖配置
　　coroutine 是在kotlin 1.3中发布的1.0正式版，所以建议优先使用这个版本。
　　项目根目录中gradle配置：buildscript {      ext.kotlin_version = ＂1.3.0＂      repositories {          google()          mavenCentral()          jcenter()                }      dependencies {          classpath ＂com.android.tools.build:gradle:3.2.0＂          classpath ＂org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version＂      }  }
　　主module中gradle配置apply plugin: ＂kotlin-android＂  apply plugin: ＂kotlin-android-extensions＂  dependencies {      implementation ＂org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version＂      implementation ＂org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1＂      implementation ＂org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1＂  }  // 实验性开启协程的配置，目前版本中已经不需要了  kotlin{                   experimental{          coroutines ＂enable＂      }  }
　　假如你的其他module也使用kt代码，也需要添加上述依赖，不然有可能会出现找不到class或符号相关编译错误
　　二、替换RxJava和升级Retrofit
　　一般项目中会引用retrofit + RxJava的组合进行网络请求，或者你单独封装了一层RxJava来进行异步操作、切换线程来处理你的业务
　　RxJava虽然操作符众多（得有100个以上了吧），上手不易，但着实好用，一条链走下来搞定你的全部业务，如果有网络请求配合上retrofit这种支持Rx的库，不要太给力。
　　不过函数式开发有个通病，这条链子上会创建大量对象，回收内存抖动你不得不考虑，虽然使用了线程池，可开销不容小觑。
　　RxJava 虽然可以链式调用，但终究还是基于回调形式，而协程完全做到了同步方式写异步代码。
　　看下以前Retrofit的写法（简易）object RetrofitHelper: Interceptor {      init {          initOkHttpClient();      }      private var mOkHttpClient: OkHttpClient? = null      private val BASE_GANK_URL = ＂http://gank.io/api/＂      fun getRetroFitBuilder(url :String) : Retrofit {          return Retrofit.Builder()                  .baseUrl(url)                  .client(mOkHttpClient)                  .addCallAdapterFactory(RxJavaCallAdapterFactory.create())                  .addConverterFactory(GsonConverterFactory.create())                  .build()      }      fun getGankMeiziApi(): GankMeiziAPI {          return getRetroFitBuilder(BASE_GANK_URL).create(GankMeiziAPI::class.java)      }  interface GankMeiziAPI {      @GET(＂data/福利/{number}/{page}＂)      abstract fun getGankMeizi(@Path(＂number＂) number: Int, @Path(＂page＂) page: Int): Observable  }  class GankMeiziPresenter : BaseMvpPresenter() {      fun getGankList(context: RxAppCompatActivity, pageNum: Int , page :Int){          RetrofitHelper.getGankMeiziApi()                  .getGankMeizi(pageNum, page)                  .subscribeOn(Schedulers.io())                  .compose(context.bindUntilEvent(ActivityEvent.DESTROY))                  .filter({ gankMeiziResult -> !gankMeiziResult.error })                  .map({ gankMeiziResult -> gankMeiziResult.results })                  .observeOn(AndroidSchedulers.mainThread())                  .subscribe({ gankMeiziInfos ->                      mvpView?.showSuccess(gankMeiziInfos)                  }, { throwable ->                      mvpView?.showError()                  })      }  }
　　RxJava 的调用链上使用RxLife来绑定生命周期（或者使用Uber的autodispose），很常见的代码。
　　对于RxJava你还有可能会封装一个小工具（主要是为了生命周期和回收问题）public class RxImpl {      public static  void exeOnLife(final AppCompatActivity mActivity , Observable> observable, final Accept acceptFun){          if (mActivity == null || ActivityHelper.activityIsDead(mActivity) || observable == null) return;          observable.as(AutoDispose.>autoDisposable(AndroidLifecycleScopeProvider.from(mActivity, Lifecycle.Event.ON_DESTROY)))                  .subscribe(new Consumer>() {                      @Override                      public void accept(RespBody respBody) throws Exception {                          if (acceptFun == null) return;                          acceptFun.accept(respBody);                      }                  });      }      public interface Accept  {          void accept(RespBody respBody);      }  }
　　现在呢，想用协程怎么办，假设你现在已经知道了如何启动一个协程GlobalScope.launch { }            GlobalScope.async {}
　　也知道了launch 和 async的区别（返回值不同），也知道了需要一个返回值和多个返回值的选择（async 和 reduce），那在Android中如何使用呢
　　三、封装
　　协程Job具有层级关系，父协程控制子协程的运行，取消父协程的运行，也就相当于关闭了所有你开在父协程里的全部任务，所以在基类中你需要声明一个全局的协程上下文，保证你开启的协程都处于这个context环境中，在onDestroy下取消全局context，就达到了你的目的abstract class AbstractFragment : RxFragment() , CoroutineScope by MainScope() {      override fun onDestroy() {          super.onDestroy()          cancel()      }  }
　　你可以像封装RxJava一样，封装一个工具来使用协程，同时遵循一些原则：
　　#### 1 调度器
　　你开启的协程需要有调度器，就像RxJava自由切换线程一样，但主线程调度器最好指定Main来避免不必要的麻烦。
　　举个例子，你使用RxJava+autodipose来绑定 生命周期，但你在子线程用RxJava又开启了一个新线程，调度回UI线程刷新view的时候会发生崩溃
　　#### 2 父协程和子协程有强烈的层级关系
　　cancel一个Job 会抛出 CancellationException ，但这个异常不需要开发人员管理，但如果协程内部发生了非 CancellationException ，则会使用这个异常来取消父Coroutine。为了保证稳定的Coroutine层级关系，这种行为不能被修改。 然后当所有的子Coroutine都终止后，父Coroutine会收到原来抛出的异常信息。
　　下边是个协程的简易封装案例fun  executeRequest(context : CoroutineContext, request: suspend () -> T?, onSuccess: (T) -> Unit = {}, onFail: (Throwable) -> Unit = {}): Job {      return CoroutineScope(Dispatchers.Main).launch(context) {          try {              val res: T? = withContext(Dispatchers.IO) { request() }              res?.let {                  onSuccess(it)              }          } catch (e: Exception) {              e.printStackTrace()              onFail(e)          }      }  }
　　context 视业务情况而定是否传入
　　然后在你的act或Fragment中直接调用class MyFragment : BaseFragment {            onAcitvityCreate(){          executeRequest(              context,                  request = {                      // 异步任务                  },                  onSuccess = {                                       },                  onFail = {                                        }          )      }  }
　　对于Retrofit修改更为简单，2.6版本已经支持了协程,网上有很多介绍interface GankMeiziAPI {      @GET(＂data/福利/{number}/{page}＂)      suspend fun getGankMeizi(@Path(＂number＂) number: Int, @Path(＂page＂) page: Int): GankMeiziResult  }
　　将Observable返回值修改为你需要的bean， 加上suspend标记即可,
　　下边是示例代码：return executeRequest(                 context,                  request = {                      RetrofitHelper.getGankMeiziApi().getGankMeizi(pageNum, page)                  },                  onSuccess = {                      mvpView?.showSuccess(it.results)                  },                  onFail = {                      mvpView?.showError()                  }          )
　　### 四、混淆
　　网上的帖子大多以demo的思路来写，商用肯定要混淆了，不添加proguard你混淆后就死翘翘了，所以直接贴上来
　　coroutine的配置-keepnames class kotlinx.coroutines.internal.MainDispatcherFactory {}  -keepnames class kotlinx.coroutines.CoroutineExceptionHandler {}  -keepnames class kotlinx.coroutines.android.AndroidExceptionPreHandler {}  -keepnames class kotlinx.coroutines.android.AndroidDispatcherFactory {}  -keepclassmembernames class kotlinx.** {      volatile ;  }
　　假如release打包后你的Retrofit 请求结果发生了npe，检查下你的bean是否添加了不混淆配置
　　### 其他
　　研究协程没多久，有错误或建议欢迎指出，共同交流
　　另外推荐云在千峰的[博客](http://blog.chengyunfeng.com/?p=1088) ，是我目前看过的最友好的coroutine系列文章