Field vs Constructor Injection Spring | Java Fresher Interview

Direct Answer

Constructor injection makes required dependencies explicit, supports final fields, and lets tests construct the class with normal Java. Field injection hides required inputs and needs the container or reflection-based test support. Spring can inject either style, but constructor injection gives an object that cannot be created without its required collaborators.

Code Example

// RECOMMENDED: Constructor injection with final fields
@Service
class OrderService {
    private final PaymentGateway paymentGateway;
    private final InventoryRepository inventoryRepo;

    // Single constructor - Spring auto-wires without @Autowired since Spring 4.3
    public OrderService(PaymentGateway paymentGateway, InventoryRepository inventoryRepo) {
        this.paymentGateway = paymentGateway;
        this.inventoryRepo = inventoryRepo;
    }

    public void processOrder(Order order) {
        inventoryRepo.reserve(order.getItems());
        paymentGateway.charge(order.getTotal());
    }
}

// AVOID: Field injection with mutable state
@Service
class OrderServiceFieldInjection {
    @Autowired private PaymentGateway paymentGateway; // hidden dependency
    @Autowired private InventoryRepository inventoryRepo; // mutable

    // Dependencies not visible in constructor - harder to test
    public void processOrder(Order order) {
        inventoryRepo.reserve(order.getItems());
        paymentGateway.charge(order.getTotal());
    }
}

Common Mistakes & Pitfalls

• Choosing Field Injection for Brevity: Freshers pick @Autowired field injection because it's fewer lines of code, not realizing they're sacrificing testability and immutability.
• Mixing Injection Types: Using constructor injection for some dependencies and field injection for others creates inconsistency and confusion about which are mandatory.
• Not Using Final Fields: Declaring constructor-injected dependencies without final allows accidental reassignment and signals to readers that the field might change, when it shouldn't.
• Ignoring Circular Dependencies: Field injection can mask circular dependency issues until runtime; constructor injection surfaces them immediately during Spring context startup.