CtrlK
BlogDocsLog inGet started
Tessl Logo

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

Koin Core is a pragmatic lightweight dependency injection framework for Kotlin Multiplatform with iOS Simulator ARM64 target support.

—

Pending
Overview
Eval results
Files

application-setup.mddocs/

Application Setup & Configuration

This document covers how to set up and configure your Koin application using the KoinApplication class and related configuration utilities.

Overview

Koin applications are configured through the KoinApplication class, which serves as the main entry point for dependency injection setup. It manages module loading, configuration options, logging, and the overall application lifecycle.

Core Setup Functions

Creating Koin Applications

import org.koin.dsl.koinApplication

// Create and configure a Koin application
fun koinApplication(
    createEagerInstances: Boolean = true,
    appDeclaration: KoinAppDeclaration? = null
): KoinApplication

fun koinApplication(appDeclaration: KoinAppDeclaration?): KoinApplication
fun koinApplication(configuration: KoinConfiguration?): KoinApplication
fun koinApplication(createEagerInstances: Boolean): KoinApplication

// Type aliases
typealias KoinAppDeclaration = KoinApplication.() -> Unit

Basic Usage Examples

import org.koin.dsl.*

// Simple application setup
val app = koinApplication {
    modules(myModule)
}

// With custom configuration
val app = koinApplication(createEagerInstances = false) {
    allowOverride(true)
    printLogger()
    modules(listOf(module1, module2))
}

// Access the Koin context
val koin = app.koin

KoinApplication Class

The KoinApplication class provides all configuration capabilities for your dependency injection container.

class KoinApplication private constructor() {
    val koin: Koin
    
    companion object {
        fun init(): KoinApplication
    }
}

Module Management

Load your dependency modules into the application:

// Load single module
fun modules(modules: Module): KoinApplication

// Load multiple modules
fun modules(vararg modules: Module): KoinApplication
fun modules(modules: List<Module>): KoinApplication

Examples

import org.koin.dsl.*

val appModule = module { 
    single<Repository> { DatabaseRepository() } 
}
val networkModule = module { 
    single<ApiService> { RestApiService() } 
}

// Load single module
val app = koinApplication {
    modules(appModule)
}

// Load multiple modules
val app = koinApplication {
    modules(appModule, networkModule)
    // or
    modules(listOf(appModule, networkModule))
}

Configuration Options

Override Control

Control whether definitions can be overridden:

fun allowOverride(override: Boolean): Unit
val app = koinApplication {
    allowOverride(true) // Allow definition overrides
    modules(myModule)
}

Properties Management

Load application properties for dependency injection:

fun properties(values: Map<String, Any>): KoinApplication
val app = koinApplication {
    properties(mapOf(
        "db.url" to "jdbc:h2:mem:test",
        "api.timeout" to 5000,
        "debug.enabled" to true
    ))
    modules(myModule)
}

Feature Options

Configure Koin feature flags and options:

import org.koin.core.option.KoinOption

fun options(vararg optionValue: Pair<KoinOption, Any>): KoinApplication
import org.koin.core.option.KoinOption

val app = koinApplication {
    options(
        KoinOption.CheckModules to true,
        KoinOption.PrintLogger to Level.DEBUG
    )
    modules(myModule)
}

Logging Configuration

Custom Logger

Set up custom logging for Koin operations:

import org.koin.core.logger.Logger

fun logger(logger: Logger): KoinApplication
import org.koin.core.logger.Logger
import org.koin.core.logger.Level
import org.koin.core.logger.MESSAGE

class CustomLogger : Logger() {
    override fun display(level: Level, msg: MESSAGE) {
        println("[$level] $msg")
    }
}

val app = koinApplication {
    logger(CustomLogger())
    modules(myModule)
}

Print Logger

Use the built-in print logger:

import org.koin.core.logger.Level

fun printLogger(level: Level = Level.INFO): KoinApplication
import org.koin.core.logger.Level

