Ce este injecția de dependență și inversiunea controlului?

Question

Accepted Answer

**Injecția de Dependență (DI)** înseamnă că un obiect primește dependențele sale din exterior în loc să le creeze singur. Este o formă de **Inversiune a Controlului (IoC)**: responsabilitatea de a conecta obiectele este *inversată* departe de obiect și dată unui apelant sau unui container.

## Fără DI versus cu DI

```python
# WITHOUT DI — the class controls its own dependencies (tight coupling)
class OrderService:
    def __init__(self):
        self.repo = PostgresOrderRepo()   # hard-wired; can't swap or test

# WITH DI — dependencies are passed in (loose coupling)
class OrderService:
    def __init__(self, repo: OrderRepo):  # any OrderRepo implementation
        self.repo = repo

# wiring happens outside:
service = OrderService(PostgresOrderRepo())   # prod
test    = OrderService(InMemoryOrderRepo())   # test — no DB needed
```

Clasa depinde acum de *abstracția* `OrderRepo`, și altcineva decide care implementare concretă să furnizeze.

## Forme de injecție

| Formă | Cum |
|---|---|
| Constructor | Transmis constructorului (preferat — dependențe obligatorii explicite) |
| Setter | Setat printr-o metodă după construire (dependențe opționale) |
| Interface/container | Un framework rezolvă și injectează (Spring, .NET DI) |

## Compromisuri

```text
✓ Testable (inject fakes/mocks)   ✓ Swappable implementations
✓ Explicit dependencies            ⚠️ More wiring; indirection can obscure flow
⚠️ DI containers add "magic" → harder to trace what's wired where
```

## De ce este important

DI este realizarea practică a Principiului Inversiunii Dependenței — logica de nivel înalt încetează să depindă de clase concrete de nivel scăzut.

Beneficiul este testabilitate și flexibilitate: puteți înlocui o bază de date falsă în teste sau schimba un furnizor de plăți în producție schimbând cablajul, nu logica de afaceri.

Formă	Cum
Constructor	Transmis constructorului (preferat — dependențe obligatorii explicite)
Setter	Setat printr-o metodă după construire (dependențe opționale)
Interface/container	Un framework rezolvă și injectează (Spring, .NET DI)