or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application.mdcomponents.mdindex.mdmodule-dsl.mdscopes.md
tile.json

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

Koin is a pragmatic lightweight dependency injection framework for Kotlin developers, providing core dependency injection functionality for Kotlin Multiplatform projects.

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@4.1.0

index.mddocs/

Koin Core

Koin is a pragmatic lightweight dependency injection framework for Kotlin developers. It provides a simple, pragmatic approach to dependency injection using a Kotlin DSL and works seamlessly across all Kotlin platforms including JVM, Android, JavaScript, and Native targets.

Package Information

  • Package Name: koin-core
  • Package Type: maven
  • Language: Kotlin
  • Maven Coordinates: io.insert-koin:koin-core:4.1.0
  • Installation: Add to your Kotlin project's dependencies

For Gradle:

implementation("io.insert-koin:koin-core:4.1.0")

For Maven:

<dependency>
  <groupId>io.insert-koin</groupId>
  <artifactId>koin-core</artifactId>
  <version>4.1.0</version>
</dependency>

Core Imports

import org.koin.core.KoinApplication
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
import org.koin.core.context.startKoin  // JVM/Android only
import org.koin.dsl.module

Basic Usage

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

// Define your services
interface Repository
class DatabaseRepository : Repository

interface Service
class BusinessService(private val repository: Repository) : Service

// Define a module
val appModule = module {
    single<Repository> { DatabaseRepository() }
    single<Service> { BusinessService(get()) }
}

// Start Koin
fun main() {
    startKoin {
        modules(appModule)
    }
}

// Use dependency injection in your components
class MyController : KoinComponent {
    private val service: Service by inject()
    
    fun doSomething() {
        // Use injected service
    }
}

Architecture

Koin is built around several key concepts:

  • Modules: Containers that group related dependency definitions
  • DSL: Kotlin DSL for declaring dependencies (single, factory, scoped)
  • Components: KoinComponent interface for classes that need dependency injection
  • Application: KoinApplication class for configuring and starting the DI container
  • Scopes: Lifecycle-aware dependency containers for managing object lifetimes
  • Qualifiers: Named or typed identifiers for distinguishing between multiple implementations

Capabilities

Module Definition and DSL

Core DSL for defining dependency injection modules with singleton, factory, and scoped lifecycles.

fun module(createdAtStart: Boolean = false, moduleDeclaration: Module.() -> Unit): Module

// Within a 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>

Module DSL and Definition

Component Integration

Provides KoinComponent interface and extension functions for easy dependency injection into Kotlin classes.

interface KoinComponent {
    fun getKoin(): Koin
}

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

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

Component Integration

Scoped Dependencies

Lifecycle-aware dependency management for controlling object creation and destruction within specific scopes.

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

class Scope {
    inline fun <reified T> get(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T
    
    fun close()
}

Scoped Dependencies

Application Configuration

KoinApplication class for configuring modules, properties, logging, and starting the dependency injection container.

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

class KoinApplication {
    fun modules(modules: List<Module>): KoinApplication
    fun properties(values: Map<String, Any>): KoinApplication
    fun logger(logger: Logger): KoinApplication
    fun createEagerInstances()
}

Application Configuration

Global Context (Platform Specific)

Global dependency injection context management for simplified usage patterns. Available on JVM/Android platforms.

interface KoinContext {
    fun get(): Koin
    fun getOrNull(): Koin?
    fun startKoin(koinApplication: KoinApplication): KoinApplication
    fun startKoin(appDeclaration: KoinAppDeclaration): KoinApplication
    fun stopKoin()
    fun loadKoinModules(module: Module, createEagerInstances: Boolean = false)
    fun unloadKoinModules(module: Module)
}

// Platform-specific global functions (JVM/Android)
fun startKoin(appDeclaration: KoinAppDeclaration): KoinApplication
fun stopKoin()

Note: Global context functions are platform-specific and may not be available on all Kotlin targets.

Type Definitions

typealias Definition<T> = Scope.(ParametersDefinition?) -> T
typealias ModuleDeclaration = Module.() -> Unit
typealias KoinAppDeclaration = KoinApplication.() -> Unit
typealias ParametersDefinition = () -> ParametersHolder
typealias ScopeID = String

interface Qualifier {
    val value: String
}

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

enum class Kind {
    Singleton, Factory, Scoped
}

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

// Utility functions
fun named(name: String): StringQualifier
fun parametersOf(vararg parameters: Any?): ParametersHolder

Error Types

class KoinApplicationAlreadyStartedException : RuntimeException
class ClosedScopeException : RuntimeException
class DefinitionOverrideException : RuntimeException
class InstanceCreationException(message: String, cause: Exception?) : RuntimeException
class NoDefinitionFoundException : RuntimeException
class ScopeNotCreatedException : RuntimeException
class ScopeAlreadyCreatedException : RuntimeException
class MissingPropertyException : RuntimeException
class NoParameterFoundException : RuntimeException
class NoPropertyFileFoundException : RuntimeException
class NoScopeDefFoundException : RuntimeException
class MissingScopeValueException : RuntimeException
class DefinitionParameterException : RuntimeException