Should You Avoid Field Injection in Spring? Constructor vs Setter Trade‑offs

Introduction

In dependency‑injection frameworks like Spring, field injection is popular because it is short and appears clean, but it carries several serious trade‑offs that are usually best avoided.

Injection Types

There are three primary ways to inject dependencies into a class: constructor injection, setter (method) injection, and field injection. The following code snippets illustrate each approach.

Constructor Injection

private DependencyA dependencyA;
private DependencyB dependencyB;
private DependencyC dependencyC;

@Autowired
public DI(DependencyA dependencyA, DependencyB dependencyB, DependencyC dependencyC) {
    this.dependencyA = dependencyA;
    this.dependencyB = dependencyB;
    this.dependencyC = dependencyC;
}

Setter Injection

private DependencyA dependencyA;
private DependencyB dependencyB;
private DependencyC dependencyC;

@Autowired
public void setDependencyA(DependencyA dependencyA) {
    this.dependencyA = dependencyA;
}

@Autowired
public void setDependencyB(DependencyB dependencyB) {
    this.dependencyB = dependencyB;
}

@Autowired
public void setDependencyC(DependencyC dependencyC) {
    this.dependencyC = dependencyC;
}

Field Injection

@Autowired
private DependencyA dependencyA;

@Autowired
private DependencyB dependencyB;

@Autowired
private DependencyC dependencyC;

Problems with Field Injection

Violation of the Single Responsibility Principle : Adding new dependencies is trivial, leading to classes that accumulate many responsibilities and become hard to maintain.

Hidden Dependencies : The class no longer explicitly declares what it needs, making it harder to understand its contract and to provide optional versus mandatory dependencies.

DI‑Container Coupling : The class becomes tightly coupled to the Spring container, preventing easy instantiation in plain unit tests without starting the container and risking NullPointerException when required collaborators are missing.

Immutability Issues : Unlike constructor injection, field injection cannot assign dependencies to final fields, leaving objects mutable and potentially error‑prone.

Constructor vs Setter Injection

Setter Injection

Setters are suitable for optional dependencies. They allow the object to be reconfigured after construction, which can be useful in scenarios such as JMX‑managed beans. Spring’s documentation historically encouraged setters to avoid long constructor parameter lists.

Spring teams often advocate setter injection because many constructor parameters become unwieldy, especially when some properties are optional. Setter methods also enable later re‑configuration or re‑injection of the object.

Constructor Injection

Constructor injection is ideal for mandatory dependencies. It guarantees that an object is fully initialized and can be made immutable by declaring injected fields as final. It also eliminates circular‑dependency problems that can arise with setters.

Since Spring 4.3, implicit constructor injection is supported, allowing developers to omit the @Autowired annotation on a single constructor, further reducing boilerplate.

Spring teams now promote constructor injection because it enables developers to build immutable components and ensures required dependencies are never null . Excessive constructor parameters, however, remain a code smell indicating too many responsibilities.

IDE Support

Recent versions of IntelliJ IDEA can automatically detect field injection and offer a quick‑fix that removes the @Autowired annotation from fields and generates a corresponding constructor, effectively converting field injection to constructor injection.

Conclusion

In most cases field injection should be avoided. Prefer constructor injection for required dependencies to achieve immutability and clear contracts, and use setter injection for optional dependencies when re‑configuration is needed. Mixing both approaches is possible, but the choice should be guided by the nature of each dependency.

Constructor injection suits mandatory dependencies and promotes immutability. Setter injection suits optional dependencies.