kotlin出来很多年，并被google被赋予Android首选开发语言的地位，还是有必要研究一下的，基础语法不再复述了，只简单聊聊kotlin中的核心内容之一：协程 Coroutine。
相关概念和API可以直接进入官网查询， 不过不推荐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<GankMeiziResult>
}
class GankMeiziPresenter : BaseMvpPresenter<IGankMeiziView>() {
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 <T> void exeOnLife(final AppCompatActivity mActivity , Observable<RespBody<XueError, T>> observable, final Accept acceptFun){
if (mActivity == null || ActivityHelper.activityIsDead(mActivity) || observable == null) return;
observable.as(AutoDispose.<RespBody<XueError,T>>autoDisposable(AndroidLifecycleScopeProvider.from(mActivity, Lifecycle.Event.ON_DESTROY)))
.subscribe(new Consumer<RespBody<XueError, T>>() {
@Override
public void accept(RespBody<XueError, T> respBody) throws Exception {
if (acceptFun == null) return;
acceptFun.accept(respBody);
}
});
}
public interface Accept <E extends XueError,T extends Object> {
void accept(RespBody<E, T> 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 <T> 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<Body>(
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<GankMeiziResult>(
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 <fields>;
}
假如release打包后你的Retrofit 请求结果发生了npe，检查下你的bean是否添加了不混淆配置
其他
研究协程没多久，有错误或建议欢迎指出，共同交流
另外推荐云在千峰的博客 ，是我目前看过的最友好的coroutine系列文章
