Koin框架

// Koin for Android
implementation 'org.koin:koin-android:2.1.5'
// or Koin for Lifecycle scoping
implementation 'org.koin:koin-androidx-scope:2.1.5'
// or Koin for Android Architecture ViewModel
implementation 'org.koin:koin-androidx-viewmodel:2.1.5'

// Given some classes
class Controller(val service : BusinessService)
class BusinessService()
// just declare it
val myModule = module {
  single { Controller(get()) }
  single { BusinessService() }
}

class MyApplication : Application() {
  override fun onCreate(){
    super.onCreate()
    // start Koin!
    startKoin {
      // Android context
      androidContext(this@MyApplication)
      // modules
      modules(myModule)
    }
  }
}

private val service: BusinessService by inject()

//dagger测试
private fun daggerTest(): LibraryResult {
    log("Running Dagger...")
    lateinit var kotlinComponent: KotlinDaggerComponent
    lateinit var javaComponent: JavaDaggerComponent
    return LibraryResult("Dagger", mapOf(
           Variant.KOTLIN to runTest(
                   setup = { kotlinComponent = DaggerKotlinDaggerComponent.create() },
                   test = { kotlinComponent.inject(kotlinDaggerTest) }
           ),
           Variant.JAVA to runTest(
                    setup = { javaComponent = DaggerJavaDaggerComponent.create() },
                    test = { javaComponent.inject(javaDaggerTest) }
            )
    ))
}


//koin测试
private fun koinTest(): LibraryResult {
    log("Running Koin...")
    return LibraryResult("Koin", mapOf(
            Variant.KOTLIN to runTest(
                    setup = {
                        startKoin {
                           modules(koinKotlinModule)
                        }
                    },
                    test = { get<Fib8>() },
                    teardown = { stopKoin() }
            ),
           Variant.JAVA to runTest(
                    setup = {
                        startKoin {
                            modules(koinJavaModule)
                        }
                    },
                    test = { get<FibonacciJava.Fib8>() },
                    teardown = { stopKoin() }
            )
    ))
}

startKoin {
    modules(syncModule)
}
Thread {
   loadKoinModules(module { asyncModule })
}.start()

/**
 * Declare a Single definition
 * @param qualifier
 * @param createdAtStart
 * @param override
 * @param definition - definition function
 */
inline fun <reified T> single(
        qualifier: Qualifier? = null,
        createdAtStart: Boolean = false,
        override: Boolean = false,
        noinline definition: Definition<T>
): BeanDefinition<T> {
    return Definitions.saveSingle(
            qualifier,
            definition,
            rootScope,
            makeOptions(override, createdAtStart)
    )
}

inline fun <reified T> saveSingle(
    qualifier: Qualifier? = null,
    noinline definition: Definition<T>,
    scopeDefinition: ScopeDefinition,
    options: Options
): BeanDefinition<T> {
    val beanDefinition = createSingle(qualifier, definition, scopeDefinition, options)
    scopeDefinition.save(beanDefinition)
    return beanDefinition
}


inline fun <reified T> createSingle(
    qualifier: Qualifier? = null,
    noinline definition: Definition<T>,
    scopeDefinition: ScopeDefinition,
    options: Options,
    secondaryTypes: List<KClass<*>> = emptyList()
): BeanDefinition<T> {
    return BeanDefinition(
        scopeDefinition,
        T::class,
        qualifier,
        definition,
        Kind.Single,
        options = options,
        secondaryTypes = secondaryTypes
    )
}

/**
 * inject lazily given dependency for Android koincomponent
 * @param qualifier - bean qualifier / optional
 * @param scope
 * @param parameters - injection parameters
 */
inline fun <reified T : Any> ComponentCallbacks.inject(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
) = lazy(LazyThreadSafetyMode.NONE) { get<T>(qualifier, parameters) }

/**
 * get given dependency for Android koincomponent
 * @param name - bean name
 * @param scope
 * @param parameters - injection parameters
 */
inline fun <reified T : Any> ComponentCallbacks.get(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
): T = getKoin().get(qualifier, parameters)

/**
 * Get a Koin instance
 * @param qualifier
 * @param scope
 * @param parameters
 */
@JvmOverloads
inline fun <reified T> get(
    qualifier: Qualifier? = null,
    noinline parameters: ParametersDefinition? = null
): T = _scopeRegistry.rootScope.get(qualifier, parameters)

/**
 * Get a Koin instance
 * @param qualifier
 * @param scope
 * @param parameters
 */
@JvmOverloads
inline fun <reified T> get(
    qualifier: Qualifier? = null,
    noinline parameters: ParametersDefinition? = null
): T {
    return get(T::class, qualifier, parameters)
}
/**
 * Get a Koin instance
 * @param clazz
 * @param qualifier
 * @param parameters
 * @return instance of type T
 */
fun <T> get(
    clazz: KClass<*>,
    qualifier: Qualifier? = null,
    parameters: ParametersDefinition? = null
): T {
    return if (_koin._logger.isAt(Level.DEBUG)) {
        val qualifierString = qualifier?.let { " with qualifier '$qualifier'" } ?: ""
        _koin._logger.debug("+- '${clazz.getFullName()}'$qualifierString")
        val (instance: T, duration: Double) = measureDurationForResult {
            resolveInstance<T>(qualifier, clazz, parameters)
        }
        _koin._logger.debug("|- '${clazz.getFullName()}' in $duration ms")
        return instance
    } else {
        resolveInstance(qualifier, clazz, parameters)
    }
}


@Suppress("UNCHECKED_CAST")
private fun <T> resolveInstance(
    qualifier: Qualifier?,
    clazz: KClass<*>,
    parameters: ParametersDefinition?
): T {
    if (_closed) {
        throw ClosedScopeException("Scope '$id' is closed")
    }
    //TODO Resolve in Root or link
    val indexKey = indexKey(clazz, qualifier)
    return _instanceRegistry.resolveInstance(indexKey, parameters)
        ?: findInOtherScope<T>(clazz, qualifier, parameters) ?: getFromSource(clazz)
        ?: throwDefinitionNotFound(qualifier, clazz)
}

@Suppress("UNCHECKED_CAST")
internal fun <T> resolveInstance(indexKey: IndexKey, parameters: ParametersDefinition?): T? {
    return _instances[indexKey]?.get(defaultInstanceContext(parameters)) as? T
}

private fun createInstanceFactory(
        _koin: Koin,
        definition: BeanDefinition<*>
): InstanceFactory<*> {
    return when (definition.kind) {
        Kind.Single -> SingleInstanceFactory(_koin, definition)
        Kind.Factory -> FactoryInstanceFactory(_koin, definition)
    }
}