阅读 235

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


本文未经授权,切勿转载

前言

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

前期分析

我大概分析了几点我们是需要去解决的:
一、在基于不进行反射下,如何保存好我们预先初始化的内容,或者我们要初始化的对象。
二、作用域的问题,我初始化的Module到底初始化哪个作用域的问题,还有一种全局都能用的Module
三、当我们的Module包含了存在生命周期的东西,如持有LifeOwnwerActivity,或者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大概已经知道如何使用了,那接下来就分析主要构成部分

限定符

其实这个限定符就是一个ConcurrentHashMapKEY的,控制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,我抽空会回复。

关注下面的标签,发现更多相似文章
评论