Kotlin Coroutine在 Android 中的使用和封装

·  阅读 2978

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系列文章

分类:
Android
标签:
分类:
Android
标签: