Why Field Injection Should Be Avoided in Spring Boot: Benefits of Constructor Injection

In the context of Spring Boot dependency injection, there is an ongoing debate about the best practice among field injection, setter injection, and constructor injection.

What is field injection? Field injection involves annotating a private field with @Autowired . Example:

@Component
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;

    public Order findOrderById(Long id) {
        return orderRepository.findById(id);
    }
}

Why stop using field injection?

1. Testability

Field injection makes unit testing difficult because the dependency is directly injected into a private field, preventing easy mocking outside the Spring context. Example test using reflection:

@RunWith(SpringJUnit4ClassRunner.class)
public class OrderServiceTest {
    private OrderService orderService;

    @Mock
    private OrderRepository orderRepository;

    @Before
    public void setUp() throws Exception {
        orderService = new OrderService();
        // This will set the mock orderRepository into orderService's private field
        ReflectionTestUtils.setField(orderService, "orderRepository", orderRepository);
    }
    ...
}

Using reflection is cumbersome and violates object‑oriented design principles.

2. Immutability

Field injection leaves beans mutable after construction. With constructor injection, dependencies are final and cannot be reassigned, preserving immutability.

@Component
public class UserService {
    @Autowired
    private UserRepository userRepository;
}

// Constructor injection version
@Component
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

3. Tighter coupling to Spring

Non‑Spring environments cannot use @Autowired directly.

Switching to another DI framework (e.g., Guice) requires refactoring all @Autowired usages.

New developers may be confused by Spring‑specific annotations.

4. Null‑Pointer Exceptions

When a bean is instantiated via its default constructor, injected fields may remain uninitialized, leading to NullPointerException at runtime.

@Component
public class PaymentGateway {
    @Autowired
    private PaymentQueue paymentQueue;

    public void initiate(PaymentRequest request) {
        paymentQueue.add(request);
    }
}

public class PaymentService {
    public void process(PaymentRequest request) {
        PaymentGateway gateway = new PaymentGateway();
        gateway.initiate(request);
    }
}

5. Circular dependencies

Field injection can hide circular dependencies, making them harder to detect. Example:

@Service
public class AService {
    @Autowired
    private BService bService;
}

@Service
public class BService {
    @Autowired
    private AService aService;
}

Constructor injection causes Spring to fail fast with a BeanCurrentlyInCreationException , revealing the issue early.

Conclusion

Although field injection may appear concise, its disadvantages outweigh its convenience. Constructor injection improves testability, enforces immutability, reduces coupling, and aligns with SOLID principles, making Spring Boot applications more maintainable and robust.