Android进阶宝典—Koin使用和原理分析

一、理解设计模式

控制反转

是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

实现控制反转最常见的方式叫做依赖注入（Dependency Injection，简称DI），依赖注入(Dependency Injection)和控制反转(Inversion of Control)基本可以理解是同一个概念。

具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但使用依赖注入后，创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者实例的工作通常由DI框架（Koin/ARouter/Spring容器）来完成，然后注入调用者，因此也称为依赖注入。

依赖注入框架的优点

• 依赖注入库会自动释放不再使用的对象，减少资源的过度使用。
• 在指定范围内，可重用依赖项和创建的实例，提高代码的可重用性，减少了很多模板代码。
• 代码变得更具可读性。
• 易于构建对象。
• 编写低耦合代码，更容易测试。

如需Android进阶学习资料 请点击免费领取

二、DI框架对比

Dagger2

优点：Google加持，社区广泛，性能佳

缺点：难上手,编译慢，编译错误晦涩，kotlin、android支持不简洁（代码量大）

Koin

优点：易上手、易调试、编译快、代码少，jetpack/Kotiln支持棒

缺点：性能不及dagger2/Hilt，java兼容不足，社区小

三、Koin使用和进阶

框架介绍

是一款轻量级的依赖注入框架，无代理，无代码生成，无反射。相对于dagger 而言更加适合Kotlin语言。

1.基本使用

• 创建module

声明需要通过Koin创建的对象，以及创建对象的方式

包括factory、single、get、bind、quilifier关键字使用

val appModule =  module {
	factory { Girl() }//每次都会生成新的对象
	//single<Girl> { Girl() }//生成单一对象
	//single { Girl() }//生成单一对象
} 
val appModule1 =  module {
	factory { Name() }//每次都会生成新的对象
	factory { Girl(get<Name>()) }
        //获取之前声明的Name对象作为传入Girl构造的参数
	
	factory ( quilifier=named("GilrQuilifier0")) {
		Girl() 
	}//每次都会生成新的对象,带quilifier
	factory ( quilifier=named("GilrQuilifier1")) { params->
		Girl(param0 = param[0],param1 = param[1]) 
	}//每次都会生成新的对象,带quilifier，带参数
}


//bind使用,也就是绑定其他接口注入获取实例其实也是用这个单例
val xxModule = module {
	single { xx() } binds (arrayOf(//适用于一个实现类，有多个接口的情况
		interface1::class,
		interface2::class
	))
	single { xx() } bind (xx::class)
}

• 注册module

用于将创建的module和Koin关联起来

startKoin {
        //一般在Application的onCreate或者attachBaseContext中调用，用于设置一些Koin框架的通用属性
	//设置log级别
	AndroidLogger(Level.DEBUG)
	//注入context，方法module中get()获取Context
	androidContext(this@KoinApplication)
	//设置module
	modules(appModule,appModule1)
}
loadKoinModules(appModule)
//用于在各自的类中调用，可以选择在执行到某些类后再将内部的能力暴露，
//能力其实和startKoin中的modules（）是一样的

• 依赖注入

当某个角色需要另一个角色的协助时，使用注入方式替代new的方式获取另一个角色的实例，分为by inject和get方式获取，其中parametersOf用于携带参数。

//方法一、必须是val 如果已经给定了类型inject不用使用类型
val girl1 : Girl by inject()
//方法二、必须是val  变量没给定类型，需要在inject中使用泛型
val girl2 by inject<Girl>()
//方法三 var 和val都行，直接获取
var girl3 = get<Girl>()
//带quilifier、带参数
var girl4:Girl by inject(quilifier = named("GilrQuilifier0"))
var girl5:Girl by inject(quilifier = named("GilrQuilifier1")){
   
	parametersOf("param0","param1")//其中parametersOf用于携带参数
}
var girl6:Girl by inject(){
   
	parametersOf("param0")
}


//可以解决koin找不到类报空错误的问题，
//这样提供方可以按需注册，使用方有就用，没有就不用
val xx = Injector.injectFactory<XX>()
private val xx: XX? by lazy {
   
		Injector.injectFactory<XX>()
}


object Injector : KoinComponent {
   


	inline fun <reified T> injectFactory() = try {
   
		val instance: T by inject()
		instance
	} catch (e: Exception) {
   
		Log.e(TAG, "inject has error:${
     e.message}")
		null
	}
}

by inject具有懒加载能力，get则是直接获取,如源码：

inline fun <reified T : Any> KoinComponent.get(    
qualifier: Qualifier? = null,    
noinline parameters: ParametersDefinition? = null): T {
       
return if (this is KoinScopeComponent) {
           
scope.get(qualifier, parameters)    
} else getKoin().get(qualifier, parameters)}
inline fun <reified T : Any> KoinComponent.inject(    
qualifier: Qualifier