or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application-setup.mdcomponent-integration.mdconfiguration-logging.mdconstructor-reference.mdindex.mdjava-interop.mdmodule-definition.mdproperty-management.mdqualifiers-parameters.mdscope-management.md
tile.json

tessl/maven-io-insert-koin--koin-core-jvm

Core dependency injection framework for Kotlin multiplatform applications with DSL-based configuration and type-safe dependency resolution.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.insert-koin/koin-core@4.1.x

To install, run

npx @tessl/cli install tessl/maven-io-insert-koin--koin-core-jvm@4.1.0

index.mddocs/

Koin Core

Koin Core is a pragmatic lightweight dependency injection framework for Kotlin multiplatform applications. It provides a DSL-based approach to dependency injection with type-safe resolution, scoped instance management, and zero external dependencies. The framework supports JVM, Android, JavaScript, Native, and WebAssembly targets.

Package Information

  • Package Name: koin-core
  • Package Type: maven
  • Language: Kotlin
  • Group ID: io.insert-koin
  • Installation: implementation("io.insert-koin:koin-core:4.1.0")

Core Imports

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.core.module.Module
import org.koin.dsl.module
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
import org.koin.core.component.get

Basic Usage

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.dsl.module
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject

// Define a module with dependencies
val appModule = module {
    single<DatabaseService> { DatabaseServiceImpl() }
    factory<UserRepository> { UserRepositoryImpl(get()) }
    single<UserService> { UserServiceImpl(get()) }
}

// Start Koin with modules
startKoin {
    modules(appModule)
}

// Use dependencies in components
class UserController : KoinComponent {
    private val userService: UserService by inject()
    
    fun getUser(id: String) = userService.findById(id)
}

// Stop Koin when done
stopKoin()

Architecture

Koin Core is built around several key components:

  • Application Context: Global Koin context (startKoin, stopKoin) for application-wide dependency management
  • Module System: DSL-based module definition (module) for organizing and declaring dependencies
  • Definition Types: Multiple definition strategies (single, factory, scoped) for different lifecycle patterns
  • Component Integration: Interfaces (KoinComponent) and extension functions for seamless dependency injection
  • Scope Management: Hierarchical scoping system for controlling dependency lifecycles and isolation
  • Type Safety: Full Kotlin type safety with reified generics and compile-time dependency resolution

Capabilities

Application Setup & Configuration

Core application initialization and configuration functionality. Essential for setting up the dependency injection container and managing application lifecycle.

fun startKoin(appDeclaration: KoinAppDeclaration): KoinApplication
fun startKoin(koinApplication: KoinApplication): KoinApplication
fun startKoin(appConfiguration: KoinConfiguration): KoinApplication
fun stopKoin()

fun koinApplication(createEagerInstances: Boolean = true, appDeclaration: KoinAppDeclaration? = null): KoinApplication
fun koinApplication(appDeclaration: KoinAppDeclaration?): KoinApplication
fun koinApplication(configuration: KoinConfiguration?): KoinApplication

fun loadKoinModules(module: Module)
fun loadKoinModules(modules: List<Module>)
fun unloadKoinModules(module: Module)
fun unloadKoinModules(modules: List<Module>)

class KoinApplication {
    val koin: Koin
    fun modules(vararg modules: Module): KoinApplication
    fun modules(modules: List<Module>): KoinApplication
    fun properties(values: Map<String, Any>): KoinApplication
    fun logger(logger: Logger): KoinApplication
    fun printLogger(level: Level = Level.INFO): KoinApplication
    fun allowOverride(override: Boolean)
    fun createEagerInstances()
    fun options(vararg optionValue: Pair<KoinOption, Any>): KoinApplication
    fun close()
}

Application Setup

Module Definition & Dependencies

DSL-based module definition system for declaring and organizing dependencies. Supports multiple definition types including singletons, factories, and scoped instances.

fun module(createdAtStart: Boolean = false, moduleDeclaration: ModuleDeclaration): Module

class Module {
    inline fun <reified T> single(
        qualifier: Qualifier? = null,
        createdAtStart: Boolean = false,
        noinline definition: Definition<T>
    ): KoinDefinition<T>
    
    inline fun <reified T> factory(
        qualifier: Qualifier? = null,
        noinline definition: Definition<T>
    ): KoinDefinition<T>
    
    fun <T> scope(scopeSet: ScopeSet): ScopeDSL
}

interface Definition<T> : (Scope, ParametersHolder) -> T

Module Definition

Constructor Reference DSL

Reflection-free dependency injection using constructor references. Provides type-safe constructor resolution without runtime reflection overhead.

