Koin Compiler - Sandbox
The goal of Koin compiler & Annotations project is to help declare Koin definition in a very fast and intuitive way, and generate all underlying Koin DSL.
Koin Annotation Processing
🚀
Koin code generation is mostly instant for Koin: just a few lines to generate. It is really easily readable/debuggable.
Even with ~~1000 of definitions, project compilation has almost no impact.
Here with such power from Ksp project, we can bring ease even more Kotlin dependency injection. We keep Koin API as it. We just avoid you to write definitions and modules.
Automatic definition binding
When tagging a component to be defined in Koin, we can easily declare all related supertypes directly:
@Single
class ElectricHeater : Heater
would generate definition:
single { ElectricHeater() } bind Heater::class
Using generated content
The only thing to setup in particular is the org.koin.ksp.generated.* import as follow, to be able to use genrated extensions:
import org.koin.ksp.generated.*
fun main() {
startKoin {
printLogger()
// ... generated features
}
// ...
}
Annotated definitions without modules
We need to use a default module with defaultModule() extension:
import org.koin.ksp.generated.*
fun main() {
startKoin {
printLogger()
// generated default module
defaultModule()
}
// ...
}
tag with @Single any components:
@Single
class CoffeeMaker(private val pump: Pump, private val heater: Heater)
@Single
class Thermosiphon(private val heater: Heater) : Pump
@Single
class ElectricHeater : Heater
What is generated:
package org.koin.ksp.generated
// imports ...
fun KoinApplication.defaultModule() = modules(defaultModule)
val defaultModule = module {
// definitions here ...
}
Class Module and functions as definitions
We want to use a CoffeeAppModule module class. The .module extension on CoffeeAppModule class will be generated:
import org.koin.ksp.generated.*
fun main() {
startKoin {
printLogger()
modules(
// generated .module extension on module class
CoffeeAppModule().module
)
}
// ...
}
Let's define a class module with annotations on functions:
@Module
class CoffeeAppModule {
@Single
fun heater() : Heater = ElectricHeater()
@Single
fun pump(heater: Heater) : Pump = Thermosiphon(heater)
@Single
fun coffeeMaker(heater: Heater, pump: Pump) = CoffeeMaker(pump, heater)
}
What is generated:
package org.koin.ksp.generated
// imports
val CoffeeAppModuleModule = module {
// generated module instance
val moduleInstance = org.koin.example.coffee.CoffeeAppModule()
// definitions using functions here ...
}
val org.koin.example.coffee.CoffeeAppModule.module : org.koin.core.module.Module get() = CoffeeAppModuleModule
Scan all definitions into a Class Module
Rather than defining each component, we can allow a module to scan definitions for current package and sub packages:
import org.koin.ksp.generated.*
fun main() {
startKoin {
printLogger()
modules(
// generated .module extension on moduel class
CoffeeAppModule().module
)
}
// ...
}
Let's define a class module, use @ComponentScan to scan definitions for a given module, @Single on components:
@Module
@ComponentScan
class CoffeeAppModule
What is generated:
package org.koin.ksp.generated
// imports
val CoffeeAppModuleModule = module {
val moduleInstance = org.koin.example.coffee.CoffeeAppModule()
// definitions here ...
}
val org.koin.example.coffee.CoffeeAppModule.module : org.koin.core.module.Module get() = CoffeeAppModuleModule
We can also specify what package to scan in @ComponentScan value. Below we scan annotated components in org.koin.example.test package:
@Module
@ComponentScan("org.koin.example.test")
class CoffeeAppModule
Unmatched definitions fallback in default module
In case of using @ComponentScan, if any definition is tagged but not associated to a declared module, this definition will fallback into the defaultModule
import org.koin.ksp.generated.*
fun main() {
startKoin {
printLogger()
modules(
// generated default module
defaultModule,
// generated .module extension on module class
CoffeeAppModule().module
)
}
// ...
}
Class Module, mixing declarations
As with previous case:
import org.koin.ksp.generated.*
fun main() {
startKoin {
printLogger()
modules(
// generated .module extension on moduel class
CoffeeAppModule().module
)
}
// ...
}
We can combine @ComponentScan & annotated functions definition:
@Module
@ComponentScan
class CoffeeAppModule {
@Single
fun coffeeMaker(heater: Heater, pump: Pump) = CoffeeMaker(pump, heater)
}
We keep @Single annotations on needed components:
@Single
class CoffeeMaker(private val pump: Pump, private val heater: Heater)
@Single
class Thermosiphon(private val heater: Heater) : Pump
class ElectricHeater : Heater
Generated content will add all definitions for module generation, like previous case.
Multiple Class Modules
Any class module tagged with @Module will be generated. Just import the module like follow:
@Module
@ComponentScan
class OtherModule
Just use it with the .module generated extension:
import org.koin.ksp.generated.*
startKoin {
printLogger()
modules(
CoffeeAppModule().module,
// new module here, with .module generated extension
OtherModule().module
)
}
TODO
🚧
Basic Definition Options: (In Progress)
-
Create at start
-
Qualifier (@Qualifier) => Type & Function
-
Generic for other keywords with factory (help for later Android)
-
Android Keywords
- @ViewModel
- @Fragment
- @Worker
Parameter Injection (@Param)
- Ctor
- Fun
Property (@Property)
- getProperty(key)
Scope Structure (@Scope)
- @Scope on a type
- @ScopedIn?
- @ScopedIn for factory definitions? (visibility problem)
2 Oct 9, 2022
3 Dec 21, 2022
18 Nov 24, 2022
10 Dec 2, 2022
116 Jan 3, 2023
57 Dec 29, 2022
139 Jan 2, 2023
20 Dec 27, 2022
50 Jan 7, 2023
1 Jun 27, 2022
3 Jan 10, 2022
3 May 16, 2021
111 Dec 27, 2022
34 Dec 30, 2022
2 Mar 12, 2022
1.4k Dec 28, 2022
7 Oct 14, 2022
468 Jan 4, 2023
9 Nov 28, 2022