Koin使用

Koin是一个轻量级的依赖注入组件，相比dagger它更容易使用，学习。上手更容易。
现在已经升级到2.0版本，增加了更多特性。

集成

implementation 'org.koin:koin-android-viewmodel:2.0.1'
implementation 'org.koin:koin-android:2.0.1'
implementation 'org.koin:koin-android-scope:2.0.1'
implementation 'org.koin:koin-android-ext:2.0.1'

注册module:

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidLogger()
            androidContext(this@MainApplication)
            androidFileProperties()
            modules(tesModule)
        }
    }
}

androidLogger：用来打印日志
androidContext：向Koin中注入context
androidFileProperties：从assets中读取保存的数据
modules：注册声明的Module

ViewModel注入

在Architecture Componets中一般会用到ViewModel，Repository相关的类，一般都是直接在使用的地方初始化。使用了Koin之后就可以使用依赖注入了，不用再考虑在什么地方初始化，从什么地方传值过来。

datasource

interface RemoteDatasource {
 @POST("test")
 fun test(@Body map: Map<String, String>): Observable<Response> 
}

repository

class TestRepository(private val datasource: RemoteDatasource){
    fun test(): Observable<Response> = datasource.test()
}

viewModel

class TestViewModel(private val repository: TestRepository) : ViewModel() {
     fun test(){
         repository.test()
         ...
    }
}

声明module

val testModule = module{
    //datasource实例化，单例
    single { retrofit.create(RemoteDatasource::class.java) }
    //Repository初始化，单例
    single { TestRepository(get()) }
    viewModel{ TestViewModel(get()) }
}

viewmodel 注入

class MainActivity : AppCompatActivity() {
    //注入viewMode，注入完成之后就可以直接使用了
    private val viewModel: TestViewModel by viewMode()
}

fragment中获取Activity中声明的viewModel

class TestFragment : Fragment() {
    val viewModel: TestViewModel by sharedViewModel()
}

factory

可以在module中使用factory

val myModule = module {
    single { DataRepository() }
    factory<Presenter> { MyPresenter(get()) }
    single { HttpClient(getProperty("server_url")) }
}

factory就是获取的时候每次都生成一个新的实例

qualifiers

限定符，用来区别同一个类的不同实例

 single(named("dev")) { DataRepository() }
 single(named("test")) { DataRepository() }

bind

将指定的实例绑定到对应的class

  single { TestRepository(get()) } bind TestViewModel::class

注入时传递参数

声明：

single{ (view : View) -> Presenter(view) }

使用：

val presenter : Presenter by inject { parametersOf(view) }

flags

createAtStart

在start的时候就创建实例。一般都是需要注入的时候才创建的

val testModule = module(createAtStart = true){
....
}

override
覆盖另一个module中的实例

val myModuleA = module {
    single<Service> { ServiceImp() }
}

val myModuleB = module {
    single<Service>(override=true) { TestServiceImp() }
}

scope

Scope就是一个实例的作用范围，一旦该作用范围结束，该实例就是从容器中移除。

Koin有3种scope

single：单实例scope，该scope下的实例不会被移除
factory：每次都是创建新实例
scoped：自定义scope

自定义scope

module {
    scope(named("A Scope Name")){
        scoped { Presenter() }
    }
}

//创建scope
val scope = koin.createScope("myScope","A_SCOPE_NAME")
//获取实例
val presenter = scope.get<Presenter>()

scope中的依赖

class ComponentA
class ComponentB(val a : ComponentA)

module {
    scope(named("A_SCOPE_NAME")){
        scoped { ComponentA() }
        scoped { ComponentB(get()) }
    }
}

使用

val myScope = koin.createScope("myScope",named("A_SCOPE_NAME"))
val componentA = myScope.get<ComponentA>()
val componentB = myScope.get<ComponentB>()

关闭scope

val myScope = koin.createScope("myScope",named("A_SCOPE_NAME"))
myScope.close()

在android中的scope

Activity和Fragment默认添加了扩展, 可以直接使用

class DetailActivity : AppCompatActivity() {
    val presenter : Presenter by currentScop.inject()
}

FileProperties

FileProperties用来存储文本数据，就是一个普通的Properties文件，在Android中是放在assets下面。路径为/assets/koin.properties。 startKoin时候会把文件中的内容都load进去。
使用

val testModule = module{
   factory{ TestModel(getProperty("test")) }
}

Koin的实现

Koin的实现就比较简单了，没有使用注解和生成代码。通过容器, kotlln DSL和Kotlin扩展实现。
抽象来看，关键的只有三个要素：

module
scope
bean

module中有两个容器，分别存放了module下的scope和bean
scope里面有个BeanRegistry，BeanRegistry中容器内存放了该scope下的所有bean
注入的时候通过socpe找到里面对应的类型的bean
所有bean的注入都提供了lazy和直接获取模式

作用域的实现

scope close之后，scope下的bean都不能再注入了。每个bean都有一个OnCloseCallback和close方法
当scope close之后会通过callback通知下面的bean都close，即清空容器和把bean的引用设置为null