What is dependency injection and the IoC container in Spring?

Question

IT Interview Practice · Accepted Answer

**Dependency injection (DI)** means a class does not create its own collaborators — it declares what it needs and the framework supplies them. The **IoC (Inversion of Control) container** is the part of Spring that builds objects (*beans*), wires their dependencies, and manages their lifecycle. "Inversion of control" = you hand control of object creation to the container instead of using `new`.

## Declaring and injecting beans

```java
@Service // registers this class as a bean the container manages
public class OrderService {

private final PaymentGateway gateway;

// Constructor injection: the container passes the PaymentGateway bean here.
    // No @Autowired needed when there is a single constructor.
    public OrderService(PaymentGateway gateway) {
        this.gateway = gateway;
    }
}

@Component // any Spring-managed bean; @Service/@Repository are specializations
public class StripeGateway implements PaymentGateway { /* ... */ }
```

At startup, `@ComponentScan` finds these classes, the container instantiates `StripeGateway`, then constructs `OrderService` passing that instance in.

## Prefer constructor injection

```java
@Autowired private PaymentGateway gateway; // field injection — avoid
```

Constructor injection lets you mark the field `final` (immutable), makes dependencies explicit, fails fast if a bean is missing, and needs no Spring to unit-test — you just call `new OrderService(mock)`.

## Why it matters

DI is the foundation everything else in Spring rests on. Interviewers want to hear *why* it helps: it decouples classes from their concrete collaborators, so you can swap `StripeGateway` for `PayPalGateway` or a mock without touching `OrderService`. Recommending constructor over field injection signals you have felt the testing pain field injection causes.

Declaring and injecting beans

Prefer constructor injection

Why it matters

Related questions