拥抱Koin - 轻量级依赖注入框架

短命女 2023-07-02 12:29 17阅读 0赞

## Koin是什么？ ##

Koin是一个轻量级的依赖注入框架，基于Kotlin的DSL进行DI的配置，全程无反射无代码生成。

## 与Dagger的比较 ##

Dagger是Andorid官方推荐使用的DI框架，功能十分强大，但学习曲线陡峭，使用成本也相对较高。Koin在某些方面相对于Dagger具有以下优势：

*  使用成本低，比如一个完整的MVVM架构的项目，使用dagger的话，需要对M/V/VM各层分别实现Module，SubComponent等文件，会增加很多项目文件，但是如果使用Koin的话，要简单得多
 *  编译速度快，Koin没有额外的代码生成，编译速度很快
 *  轻量，Dagger在编译后会生大量代码，增加安装包体积，Koin没有这种烦恼

## 基于DSL ##

Koin最重要的特点是借助Kotlin的语法优势，提供了多个DSL式的API帮助我们进行DI的配置。DSL本质上是一些尾lambda的高阶函数，同时配合kotlin的类型推到，让我们节省了很多模板代码的书写。例如 factory\{...\}，类似于Dagger的@Provide，提供依赖对象，每次使用到的时候都会生成新的实例。其定义如下：

typealias Definition<T> = Scope.(DefinitionParameters) -> T
        
    inline fun <reified T> factory(
                qualifier: Qualifier? = null,
                override: Boolean = false,
                noinline definition: Definition<T>
    ): BeanDefinition<T> {
            return Definitions.saveFactory(
                    qualifier, definition, rootScope, makeOptions(override))
    }

常用的DSL主要有：

*  `module { }`  - 类似于Dagger的@Module，里面提供所需的依赖
 *  `factory { }` \- 类似于Dagger的@Provide，提供依赖对象，每次使用到的时候都会生成新的实例
 *  `single { }` \- 与factory功能一样，factory提供多实例对象，single提供单例

## 快速上手 ##

我们尝试在一个MVVM项目应用Koin。首先添加Koin的依赖

implementation "org.koin:koin-android-viewmodel:$koin_version"
    
    // androidx工程使用
    implementation "org.koin:koin-androidx-viewmodel:$koin_version"

koine-android-viewmodle可以配合ViewModle使用Koin，Koin还有其他类型的依赖，我们选用它是为了要在MVVM中使用。

然后我们想Dagger一样定义我们所需要的Module，我们可以将Module在不同文件定义，但是项目比较简单是也可以定义在一起。

### ViewModel层 ###

我们为VIewModle层提供DI用的Module

val viewModelModule = module {
        viewModel { LoginViewModel(get()) } //get<AuthRepo>()
    }
    
    val repoModule = module {
        factory  <AuthRepo> { AuthRepo(get(), get()) } // AuthRepo(get<AuthApi>(), get<AuthDao>() 
    }

在module中通过viewmodel\{...\}声明ViewModel的factory，factory会为Activity或者Fragment提供ViewModel，被存入到其ViewModelStore中。各依赖的构造函数中所需的参数通过get()注入，通过类型推断省略了泛型。

### Model层 ###

接下来，实现Model层所需的DI用的Module

val remoteModule = module {
    
        single<Retrofit> {
            Retrofit.Builder()
                    .baseUrl(Constants.HOST_API)
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create())
                    .build()
        }
    
        single<AuthApi> { get<Retrofit>().create(AuthApi::class.java) }
    }
    
    
    val localModule = module {
    
        single<AppDatabase> { AppDatabase.getInstance(androidApplication()) }
    
        single<AuthDao> { get<AppDatabase>().authDao() }
    }

我们将remote请求所需的retrofit，api以及local所需的db、dao以single的形式provide

### View层 ###

我们为Activity注入所需要的ViewModel

class LoginActivity : AppCompatActivity() {
        private val mViewModel: LoginViewModel by viewModel()    
    }

通过 by viewModel()可以简单的从Koin中获取ViewModel，相对于ViewModelProviders.of()方式更加简单q

### 启动Koin ###

在APP启动时，我们将上述所有Module注入到全局容器，后续创建各对象时从容器中集中检索，将所需要的依赖注入到对象中，完成依赖注入

startKoin(this, listOf(repoModule, viewModelModule))

## 实现细节 ##

最后我们简单了解一下Koin的源码。依赖注入的基本思想非常简单：将各种依赖的单例或者factory注册到全局容器中，然后在需要使用创建这些依赖对象是，通过key（比如class类型）在全局容器中检索，并进行创建。

Koin通过ScopeDefinition定义不同Scope的全局容器

class ScopeDefinition (
        /*other params*/,
        private val _definitions: HashSet<BeanDefinition<*>> = hashSetOf()) {
        // ...
        val definitions: Set<BeanDefinition<*>>
            get() = _definitions
        // ...
    }

ScopeDefinition中有一个BeanDefinitions的Set，用来注册各个依赖对象的创建信息

data class BeanDefinition<out T>(
        primaryType: KClass<*>,
        val definition: Definition<T>
        //... other params
    )

BeanDefinition有两个关键构造参数，primaryType是依赖对象的类型，用来作为检索的key，definition实际我们在DSL中声明的factory。

inline fun <reified T : ViewModel> Module.viewModel(
            qualifier: Qualifier? = null,
            override: Boolean = false,
            noinline definition: Definition<T>
    ): BeanDefinition<T> {
        val beanDefinition = factory(qualifier, override, definition)
        beanDefinition.setIsViewModel()
        return beanDefinition
    }

从viewmodel\{...\}的实现可以看出，factory()创建了BeanDefinition，factory()内部会将创建的BeanDefinition注入到全局容器

//创建BeanDefinition
    inline fun <reified T> createFactory(
            qualifier: Qualifier? = null,
            noinline definition: Definition<T>,
            scopeDefinition: ScopeDefinition,
            options: Options,
            secondaryTypes: List<KClass<*>> = emptyList()
        ): BeanDefinition<T> {
            return BeanDefinition(
                scopeDefinition,
                T::class,
                qualifier,
                definition,
                Kind.Factory,
                options = options,
                secondaryTypes = secondaryTypes
            )
     }
    
    //注入全局容器
    inline fun <reified T> saveFactory(
            qualifier: Qualifier? = null,
            noinline definition: Definition<T>,
            scopeDefinition: ScopeDefinition,
            options: Options
        ): BeanDefinition<T> {
            val beanDefinition = createFactory(qualifier, definition, scopeDefinition, options)
            scopeDefinition.save(beanDefinition)
            return beanDefinition
        }

## 最后 ##

本文简单介绍了Koin的特点、使用方法以及实现原理。Koin上手简单，非常适合基于Kotlin开发的MVVM项目，想要了解更多使用细节，请移步官网 [https://github.com/InsertKoinIO/koin][https_github.com_InsertKoinIO_koin]。当然如果您的项目比较复杂，让然推荐使用Dagger，毕竟是官方指定产品，可以处理一些Koin不能胜任的复杂需求。

[https_github.com_InsertKoinIO_koin]: https://github.com/InsertKoinIO/koin