Dependency Injection

🔍 What Is It?

Dependency Injection is the mechanism by which the Spring IoC Container provides a bean's dependencies.

Three injection types:

1. Constructor Injection (recommended)

@Service
public class OrderService {
    private final OrderRepository repository; // final — immutable
    
    public OrderService(OrderRepository repository) { // Spring calls this
        this.repository = repository;
    }
}

2. Setter Injection (optional dependencies)

@Service
public class NotificationService {
    private EmailService emailService; // optional
    
    @Autowired(required = false)
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

3. Field Injection (avoid)

@Service
public class UserService {
    @Autowired // Don't do this — untestable, hides dependencies
    private UserRepository repository;
}

🎯 Why Do We Need It?

DI is what makes Spring applications testable and maintainable:

Without DI (tight coupling):

public class OrderService {
    private OrderRepository repository = new JpaOrderRepository(); // hardcoded!
    // Can't test without a real database
    // Can't swap implementations
}

With DI (loose coupling):

public class OrderService {
    private final OrderRepository repository; // interface, not implementation
    
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
    // In tests: inject MockOrderRepository
    // In production: inject JpaOrderRepository
    // Change implementations without touching OrderService
}

🏗️ What Happens in Real Projects?

In a real enterprise Spring Boot application:

• →Every @Service uses constructor injection to receive its @Repository dependencies
• →Every @Controller uses constructor injection to receive its @Service dependencies
• →@Configuration beans inject other beans via constructor or method parameters
• →Tests inject mock implementations via constructor — no Spring context needed

The pattern is so consistent that Lombok's @RequiredArgsConstructor is commonly used to auto-generate constructors for all final fields.

⚙️ How It Works

Constructor injection resolution:

1. Spring needs to create OrderService
2. Reads its constructor: requires OrderRepository
3. Looks up OrderRepository bean in the container
4. Creates OrderRepository first (if not yet created)
5. Calls new OrderService(orderRepository)
6. OrderService is ready

@Autowired is optional for single-constructor classes:

Since Spring 4.3, if a class has exactly one constructor, Spring automatically uses it for injection — no @Autowired needed. This is the modern style.

@Qualifier for disambiguation:

When multiple beans of the same type exist, use @Qualifier("beanName") to specify which one.

💻 Example

Dependency Injection Patterns — Constructor injection, qualifiers, and testing with DI.

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final NotificationService notificationService;
    private final AppProperties appProperties;

    // No @Autowired needed — Spring detects single constructor
    public OrderService(
            OrderRepository orderRepository,
            PaymentService paymentService,
            InventoryService inventoryService,
            NotificationService notificationService,
            AppProperties appProperties) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
        this.notificationService = notificationService;
        this.appProperties = appProperties;
    }

    @Transactional
    public Order placeOrder(CreateOrderRequest request) {
        inventoryService.reserve(request.getItems());
        Order order = orderRepository.save(Order.from(request));
        paymentService.charge(order);
        notificationService.sendConfirmation(order);
        return order;
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits