本文未经授权，切勿转载
前言
从业Android开发快两年多了，接触到不同得框架，从最开始ButterKnife到后面Kotlin得Kotlin-android-extensions,再到了DataBinding和ViewBinding，其中印象最深刻不是这类，也不是像RxJava2这类，而是依赖注入组件诸如Dagger2,再到后来得Koin，以及最新的Hilt。那么不如我们自己尝试看看自己手动写能去到什么地步。
前期分析
我大概分析了几点我们是需要去解决的：</br>一、在基于不进行反射下，如何保存好我们预先初始化的内容，或者我们要初始化的对象。</br>二、作用域的问题，我初始化的Module到底初始化哪个作用域的问题，还有一种全局都能用的Module。</br>
三、当我们的Module包含了存在生命周期的东西，如持有LifeOwnwer的Activity,或者Fragment等等类似的类。
快速开始
该项目地址在这里Kinit，基于Kotlin进行开发的，以及reified,DSL语法
startInit {
enableLog()
single { RoomApi.getDao() }
single { RetroHttp.createApi(Main::class.java) }
}
如果看过我那篇文章
Android开发: 分享如何利用好Kotlin的特点（一）---- 提高开发效率
应该有印象开篇就讲到如何利用Lazy进行全局初始化，当时就是这个项目的雏形。如果我们要在注入到ViewModel内的对象呢,需要在Activity使用这个Module,由于我们前面分析的第三点，这里使用LifeModule，进行生命周期的监听，然后把对象从储存池内移走,如下：</br>
Activity.kt
private val viewModel : MainViewModel by viewModels { ViewModelProvider.AndroidViewModelFactory(application)}
val module = lifeModule {
factory(MainViewModel::class.java.name){ this@MainActivity }
}
startInit {
module(viewModel,module)
}
ViewModel.kt
我们只需要在Activity初始化module第一个参数传入特征对象，然后在需要注入的地方，再次把特征对象传入lifeOwnerOrNull方法中，所以我建议把这个特征类选择为注入所在那个类。
private val repository by lazy { MainRepository(lifeOwnerOrNull(this))}
MainRepository.kt
class MainRepository(owner: LifecycleOwner?) : BaseRepository(owner)
详细可以直接查看我项目的ReadMe,后续会补充中文的ReadMe</br>
依赖方法：App build.gradle
//Core
api("com.github.ShowMeThe.kinit:kinit_core:v0.03")
//Lifecycle-ktx
api("com.github.ShowMeThe.kinit:kinit_lifecycle:v0.03")
还有记得在项目目录的build.gradle添加
allprojects {
repositories {
........
maven {
setUrl("https://jitpack.io")
}
}
}
核心分析
通过QuickStart大概已经知道如何使用了，那接下来就分析主要构成部分
限定符
其实这个限定符就是一个ConcurrentHashMap的KEY的，控制KEY来控制特征对应存储不同的Module或者全局初始化对象
open class Qualifier<D> {
private var key : D? = null
private var typeName:String? = ""
fun setTypeName(typeName: String?){
this.typeName = typeName
}
fun getTypeName() = typeName
fun getKey() = key
fun setKeyName(key:D){
this.key = key
}
inline fun<reified T> Qualifier<*>.makeTypeName(){
setTypeName(T::class.java.name)
}
override fun hashCode(): Int {
return getKey().hashCode() + getTypeName().hashCode()
}
override fun equals(other: Any?): Boolean {
return if(other is Qualifier<*>){
other.key == this.key && other.typeName == this.typeName
}else{
false
}
}
override fun toString(): String {
return "Qualifier[Key:${key},TypeName:${typeName}]"
}
}
模块
模块里面存储的也包含一个ConcurrentHashMap，用于存储不同的初始化的内容，通过唯一的name，即ConcurrentHashMap里面的KEY
fun module(scope:Module.()->Unit):Module{
val moduleBean = Module()
scope.invoke(moduleBean)
return moduleBean
}
open class Module {
var qualifier : Qualifier<*>? = null
set(value) {
field = value
setParentKey(field)
}
private val entry = ConcurrentHashMap<String,Any?>()
fun getEntry() = entry
inline fun factory(name:String,single: ()-> Any){
addSingle(name,single())
}
fun addSingle(name: String,any: Any){
getEntry()[name] = any
}
fun get(name: String):Any?{
return getEntry()[name]
}
open fun setParentKey(qualifier: Qualifier<*>?){
}
fun getKeys() = entry.keys
}
有了上面这两个，限定和作用域的控制，剩下都是存储的问题，以及处理各种提取内容的方法，以及相应的拓展方法，方便取出数据。
总结
整体框架使用起来，建立在我某一个项目中，采用注解+反射的方法注入对象，这个改善了注入的速度。目前框架由于我一个人维护，白天要上班，只能晚上写写，能力和时间都有限，想法也是有限的，所以欢迎各位Pull Request或者有问题留言Issue，我抽空会回复。
