Compile-time dependency injection library enabling seamless construction of type instances through annotations like `@Component`, `@Provides`, and `@Inject`. Supports component arguments, type alias differentiation, function injection, scopes, component inheritance, multi-bindings, assisted injection, lazy initialization, and default arguments.
A compile-time dependency injection library for kotlin.
@Component
abstract class AppComponent {
abstract val repo: Repository
@Provides
protected fun jsonParser(): JsonParser = JsonParser()
protected val RealHttp.bind: Http
@Provides get() = this
}
interface Http
@Inject
class RealHttp : Http
@Inject
class Api(private val http: Http, private val jsonParser: JsonParser)
@Inject
class Repository(private val api: Api)
val appComponent = AppComponent::class.create()
val repo = appComponent.repo
Using ksp
settings.gradle
pluginManagement {
repositories {
gradlePluginPortal()
mavenCentral()
}
}
build.gradle
plugins {
id("org.jetbrains.kotlin.jvm") version "2.2.20"
id("com.google.devtools.ksp") version "2.3.4"
}
repositories {
mavenCentral()
google()
}
dependencies {
ksp("me.tatarka.inject:kotlin-inject-compiler-ksp:0.9.0")
implementation("me.tatarka.inject:kotlin-inject-runtime:0.9.0")
}
Let's go through the above example line-by line and see what it's doing.
@Component
abstract class AppComponent {
The building block of kotlin-inject is a component which you declare with an @Component annotation on an abstract
class. An implementation of this component will be generated for you.
abstract val repo: Repository
In your component you can declare abstract read-only properties or functions to return an instance of a given type. This is where the magic happens. kotlin-inject will figure out how to construct that type for you in it's generated implementation. How does it know how to do this? There's a few ways:
@Provides
protected fun jsonParser(): JsonParser = JsonParser()
For external dependencies, you can declare a function or read-only property in the component to create an instance for a certain type. kotlin-inject will use the return type to provide this instance where it is requested.
Note: It is good practice to always explicitly declare the return type, that way it's clear what type is being provided. It may not always be what you expect!
protected val RealHttp.bind: Http
@Provides get() = this
You can declare arguments to a providing function/property to help you construct your instance. Here we are taking in an
instance of RealHttp and providing it for the interface Http. You can see a little sugar with this as the receiver
type for an extension function/property counts as an argument. Another way to write this would be:
@Provides
fun http(http: RealHttp): Http = http
@Inject
class RealHttp : Http
@Inject
class Api(private val http: Http, private val jsonParser: JsonParser)
@Inject
class Repository(private val api: Api)
For your own dependencies you can simply annotate the class with @Inject. This will use the primary constructor to
create an instance, no other configuration required!
val appComponent = AppComponent::class.create()
val repo = appComponent.repo
Finally, you can create an instance of your component with the generated .create() extension function.
If you need to pass any instances into your component you can declare them as constructor args. You can then pass them
into the generated create function. You can optionally annotate it with @Provides to provide the value to the
dependency graph.
@Component
abstract class MyComponent(@get:Provides protected val foo: Foo)
MyComponent::class.create(Foo())
If the argument is another component, you can annotate it with @Component and it's dependencies will also be available
to the child component. This allows you to compose them into a graph.
@Component
abstract class ParentComponent {
@Provides
fun provideFoo(): Foo = ...
}
@Component
abstract class ChildComponent(@Component val parent: ParentComponent) {
abstract val foo: Foo
}
val parent = ParentComponent::class.create()
val child = ChildComponent::class.create(parent)
If you have multiple instances of the same type you want to differentiate, you can use a @Qualifier. They will be
treated as separate types for the purposes of injection. They can be placed either on the variable or the type.
Alternatively different typealises will be treated as different types. (Note: this is going away in a future release, so
consider using a @Qualifier annotation instead. There will be a migration path.)
typealias Dep1 = Dep
Dep2 = Dep
{
: Dep1 = Dep()
: Dep2 = Dep()
: Thing = Thing(dep1, dep2)
}
(dep1: Dep1, dep2: Dep2)
You can also use type aliases to inject into top-level functions. Annotate your function with @Inject and create a
type alias with the same name.
typealias myFunction = () -> Unit
@Inject
fun myFunction(dep: Dep) {
}
You can then use the type alias anywhere and you will be provided with a function that calls the top-level one with the requested dependencies.
@Inject
class MyClass(val myFunction: myFunction)
@Component
abstract class MyComponent {
abstract val myFunction: myFunction
}
You can optionally pass explicit args as the last arguments of the function.
typealias myFunction = (String) -> String
@Inject
fun myFunction(dep: Dep, arg: String): String = ...
By default kotlin-inject will create a new instance of a dependency each place it's injected. If you want to re-use an instance you can scope it to a component. The instance will live as long as that component does.
First create your scope annotation.
@Scope
@Target(CLASS, FUNCTION, PROPERTY_GETTER)
annotation class MyScope
Then annotate your component with that scope annotation.
@MyScope
@Component
abstract class MyComponent()
Finally, annotate your provides and @Inject classes with that scope.
@MyScope
@Component
abstract class MyComponent {
@MyScope
@Provides
protected fun provideFoo(): Foo = ...
}
@MyScope
@Inject
class Bar()
You can define @Provides and scope annotations on an interface or abstract class that's not annotated
with @Component. This allows you to have multiple implementations, which is useful for things like testing. For
example, you can have an abstract class like
@NetworkScope
abstract class NetworkComponent {
@NetworkScope
@Provides
abstract fun api(): Api
}
Then you can have multiple implementations
@Component
abstract class RealNetworkComponent : NetworkComponent() {
override fun api(): Api = RealApi()
}
@Component
abstract class TestNetworkComponent : NetworkComponent() {
: Api = FakeApi()
}
Then you can provide the abstract class to your app component
@Component abstract class AppComponent(@Component val network: NetworkComponent)
Then in your app you can do
AppComponent::class.create(RealNetworkComponent::class.create())
and in tests you can do
AppComponent::class.create(TestNetworkComponent::class.create())
You can collect multiple bindings into a Map or Set by using the @IntoMap and @IntoSet annotations respectively.
For a set, return the type you want to put into a set, then you can inject or provide a Set<MyType>.
@Component
abstract class MyComponent {
abstract val allFoos: Set<Foo>
@IntoSet
@Provides
protected fun provideFoo1: Foo = Foo()
: Foo = Foo()
}
For a map, return a Pair<Key, Value>.
@Component
abstract class MyComponent {
abstract val fooMap: Map<String, Foo>
@IntoMap
: Pair<String, Foo> = to Foo()
: Pair<String, Foo> = to Foo()
}
Sometimes you want to delay the creation of a dependency or provide additional params manually. You can do this by injecting a function that returns the dependency instead of the dependency directly.
The simplest case is you take no args, this gives you a function that can create the dep.
@Inject
class Foo
@Inject
class MyClass(fooCreator: () -> Foo) {
init {
val foo = fooCreator()
}
}
If you define args, you can use these to assist the creation of the dependency. To do so, mark these args with the
@Assisted annotation. The function should take the same number of assisted args in the same order.
@Inject
class Foo(bar: Bar, @Assisted arg1: String, @Assisted arg2: String)
@Inject
class MyClass(fooCreator: (arg1: String, arg2: String) -> Foo) {
init {
val foo = fooCreator("1", "2")
}
}
Similarly, you can inject a Lazy<MyType> to construct and re-use an instance lazily.
@Inject
class Foo
@Inject
class MyClass(lazyFoo: Lazy<Foo>) {
val foo by lazyFoo
}
You can use default arguments for parameters you inject. If the type is present in the graph, it'll be injected, otherwise the default will be used.
( dep: Dep = Dep())
{
myClass: MyClass
: Dep = Dep()
}
{
myClass: MyClass
}
ComponentWithDep::.create().myClass.dep
ComponentWithoutDep::.create().myClass.dep
You can pass options to the processor which enables certain functionality. You do this in the main build.gradle.kts file of your project. For example:
ksp {
arg("me.tatarka.inject.dumpGraph", "true")
}
The following options exist:
You can find additional docs on specific use-cases in the docs folder.
You can find various samples here
annotation class Named(val value: String)
abstract class MyComponent {
fun dep1(): Dep = Dep("one")
fun dep2(): Dep = Dep("two")
fun provides( dep1: Dep, dep2: Dep): Thing = Thing(dep1, dep2)
}
class InjectedClass( dep1: Dep, dep2: Dep)
me.tatarka.inject.enableJavaxAnnotations=true
@javax.inject.* annotations can be used in in addition to the provided annotations. This can be useful if you are
migrating existing code or want to be abstracted from the injection lib you are using on the jvm.
me.tatarka.inject.generateCompanionExtensions=true
This will generate the create() methods on the companion object instead of the component's class. This allows you to
do
MyComponent.create() instead of MyComponent::class.create(). However, due to a kotlin limitation you will have to
explicitly specify a companion object for your component.
@Component abstract class MyComponent {
companion object
}
me.tatarka.inject.dumpGraph=true
This will print out the dependency graph when building. This can be useful to help debug issues.
Surfaced from shared tags and platforms — no rankings paid for.