Using Annotations for Dependency Injection in Kotlin

Dependency Injection (DI) is a fundamental design pattern in modern software development that helps in integrating different parts of a program. In Kotlin, as in many other programming languages, DI is often facilitated by annotations. This article will guide you through using annotations for DI in Kotlin, leveraging frameworks like Dagger or Koin.

Understanding Dependency Injection

Before getting started with annotations, it's crucial to understand the concept of dependency injection. DI is a technique in which an object receives other objects it depends on, called dependencies. This approach makes testing easier and improves code maintainability.

Setting Up Your Kotlin Project

Before you can use annotations for DI, setup a Kotlin project. Start by configuring your build. Here is an example for setting up in a build.gradle.kts file using Dagger:

dependencies {
    implementation("com.google.dagger:dagger:2.x")
    kapt("com.google.dagger:dagger-compiler:2.x")
}

Make sure you're applying the Kotlin annotation processor plugin as well:

plugins {
    kotlin("kapt")
}

Using Annotations

Annotations in Kotlin serve as a metadata layer that we can use for DI. They are often used by frameworks to generate and manage code. Here are some common annotations used in DI:

• @Inject: Used to annotate constructors, fields, or methods for which dependencies should be provided.
• @Module: Defines a class that contributes application dependencies.
• @Provides: Inside @Modules, these functions tell the framework how to provide dependencies by creating an instance of the object.

Example with Dagger

Here’s a simple example of how to use Dagger with annotations for DI:

import dagger.Module
import dagger.Provides
import dagger.Component
import javax.inject.Inject

// A simple class that requires a dependency
class Car @Inject constructor(private val engine: Engine) {
    fun run() {
        println("Car is running with engine: ")
    }
}

@Module
class EngineModule {
    @Provides
    fun provideEngine(): Engine = Engine()
}

// The Dagger Component
@Component(modules = [EngineModule::class])
interface CarComponent {
    fun inject(app: App)
}

// Application class to run the example
class App {
    @Inject lateinit var car: Car

    fun setup() {
        DaggerCarComponent.create().inject(this)
        car.run()
    }
}

fun main() {
    val app = App()
    app.setup()
}

In this example, the Car class has a dependency on an Engine, and Dagger is used to provide this dependency via the @Inject annotation. The EngineModule provides the implementation details on how to create an instance of Engine.