Java Dependency Injection with Dagger

Dependency Injection (DI) is a design pattern used to implement Inversion of Control (IoC), allowing you to achieve better modularity and ease of testing by injecting dependencies into a class rather than creating them within the class. Dagger is a popular dependency injection framework for Java that makes use of compile-time dependency injection. Dagger is particularly useful for Android development but is also widely used in Java backend applications.

This guide explores how to use Dagger to perform dependency injection in Java.

1. What is Dagger?

Dagger is a dependency injection framework for Java, designed to handle the task of providing objects (dependencies) to other objects (clients) that need them. It uses annotation processing to generate the necessary code during compile-time rather than at runtime, which leads to more efficient and faster performance compared to reflection-based frameworks.

Dagger is primarily used in Java and Android applications to manage dependencies and streamline the creation and injection of objects.

2. Why Use Dependency Injection (DI)?

Dependency Injection has several benefits:

Loose Coupling: DI reduces the dependency between components, making the code more flexible and easier to maintain.
Testability: By injecting dependencies, it is easier to swap out components for mock or stub classes during unit testing.
Modularity: DI promotes the separation of concerns by allowing you to inject different implementations of an interface, making the system more modular and scalable.
Cleaner Code: DI eliminates the need for manually creating or managing objects, leading to more readable, concise code.

3. Key Concepts of Dagger

Before we dive into examples, let’s briefly understand some key terms and concepts used in Dagger:

3.1. @Inject

The @Inject annotation marks fields, methods, or constructors that are used for dependency injection. It tells Dagger to inject the necessary dependencies at runtime or compile-time.

3.2. @Module

A @Module is a class that provides methods to supply dependencies. These methods are annotated with @Provides to tell Dagger how to create the dependency.

3.3. @Component

A @Component is an interface that defines the injection points for dependencies. It connects the modules with the places where dependencies need to be injected.

4. Example: Simple Dependency Injection with Dagger

4.1. Step 1: Add Dagger Dependency

To use Dagger in a Java project, you need to add Dagger as a dependency in your pom.xml (for Maven) or build.gradle (for Gradle).

For Maven:

<dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger</artifactId>
    <version>2.40.5</version> <!-- Use the latest version -->
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger-compiler</artifactId>
    <version>2.40.5</version> <!-- Use the latest version -->
    <scope>provided</scope>
</dependency>

For Gradle:

implementation 'com.google.dagger:dagger:2.40.5' // Use the latest version
annotationProcessor 'com.google.dagger:dagger-compiler:2.40.5' // Use the latest version

4.2. Step 2: Create the Dependencies

Let’s create a simple scenario where we have a Car class that depends on an Engine class.

public class Engine {
    private String type;

    public Engine(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

public class Car {
    private Engine engine;

    @Inject // Tells Dagger to inject the Engine dependency here
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void displayEngineType() {
        System.out.println("Car's engine type: " + engine.getType());
    }
}

4.3. Step 3: Create a Dagger Module

In Dagger, the @Module class defines how to create dependencies. In this example, we will use the @Module annotation to provide an Engine object to be injected into the Car class.

import dagger.Module;
import dagger.Provides;

@Module
public class CarModule {

    @Provides
    public Engine provideEngine() {
        return new Engine("V8");
    }
}

The provideEngine() method is used to tell Dagger how to create an instance of Engine. It uses the @Provides annotation to indicate that it is a provider method.

4.4. Step 4: Create a Dagger Component

The @Component interface defines the connection between the modules and the classes that require injection. In this case, we’ll create a CarComponent interface.

import dagger.Component;

@Component(modules = CarModule.class)
public interface CarComponent {
    void inject(Car car); // Injection point
}

The CarComponent interface defines a method inject(Car car) that will perform the actual injection of dependencies into the Car class.

4.5. Step 5: Create the Main Application to Run

Now, we’ll use the Dagger-generated code to inject the Engine dependency into a Car instance.

public class Main {
    public static void main(String[] args) {
        // Create the Dagger component
        CarComponent carComponent = DaggerCarComponent.create();

        // Inject the dependencies
        Car car = new Car(null); // Passing null as Dagger will inject the Engine
        carComponent.inject(car); // Perform the injection

        // Call a method on the Car instance to display the injected Engine's type
        car.displayEngineType(); // Output: Car's engine type: V8
    }
}

In the above code:

We create the CarComponent using DaggerCarComponent.create(). This is where Dagger generates the code that connects the module (CarModule) and the class (Car).
The inject() method is called to inject the dependencies into the Car object.

5. Benefits of Using Dagger for Dependency Injection

Compile-Time Dependency Injection: Unlike reflection-based DI frameworks, Dagger performs dependency injection at compile-time. This results in faster performance and eliminates runtime overhead.
Clear and Explicit Wiring: Dagger’s annotations make the relationships between dependencies clear and explicit. You can see exactly where each dependency is coming from.
Scalability: Dagger is highly scalable and suitable for complex applications with many dependencies.
Reduced Boilerplate Code: Dagger eliminates the need for manually writing code to wire up dependencies, making your codebase cleaner and more maintainable.
Easy Integration with Android: Dagger is commonly used in Android development, especially with Dagger 2 (Android-specific version).

6. Drawbacks of Dagger

Complexity: Dagger requires understanding of annotations, modules, and components. It can be harder to learn compared to other frameworks like Spring for beginners.
Error Messages: Dagger’s compile-time errors can sometimes be difficult to understand, especially for complex dependency graphs.
Requires Annotation Processing: Dagger requires an annotation processor to generate the necessary code, which adds some setup overhead.