HI, KTor now has built-in Dependency Injection. It...

# ktor

[lc]

HI, KTor now has built-in Dependency Injection. It's tied to the Application module. Is there an elegant way to get application dependencies inside classes without passing the application instance itself in the constructor?

[Bruce Hamilton]

There's a few ways for injection using constructors via reflection...

From the provider:

dependencies {
    provide(MyImplementation::class)
    provide(::MyImplementation)
}

From the resolver:

dependencies.create(MyImplemenation::class)

From configuration:

application:
    dependencies:
          - com.example.MyImplemenation

[lc]

thank you @Bruce Hamilton, but If the MyImplementation class is complex enough and also pulls in dependencies within itself?

[Bruce Hamilton]

yep, it'll just try each constructor in sequence and resolve each argument from the registry

[lc]

seems it is not so suitable as KoinComponent in Koin

[Bruce Hamilton]

could you provide an example of what you mean here? I'm not familiar with that part of the Koin API... I take it you're using the interop with Ktor DI?

[lc]

i mean i have to pass application instance or dependencies in every class constructor where i want to use it..

Application.kt

fun main(args: Array<String>) = EngineMain.main(args)

fun Application.cfg(key: String, default: String = "") = environment.config.propertyOrNull(key)?.getString() ?: default

fun Application.module(testing: Boolean = false) = runBlocking {
    val log = KotlinLogging.logger {}

    val buildNumber = System.getenv("BUILD_NUMBER") ?: TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()).toString()

    log.info { "rut-bot build $buildNumber starting..." }

    configureDependencies()

    startRutbot()
}

Dependencies.kt

fun Application.configureDependencies() {
    val app = this

    dependencies {
        provide<Boolean> { false } // Debug mode off by default

        provide("user") { app.cfg("rutbot.user") }

        provide<RutConnectService> { RutConnectService(app) }
        provide<LocalState> { LocalState(app) }
        provide<RutBot> { RutBot(app) }
    }
}

RutConnectService.kt

class RutConnectService(private val application: Application) {
    val log = KotlinLogging.logger("RutConnect")

    private val user = runBlocking { application.dependencies.resolve<String>("user") }

[lc]

using Koin it can be done with KoinComponent interface
Dependencies.kt

fun Application.configureDependencies() {

    val rutModule = module {
        single(named(Parameters.key)) { cfg("ktor.environment", "dev") }

        single(named(Parameters.debug)) { cfg("ktor.environment.debug", "false").toBoolean() }

        single<RutConnectService> { RutConnectService() }
        single<UserService> { UserService() }
        single<LocalState> { LocalState() }
        single<TradeService> { TradeService() }
    }

    install(Koin) {
        slf4jLogger()
        modules(rutModule)
    }
}

RutConnectService.kt

class RutConnectService: KoinComponent {
    val log = KotlinLogging.logger("RutConnect")

    private val localState: LocalState by inject()
    private val tradeService: TradeService by inject()
    private val userService: UserService by inject()

[Bruce Hamilton]

Oh, you can just write dependencies.provide(RutConnectService::class) for providing then expose the properties in the constructor. This decouples your class from Ktor and it's DI as well.

[lc]

thank you very much, and how to resolve named string binding in than case, i mean something like this:
provide<String>("user") { "tester.bill" }

[Bruce Hamilton]

When using the constructor reflection it'll need a @Named("user") annotation on the property. With the lambda config it's just a string arg on resolve like provide { MyService(resolve('user")) }