Autowire DSL

Koin offers an autowire DSL that allows you to target a class constructor directly and automatically wire dependencies, avoiding the need to specify them within a lambda expression.

info

Naming Note: This feature was previously called "Constructor DSL" in earlier documentation. Both terms refer to the same capability.

For a given class ClassA with following dependencies:

class ClassA(val b : ClassB, val c : ClassC)
class ClassB()
class ClassC()

you can now declare those components, directly targeting the class constructor:

module {
    singleOf(::ClassA)
    singleOf(::ClassB)
    singleOf(::ClassC)
}

No need to specify dependencies in constructor anymore with get() function! 🎉

info

Be sure to use :: before your class name, to target your class constructor

note

Your constructor is filled automatically with all required dependencies. Avoid using any default value as Koin will try to find it in the current graph.

note

If you need to retrieve a "named" definition, you need to use the classic DSL with lambda and get() to specify the qualifier

Available Keywords

The following autowire keywords are available to build your definition from constructor:

• factoryOf - equivalent of factory { } - factory definition
• singleOf - equivalent of single { } - single definition
• scopedOf - equivalent of scoped { } - scoped definition

info

Be sure to not use any default value in your constructor, as Koin will try to fill every parameter with it.

DSL Options

Any autowire DSL definition can also open some options within a lambda:

module {
    singleOf(::ClassA) {
        // definition options
        named("my_qualifier")
        bind<InterfaceA>()
        createdAtStart()
    }
}

Usual options and DSL keywords are available in this lambda:

• named("a_qualifier") - give a String qualifier to the definition
• named<MyType>() - give a Type qualifier to the definition
• bind<MyInterface>() - add type to bind for given definition
• binds(listOf(...)) - add types list for given definition
• createdAtStart() - create single instance at Koin start

You can also use bind or binds operator, without any need of lambda:

module {
    singleOf(::ClassA) bind InterfaceA::class
}

Injected Parameters

With autowire DSL declarations, you can still use injected parameters. Koin will look in injected parameters and current dependencies to try to inject your constructor.

Like following:

class MyFactory(val id : String)

declared with autowire DSL:

module {
    factoryOf(::MyFactory)
}

can be injected like this:

val id = "a_factory_id"
val factory = koin.get<MyFactory> { parametersOf(id)}

Reflection Based DSL (Deprecated since 3.2)

caution

Koin Reflection DSL is now deprecated. Please use Koin Autowire DSL above