Dependency Injection e Inversion of Control in PHP

La Dependency Injection (DI) è un design pattern fondamentale nella programmazione a oggetti moderna. È un'implementazione del principio di Inversion of Control (IoC) e il suo obiettivo è creare codice debolmente accoppiato (loosely coupled).

Il Problema: L'Accoppiamento Forte (Tight Coupling)

Immagina di avere una classe `UserController` che ha bisogno di un oggetto `Database` per funzionare. L'approccio più semplice (ma sbagliato) è questo:

class UserController {
    private $db;

    public function __construct() {
        // La classe crea la sua dipendenza. C'è un accoppiamento forte!
        $this->db = new Database(); 
    }
}

Questo codice ha due grossi problemi:

1. Non è flessibile: `UserController` sarà per sempre legato alla classe specifica `Database`. Se un giorno volessi usare una classe diversa, `MongoDatabase`, dovresti modificare il codice di `UserController`.
2. Non è testabile: Quando testi `UserController`, non puoi "isolare" la sua logica. Il test eseguirà anche il codice di `Database`, connettendosi a un vero database, il che è lento e indesiderato nei test unitari.

La Soluzione: Invertire il Controllo (IoC)

Con la Dependency Injection, non è più la classe a creare le sue dipendenze, ma le riceve dall'esterno, di solito tramite il costruttore (Constructor Injection).

class UserController {
    private $db;

    // La dipendenza viene "iniettata" dall'esterno.
    public function __construct(DatabaseInterface $db) {
        $this->db = $db;
    }
}

// Codice esterno che usa la classe
$database = new Database();
$controller = new UserController($database);

I Vantaggi

• Flessibilità: Ora `UserController` dipende da un'interfaccia (`DatabaseInterface`), non da una classe concreta. Puoi passargli qualsiasi oggetto che implementi quell'interfaccia (`Database`, `MongoDatabase`), senza modificare `UserController`.
• Testabilità: Durante i test, puoi creare un "oggetto finto" (un "mock") che implementa `DatabaseInterface` e passarlo al costruttore. In questo modo puoi testare `UserController` in totale isolamento.

I Container di Dependency Injection

In un'applicazione grande, creare e "iniettare" manualmente tutti gli oggetti diventa complesso. Per questo si usano i Container di Dependency Injection (o Service Container). Sono componenti (spesso conformi allo standard PSR-11) che gestiscono automaticamente la creazione e l'iniezione delle dipendenze per te. Sono il cuore di framework come Laravel e Symfony.