Ce este injecția de dependențe și cum se aplică în…

Injecția de dependințe (DI) este un model de proiectare care permite unui obiect să primească dependințe de la alt obiect sau framework, în loc să le creeze singur. Acest lucru facilitează gestionarea dependențelor claselor și face codul mai flexibil, testabil și ușor de întreținut.

În PHP, DI este utilizat pentru:

Reducerea cuplajului (coupling): Clasele nu sunt legate strict de implementările specifice ale dependențelor lor.
Simplificarea testării unitare: Se pot înlocui cu ușurință dependențele reale cu obiecte mock pentru testare.
Creșterea flexibilității și extensibilității: Se pot modifica sau înlocui implementările dependențelor fără a modifica clasa care le utilizează.

Există trei abordări principale pentru injectarea dependențelor:

Injectarea prin constructor (Constructor Injection): Dependințele sunt transmise ca argumente ale constructorului clasei. Este cea mai preferată metodă, deoarece garantează prezența dependențelor necesare la crearea obiectului.

<?php
class DatabaseConnection
{
    // Detalii despre conexiunea la bază de date
}

class UserRepository
{
    private DatabaseConnection $db;

    public function __construct(DatabaseConnection $db)
    {
        $this->db = $db;
    }

    // Metode ale repository-ului
}

// Crearea unui obiect cu injectarea dependenței
$db = new DatabaseConnection();
$userRepository = new UserRepository($db);

Injectarea prin setter (Setter Injection): Dependințele sunt injectate prin metode publice-setter. Permite ca dependențele să fie opționale.

<?php
class Logger
{
    // Logare
}

class UserService
{
    private ?Logger $logger = null; // Dependență opțională

    public function setLogger(Logger $logger): void
    {
        $this->logger = $logger;
    }

    public function doSomething(): void
    {
        if ($this->logger) {
            $this->logger->log("Fac ceva...");
        }
        // Logica principală
    }
}

// Crearea obiectului și injectarea opțională a dependenței
$userService = new UserService();
$logger = new Logger();
$userService->setLogger($logger);

Injectarea prin interfață (Interface Injection): Clasa care are nevoie de dependență implementează o interfață care definește metoda de setare a acesteia. Este mai puțin comun în PHP comparativ cu primele două.

În aplicațiile PHP reale, se folosesc adesea containere de injectare a dependențelor (Dependency Injection Containers). Acestea sunt biblioteci sau framework-uri care automatizează procesul de creare a obiectelor și a dependențelor lor. Containerul poate analiza dependențele clasei și poate crea și injecta automat obiectele necesare.

Exemple de containere DI populare pentru PHP:

PHP-DI
Symfony\DependencyInjection
Laravel Service Container (integrat în Laravel)

Utilizarea containerului DI:

<?php
// Exemplu cu un pseudo-container
// De obicei, containerul este configurat cu ajutorul configurației (YAML, array-uri PHP etc.)

// Configurarea containerului (simplificat)
$container->set(DatabaseConnection::class, function() {
    return new DatabaseConnection(); // Crearea unei instanțe
});

$container->set(UserRepository::class, function($container) {
    // Injectarea dependenței DatabaseConnection la crearea UserRepository
    return new UserRepository($container->get(DatabaseConnection::class));
});

// Obținerea obiectului din container - containerul va crea și injecta dependențele
$userRepository = $container->get(UserRepository::class);

În concluzie, injectarea dependențelor în PHP este un model cheie pentru construirea unui cod flexibil, testabil și ușor de întreținut, mai ales în proiecte mari și atunci când se utilizează framework-uri.

Ce este injecția de dependențe și cum se aplică în dezvoltarea PHP?