Dependency Injection

Dependency Injection in Spring

Dependency Injection (DI) is how Spring manages object creation and wiring. Instead of using new, Spring creates objects and injects dependencies for you.

The IoC Container

Spring's ApplicationContext is the DI container. It:

Scans classes annotated with @Component, @Service, @Repository, @Controller
Instantiates them as beans (singletons by default)
Injects their dependencies

Component Stereotypes

@Component   // generic Spring bean
@Service     // service-layer logic (same as @Component, communicates intent)
@Repository  // data-access layer (also translates DB exceptions)
@Controller  // web layer (handles HTTP requests)

Constructor Injection (recommended)

@Service
public class OrderService {
    private final OrderRepository repository;
    private final EmailService emailService;

    // Spring injects these — no @Autowired needed on single constructor
    public OrderService(OrderRepository repository, EmailService emailService) {
        this.repository  = repository;
        this.emailService = emailService;
    }

    public Order placeOrder(CreateOrderRequest request) {
        Order order = repository.save(new Order(request));
        emailService.sendConfirmation(order);
        return order;
    }
}

Why constructor injection?

Fields can be final (immutability)
All dependencies explicit (easy to see what a class needs)
Testable without Spring (just call the constructor)

Field Injection (avoid)

@Service
public class OrderService {
    @Autowired
    private OrderRepository repository; // ❌ avoid — hides dependencies, hard to test
}

Conditional beans

@Bean
@ConditionalOnProperty(name = "feature.notifications.enabled", havingValue = "true")
public NotificationService notificationService() {
    return new EmailNotificationService();
}

Bean scopes

@Component
@Scope("prototype")  // new instance per injection (default is "singleton")
public class RequestHandler { ... }

Interview Tip

"Always prefer constructor injection over field injection. It makes dependencies explicit, supports immutability, and allows unit testing without Spring context overhead."

Common question: "What is the difference between @Component, @Service, and @Repository?"

Functionally identical — all register a bean. The difference is semantic: @Repository adds exception translation (converts DB-specific exceptions to Spring's DataAccessException hierarchy).