Dependency injection with koin

Proprietary & Confidential
Dependency
injection with Koin
2019.1.17
Sean Tsai
sean.tsai@honestbee.com

A pragmatic lightweight dependency injection framework for Kotlin
developers. Written in pure Kotlin using functional resolution only:
no proxy, no code generation, no reflection!
Koin is a DSL, a lightweight container and a pragmatic API.
What’s Koin?

Getting Started

// Add Jcenter to your repositories if needed
repositories {
jcenter ()
}
dependencies {
// Koin for Android
compile 'org.koin:koin-android:1.0.2'
// Koin for Java developers
// implementation "org.koin:koin-java:1.0.2"
// Koin for Unit tests
// testImplementation "org.koin:koin-test:1.0.2"
}
Grade Setup

interface HelloRepository {
fun giveHello(): String
}
class HelloRepositoryImpl () : HelloRepository {
override fun giveHello() = "Hello Koin"
}
Our components - Repository

class MySimplePresenter (val repo: HelloRepository) {
fun sayHello() = "${repo.giveHello()} from $this"
}
Our components - Presenter

val appModule = module {
// single instance of HelloRepository
single<HelloRepository> { HelloRepositoryImpl() }
// Simple Presenter Factory
factory { MySimplePresenter( get()) }
}
Writing the Koin module

class MyApplication : Application(){
override fun onCreate() {
super.onCreate()
// Start Koin
startKoin( this, listOf(appModule))
}
}
Start Koin

class MySimpleActivity : AppCompatActivity() {
// Lazy injected MySimplePresenter
val firstPresenter: MySimplePresenter by inject()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
//...
}
}
Injecting dependencies

More Details

● module - create a Koin Module
● factory - provide a factory bean definition
● single - provide a singleton bean definition (also aliased as bean)
● get - resolve a component dependency
● bind - add type to bind for given bean definition
The Koin DSL

val appModule = module {
// single instance of HelloRepository
single<HelloRepository> { HelloRepositoryImpl() }
// Simple Presenter Factory
factory { MySimplePresenter( get()) }
}
Let’s get back to previous example....

Experimental features - create<T>()
// Presenter <- Service
class Service()
class Controller(val view : View)
val myModule = module {
// declare Service as single instance
single { Service() }
// declare Controller as single instance, resolving View instance
with get()
single<Controller> { ControllerImpl(get()) }
}

Experimental features - create<T>()
// Presenter <- Service
class Service()
class Controller(val view : View)
// declare Service as single instance
single<Service>()
// declare Controller as single instance, resolving View instance
with get()
single<Controller> { create<ControllerImpl>() }
}

// Will match type ServiceImp only
single { ServiceImp() }
// Will match type Service only
single { ServiceImp() as Service }
}
Binding an interface
● A single or a factory definition use the type from the their given lambda definition: i.e single {
T } The matched type of the definition is the only matched type from this expression.

// Will match type ServiceImp only
single { ServiceImp() }
// Will match type Service only
single<Service> { ServiceImp() }
}
Binding an interface

// Will match types ServiceImp & Service
single { ServiceImp() } bind Service::class
}
Binding additional type

Declaring injection parameters
class Presenter(val view : View)
single{ (view : View) -> Presenter(view) }
}
val presenter : Presenter by inject { parametersOf(view) }

Module - Naming a definition
module {
single { ComponentA() }
module("A") {
single { ComponentB() }
}
}
ComponentA ->
ComponentB -> A.ComponentB

Module - Naming a definition
single<Service>("default") { ServiceImpl() }
single<Service>("test") { ServiceImpl() }
}
val service : Service by inject(name = "default")

Module - Visibility rules
● Visibility rule is quite simple: child modules can see their parents, but not the inverse.
A definition from a child module, can see definitions in parents modules. Modules can’t
share their definitions in divergent paths.

// definitions in /
val rootModule = module {
}
// definitions in /org
val orgModule = module("org") {
single { ComponentB(...) }
}
// definitions in /org/sample
val sampleModule = module("org.sample") {
single { ComponentC(...) }
}
// definitions in /org/demo
val demoModule = module("org.demo") {
single { ComponentD(...) }
}

// definitions in /
}
}
}
}
Can only see:
➢ /

// definitions in /
}
}
}
}
Can only see:
➢ /
➢ /org

// definitions in /
}
}
}
}
Can only see:
➢ /
➢ /org
➢ /org/sample

// definitions in /
}
}
}
}
Can only see:
➢ /
➢ /org
➢ /org/demo

If you do care about your modules
lifetime. Can check with Scope section.

Reference
• Koin Official Site
• Koin Official Doc

Q & A

Dependency injection with koin

More Related Content

What's hot

Similar to Dependency injection with koin

More from Sean Tsai

Recently uploaded

Dependency injection with koin