NUHMAN.com

In Java, Dependency Injection (DI) is a design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. It helps to decouple components, making the codebase more modular, testable, and easier to maintain. There are several types of dependency injection techniques, each suited to different use cases. Let’s explore the most common types:

1. Constructor Injection

Constructor Injection involves passing dependencies to a class via its constructor. This makes the dependency mandatory and encourages immutability.

Example:

java

public class Service {
    private final Repository repository;

    public Service(Repository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        repository.action();
    }
}

Here, Service cannot be instantiated without a Repository, ensuring a valid state from the start.

2. Setter Injection

Setter Injection provides dependencies via public setter methods. It’s useful when dependencies are optional or when you want to change them after instantiation.

Example:

java

public class Service {
    private Repository repository;

    public void setRepository(Repository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        repository.action();
    }
}

Setter injection allows flexibility but may result in an incomplete object if setters are not properly invoked.

3. Field Injection

Field Injection injects dependencies directly into class fields using annotations. While concise, it hides dependencies and complicates unit testing.

Example:

java

public class Service {
    @Inject
    private Repository repository;

    public void doSomething() {
        repository.action();
    }
}

Frameworks like Spring or Google Guice handle this automatically using reflection.

4. Interface Injection

In Interface Injection, the dependency is provided through an interface method, requiring the dependent class to implement that interface.

Example:

java

public interface RepositoryAware {
    void setRepository(Repository repository);
}

public class Service implements RepositoryAware {
    private Repository repository;

    @Override
    public void setRepository(Repository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        repository.action();
    }
}

This form is rarely used in modern Java applications but demonstrates a different way to enforce dependency contracts.

Dependency Injection with Spring Framework

Spring is the most widely used DI framework in Java. It supports all three major forms of injection: constructor, setter, and field.

Constructor Injection:

java

@Component
public class Service {
    private final Repository repository;

    @Autowired
    public Service(Repository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        repository.action();
    }
}

Setter Injection:

java

@Component
public class Service {
    private Repository repository;

    @Autowired
    public void setRepository(Repository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        repository.action();
    }
}

Field Injection:

java

@Component
public class Service {
    @Autowired
    private Repository repository;

    public void doSomething() {
        repository.action();
    }
}

While Spring supports all methods, constructor injection is generally preferred due to its explicitness and support for immutability.

Summary

TypeCharacteristicsUse CaseConstructor InjectionMandatory dependencies, supports immutabilityPreferred in most scenariosSetter InjectionOptional or reassignable dependenciesWhen flexibility is neededField InjectionConcise, but harder to testUsed mainly by frameworksInterface InjectionRequires interface implementationRarely used

Conclusion:

Choosing the right dependency injection technique depends on your application’s design goals. Constructor injection is ideal for most cases, especially when working with frameworks like Spring, while setter and field injection offer flexibility when needed. Interface injection remains more of an academic example than a real-world necessity.