Android:手写轻量级的依赖注入组件

本文未经授权，切勿转载

前言

  从业Android开发快两年多了，接触到不同得框架，从最开始ButterKnife到后面Kotlin得Kotlin-android-extensions,再到了DataBinding和ViewBinding，其中印象最深刻不是这类，也不是像RxJava2这类，而是依赖注入组件诸如Dagger2,再到后来得Koin，以及最新的Hilt。那么不如我们自己尝试看看自己手动写能去到什么地步。

前期分析

我大概分析了几点我们是需要去解决的：
一、在基于不进行反射下，如何保存好我们预先初始化的内容，或者我们要初始化的对象。
二、作用域的问题，我初始化的Module到底初始化哪个作用域的问题，还有一种全局都能用的Module。

三、当我们的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，进行生命周期的监听，然后把对象从储存池内移走,如下：

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

依赖方法：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 {

    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 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()

    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，我抽空会回复。