CtrlK
BlogDocsLog inGet started
Tessl Logo

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.

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

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
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.insert-koin/koin-core@4.1.x
Publish Source
CLI
Badge
tessl/maven-io-insert-koin--koin-core badge