Cum funcționează injectarea dependențelor în PHP modern?

Question

Accepted Answer

**Dependency Injection (DI)** este un pattern de design în care o clasă primește dependențele sale din exterior (de obicei prin constructor) în loc să le creeze ea însăși. Framework-urile PHP moderne folosesc DI extensiv, adesea cu un **container** care rezolvă și injectează dependențele automat — conducând la cod ușor cuplat și testabil.

## Problema pe care DI o rezolvă

```php
// ❌ tight coupling — the class CREATES its own dependencies (hard to test/swap)
class UserService {
    private $mailer;
    public function __construct() {
        $this->mailer = new SmtpMailer();   // hardcoded → can't mock, can't swap
    }
}

// ✅ dependency injection — dependencies are PASSED IN
class UserService {
    public function __construct(private MailerInterface $mailer) {}
    // depends on an INTERFACE, receives the concrete impl from outside
}
```

Injectarea dependențelor (contra unei **interfețe**) decuplează clasa de implementările concrete — puteți schimba implementările și injecta mock-uri în teste.

## Injectarea prin constructor (forma standard)

```php
class OrderService {
    public function __construct(
        private OrderRepository $repo,        // dependencies declared in the constructor
        private MailerInterface $mailer,
        private LoggerInterface $logger,
    ) {}
}
```

Injectarea prin constructor face ca dependențele să fie explicite și asigură că obiectul este complet format când este creat.

## Containerele DI — rezolvare automată

```php
// a DI CONTAINER builds objects, resolving the whole dependency graph automatically
$container->bind(MailerInterface::class, SmtpMailer::class);   // map interface → impl

$service = $container->get(OrderService::class);
// the container sees OrderService needs OrderRepository, MailerInterface, LoggerInterface,
// constructs each (recursively), and injects them — you don't `new` anything manually
```

Un **container DI** (în Laravel, Symfony, sau un independent ca PHP-DI) construiește automat obiecte prin rezolvarea dependențelor lor din constructor recursiv — configurați legăturile interfață-la-implementare, iar containerul conectează totul.

## Beneficiile

```text
✓ Loose coupling — depend on interfaces/abstractions, not concrete classes
✓ Testability — inject mocks/fakes in tests (no real DB/mailer needed)
✓ Flexibility — swap implementations via container config (e.g. fake mailer in dev)
✓ Single responsibility — classes focus on logic, not constructing dependencies
```

## De ce conteaza

Injectarea dependențelor este un pattern fundamental în PHP modern, central pentru modul în care sunt structurate aplicațiile și framework-urile profesionale (Laravel, Symfony), deci înțelegerea acesteia este cunoaștere importantă de nivel senior.

Valoarea principală este **decuplarea și testabilitatea**: prin faptul că clasele primesc dependențele lor (declarate contra interfețelor) în loc să le creeze, codul devine ușor cuplat (depinzând de abstracții, nu de implementări concrete), ușor **testabil** (injectați mock-uri în loc de baze de date/servicii reale — făcând testarea unitară temeinică practică), și flexibil (schimbarea implementărilor prin configurație).

Framework-urile PHP moderne furnizează **containere DI** care automatizează aceasta — rezolvând și injectând întregul grafic de dependențe automat pe baza legăturilor interfață-la-implementare, deci nu trebuie să construiți manual obiecte.

Înțelegerea injectării prin constructor (forma standard), programarea contra interfețelor, și modul în care funcționează containerele DI (rezolvare automată) este esențială pentru a lucra eficient cu framework-urile PHP (care sunt construite în jurul DI) și pentru a scrie cod bine arhitecturat, ușor de menținut și testabil.

Deoarece DI stă la baza structurii tuturor framework-urilor PHP moderne majore și este o caracteristică a designului profesional de aplicații, stăpânirea acesteia — pattern-ul, beneficiile sale, și rezolvarea bazată pe container — este cunoaștere importantă care deosebește dezvoltatorii care pot construi PHP curat, testabil, idiomatic pentru framework din cei care scriu cod strâns cuplat, greu de testat.