inline fun <reified R> Module.singleOf(
    crossinline constructor: () -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

inline fun <reified R> Module.factoryOf(
    crossinline constructor: () -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

inline fun <reified R> Scope.new(constructor: () -> R): R

Constructor Reference DSL

Component Integration & Injection

Component integration interfaces and extension functions for seamless dependency injection into classes and objects.

interface KoinComponent {
    fun getKoin(): Koin
}

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

inline fun <reified T> KoinComponent.inject(
    qualifier: Qualifier? = null,
    mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
    noinline parameters: ParametersDefinition? = null
): Lazy<T>

inline fun <reified T> KoinComponent.get(
    qualifier: Qualifier? = null,
    noinline parameters: ParametersDefinition? = null
): T

Component Integration

Scope Management

Hierarchical scope system for controlling dependency lifecycles and providing isolated dependency contexts for specific application areas.

class Scope(
    val scopeQualifier: Qualifier,
    val id: ScopeID,
    val isRoot: Boolean = false,
    val scopeArchetype: TypeQualifier? = null,
    private val _koin: Koin
) {
    val closed: Boolean
    
    inline fun <reified T> inject(
        qualifier: Qualifier? = null,
        mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
        noinline parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    inline fun <reified T> get(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T
    
    inline fun <reified T> getOrNull(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T?
    
    inline fun <reified T> getAll(): List<T>
    inline fun <reified T> getSource(): T?
    
    inline fun <reified T> declare(
        instance: T,
        qualifier: Qualifier? = null,
        secondaryTypes: List<KClass<*>> = emptyList(),
        allowOverride: Boolean = true,
        holdInstance: Boolean = false
    )
    
    fun linkTo(vararg scopes: Scope)
    fun unlink(vararg scopes: Scope)
    fun registerCallback(callback: ScopeCallback)
    fun close()
    fun getKoin(): Koin
}

typealias ScopeID = String

Scope Management

Qualifiers & Parameters

Type-safe qualifier system for distinguishing between multiple instances of the same type, and parameter injection for runtime dependency configuration.

interface Qualifier {
    val value: String
}

fun named(name: String): Qualifier
fun named(name: Enum<*>): Qualifier
inline fun <reified T> named(): Qualifier

class ParametersHolder(
    private val values: MutableList<Any?> = mutableListOf(),
    private val useIndexedValues: Boolean? = null
) {
    fun <T> get(index: Int): T
    fun <T> getOrNull(index: Int): T?
    fun size(): Int
    fun isEmpty(): Boolean
}

fun parametersOf(vararg values: Any?): ParametersHolder

Qualifiers & Parameters

Configuration & Logging

Application configuration system with structured logging support for debugging and monitoring dependency injection lifecycle.

class KoinConfiguration(val config: KoinApplication.() -> Unit) {
    operator fun invoke(): KoinApplication.() -> Unit
    val appDeclaration: KoinApplication.() -> Unit
}

fun koinConfiguration(declaration: KoinAppDeclaration): KoinConfiguration

abstract class Logger(var level: Level = Level.INFO) {
    abstract fun display(level: Level, msg: MESSAGE)
    fun debug(msg: MESSAGE)
    fun info(msg: MESSAGE)
    fun warn(msg: MESSAGE)
    fun error(msg: MESSAGE)
    fun log(lvl: Level, msg: String)
}

enum class Level {
    DEBUG, INFO, WARNING, ERROR, NONE
}

Configuration & Logging

Property Management

Property injection and management system for configuration values and runtime parameters with type-safe access patterns.

fun <T : Any> Koin.getProperty(key: String, defaultValue: T): T
fun <T : Any> Koin.getProperty(key: String): T?
fun Koin.setProperty(key: String, value: Any)
fun Koin.deleteProperty(key: String)

inline fun <reified T> KMutableProperty0<T>.inject()
inline fun <reified T> KMutableProperty0<T>.inject(koin: Koin)
inline fun <reified T> KMutableProperty0<T>.inject(scope: Scope)

Property Management

Java Interoperability

Java-specific API for dependency injection in mixed Kotlin/Java projects with static access patterns.

object KoinJavaComponent {
    @JvmStatic
    fun <T> inject(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    @JvmStatic
    fun <T> get(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): T
    
    @JvmStatic
    fun getKoin(): Koin
}

Java Interoperability

Types

Core Types

typealias KoinAppDeclaration = KoinApplication.() -> Unit
typealias ModuleDeclaration = Module.() -> Unit
typealias ParametersDefinition = () -> ParametersHolder
typealias DefinitionOptions<T> = BeanDefinition<T>.() -> Unit
typealias Definition<T> = Scope.(ParametersHolder) -> T
typealias QualifierValue = String
typealias ScopeID = String
typealias MESSAGE = String
typealias OnCloseCallback<T> = (T) -> Unit

data class StringQualifier(override val value: String) : Qualifier
data class TypeQualifier(val kClass: KClass<*>) : Qualifier

enum class KoinOption {
    VIEWMODEL_SCOPE_FACTORY
}

enum class Level {
    DEBUG, INFO, WARNING, ERROR, NONE
}

Core Interface Types

interface Qualifier {
    val value: QualifierValue
}

interface KoinComponent {
    fun getKoin(): Koin
}

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

abstract class Logger(var level: Level = Level.INFO) {
    abstract fun display(level: Level, msg: MESSAGE)
}

Exception Types

class NoDefinitionFoundException(msg: String) : Exception(msg)
class InstanceCreationException(msg: String) : Exception(msg)
class ClosedScopeException(msg: String) : Exception(msg)
class DefinitionOverrideException(msg: String) : Exception(msg)
class DefinitionParameterException(msg: String) : Exception(msg)
class KoinApplicationAlreadyStartedException(msg: String) : Exception(msg)
class MissingPropertyException(msg: String) : Exception(msg)
class MissingScopeValueException(msg: String) : Exception(msg)
class NoParameterFoundException(msg: String) : Exception(msg)
class NoPropertyFileFoundException(msg: String) : Exception(msg)
class NoScopeDefFoundException(msg: String) : Exception(msg)
class ScopeAlreadyCreatedException(msg: String) : Exception(msg)
class ScopeNotCreatedException(msg: String) : Exception(msg)