val app = koinApplication {
    printLogger(Level.DEBUG) // Enable debug logging
    modules(myModule)
}

Lifecycle Management

Eager Instances

Create singleton instances marked for eager initialization:

fun createEagerInstances(): Unit
val eagerModule = module {
    single<DatabaseConnection>(createdAtStart = true) { 
        DatabaseConnection() 
    }
}

val app = koinApplication {
    modules(eagerModule)
    createEagerInstances() // Creates DatabaseConnection immediately
}

Application Cleanup

Close and cleanup resources:

fun close(): Unit
val app = koinApplication { modules(myModule) }

// Use the application...

// Clean up when done
app.close()

Configuration Composition

KoinConfiguration Class

For reusable configuration blocks:

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

fun koinConfiguration(declaration: KoinAppDeclaration): KoinConfiguration

Creating Reusable Configurations

import org.koin.dsl.*

// Define reusable configuration
val databaseConfig = koinConfiguration {
    properties(mapOf("db.url" to "jdbc:postgresql://localhost/mydb"))
    modules(databaseModule)
}

val loggingConfig = koinConfiguration {
    printLogger(Level.DEBUG)
}

// Apply configurations
val app = koinApplication {
    includes(databaseConfig, loggingConfig)
    modules(appModule)
}

Including Configurations

// Include KoinAppDeclaration configurations
fun KoinApplication.includes(vararg configurations: KoinAppDeclaration?): KoinApplication

// Include KoinConfiguration objects
fun KoinApplication.includes(vararg configurations: KoinConfiguration?): KoinApplication

Advanced Composition Example

// Environment-specific configurations
val developmentConfig = koinConfiguration {
    allowOverride(true)
    printLogger(Level.DEBUG)
    properties(mapOf("env" to "development"))
}

val productionConfig = koinConfiguration {
    allowOverride(false)
    printLogger(Level.ERROR)
    properties(mapOf("env" to "production"))
}

// Application setup based on environment
val isProduction = System.getProperty("env") == "production"
val app = koinApplication {
    includes(if (isProduction) productionConfig else developmentConfig)
    modules(coreModules)
}

Module Loading Behavior

When modules are loaded, Koin:

  1. Validates definitions - Checks for conflicts and circular dependencies
  2. Registers definitions - Adds them to the instance registry
  3. Sets up scopes - Configures any scope definitions
  4. Reports timing - Logs loading duration and definition count (if logging enabled)
  5. Handles overrides - Respects the allowOverride setting

Best Practices

1. Environment-Based Configuration

class AppConfiguration {
    companion object {
        fun create(environment: String): KoinConfiguration = when (environment) {
            "test" -> koinConfiguration {
                allowOverride(true)
                modules(testModules)
            }
            "production" -> koinConfiguration {
                allowOverride(false)
                printLogger(Level.ERROR)
                modules(productionModules)
            }
            else -> koinConfiguration {
                printLogger(Level.DEBUG)
                modules(developmentModules)
            }
        }
    }
}

2. Modular Configuration

// Organize by feature
val databaseConfig = koinConfiguration { 
    modules(databaseModule, migrationModule) 
}
val networkConfig = koinConfiguration { 
    modules(apiModule, httpModule) 
}
val uiConfig = koinConfiguration { 
    modules(viewModelModule, adapterModule) 
}

val app = koinApplication {
    includes(databaseConfig, networkConfig, uiConfig)
}

3. Property Management

// Load from external sources
val properties = loadPropertiesFromFile("application.properties")
val app = koinApplication {
    properties(properties)
    modules(appModule)
}

This setup system provides flexible, composable application configuration while maintaining clean separation of concerns across different application layers and environments.

Install with Tessl CLI

npx tessl i tessl/maven-io-insert-koin--koin-core-iossimulatorarm64

docs

application-setup.md

components.md

dependency-injection.md

error-handling.md

index.md

modules-and-definitions.md

qualifiers-parameters.md

scoping.md

tile.json