Digital solutions
Design Patterns avec Laravel

Dependency Injection Pattern

  • Type : Créationnel
  • Difficulté : 6/10
  • Définition succincte : Le Dependency Injection Pattern est un design pattern de création qui consiste à injecter les dépendances d'une classe à l'extérieur plutôt que de les créer au sein de la classe elle-même. Cela permet de rendre le code plus flexible, testable et découplé. Laravel utilise ce pattern via son Service Container, qui est responsable de la gestion des dépendances et de leur injection automatique dans les classes.

Objectif du Dependency Injection Pattern

L'objectif principal du Dependency Injection Pattern est de découpler les classes de leurs dépendances. Plutôt que de laisser une classe créer elle-même ses dépendances, elles lui sont fournies (injectées), souvent via un constructeur, un setter, ou une méthode. Cela facilite grandement le test unitaire et permet une meilleure gestion des modifications dans les dépendances sans affecter le code de la classe qui les utilise.

Structure du Dependency Injection Pattern

  • Client : La classe qui dépend d'autres classes ou services.
  • Service : La classe ou le service dont le client dépend.
  • Injector : L'objet ou le mécanisme qui injecte les dépendances dans le client.

1. Exemple d'utilisation dans Laravel

Laravel facilite grandement l'utilisation de l'injection de dépendances via son Service Container. Les dépendances sont automatiquement injectées dans les classes comme les contrôleurs, les middlewares, les jobs, etc.

Voici un exemple de la manière dont Laravel injecte automatiquement des services dans un contrôleur via le constructeur :

// app/Http/Controllers/OrderController.php

namespace App\Http\Controllers;

use App\Services\PaymentGateway;

class OrderController extends Controller
{
    protected $paymentGateway;

    // Injection de la dépendance via le constructeur
    public function __construct(PaymentGateway $paymentGateway)
    {
        $this->paymentGateway = $paymentGateway;
    }

    public function processOrder()
    {
        $this->paymentGateway->charge(1000);
    }
}

Dans cet exemple, le service PaymentGateway est injecté directement dans le contrôleur grâce à la puissance du conteneur de services de Laravel. Laravel résout automatiquement les dépendances lorsque le contrôleur est instancié.

2. Implémentation complète dans Laravel

Imaginons maintenant que tu développes un système de gestion de commandes où le processus de facturation et de notification doit être géré par des services externes. Plutôt que de coupler ces services directement dans ta classe principale, tu utilises l'injection de dépendances pour rendre le système plus modulaire et facile à tester.

a) Créer des services

Commençons par définir deux services : un pour la facturation (BillingService) et un pour la notification (NotificationService).

2.1. Service de facturation (BillingService)
// app/Services/BillingService.php

namespace App\Services;

class BillingService
{
    public function processPayment(int $amount)
    {
        // Simule le traitement du paiement
        return "Processed payment of $amount.";
    }
}
2.2. Service de notification (NotificationService)
// app/Services/NotificationService.php

namespace App\Services;

class NotificationService
{
    public function sendNotification(string $message)
    {
        // Simule l'envoi d'une notification
        return "Notification sent: $message";
    }
}

b) Utiliser l'injection de dépendances dans une commande CLI

Nous allons maintenant injecter ces deux services dans une commande CLI pour gérer le processus de commande.

// app/Console/Commands/ProcessOrder.php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use App\Services\BillingService;
use App\Services\NotificationService;

class ProcessOrder extends Command
{
    protected $signature = 'order:process {amount}';
    protected $description = 'Process an order by charging and sending notification';

    protected $billingService;
    protected $notificationService;

    // Injection des services via le constructeur
    public function __construct(BillingService $billingService, NotificationService $notificationService)
    {
        parent::__construct();
        $this->billingService = $billingService;
        $this->notificationService = $notificationService;
    }

    public function handle()
    {
        $amount = $this->argument('amount');

        // Utiliser le service de facturation pour traiter le paiement
        $paymentResult = $this->billingService->processPayment($amount);
        $this->info($paymentResult);

        // Envoyer une notification de succès
        $notificationResult = $this->notificationService->sendNotification("Payment of $amount processed successfully.");
        $this->info($notificationResult);
    }
}

c) Déclaration des services dans le conteneur

Laravel détecte automatiquement les dépendances si elles sont correctement liées dans le conteneur. Cependant, si tu veux enregistrer les services manuellement, tu peux le faire dans un Service Provider :

// app/Providers/AppServiceProvider.php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Services\BillingService;
use App\Services\NotificationService;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(BillingService::class, function ($app) {
            return new BillingService();
        });

        $this->app->bind(NotificationService::class, function ($app) {
            return new NotificationService();
        });
    }

    public function boot()
    {
        //
    }
}

d) Exécution de la commande

Voici comment tu peux exécuter cette commande en passant un montant en argument :

php artisan order:process 1000

Cela renverra :

Processed payment of 1000.
Notification sent: Payment of 1000 processed successfully.

Exemple de résultat

En utilisant l'injection de dépendances dans cette commande, Laravel gère automatiquement la résolution des services BillingService et NotificationService. Cela permet de maintenir la classe ProcessOrder légère, modulaire et facilement testable.

Exemple de test avec des mocks (facilité par l'injection de dépendances)

Voici un exemple de test unitaire où nous simulons le service EmailService à l'aide d'un mock pour tester le contrôleur sans envoyer réellement des emails.

// tests/Unit/EmailControllerTest.php

namespace Tests\Unit;

use App\Http\Controllers\EmailController;
use App\Services\EmailService;
use Illuminate\Http\Request;
use Tests\TestCase;

class EmailControllerTest extends TestCase
{
    public function testSendEmail()
    {
        // Créer un mock du service EmailService
        $emailServiceMock = $this->createMock(EmailService::class);

        // Définir ce que doit retourner le mock lorsqu'il est appelé
        $emailServiceMock->method('send')
                         ->willReturn("Email sent to johndoe@example.com with subject 'Welcome'");

        // Injecter le mock dans le contrôleur
        $controller = new EmailController($emailServiceMock);

        // Créer une requête simulée
        $request = Request::create('/send-email', 'POST', [
            'to' => 'johndoe@example.com',
            'subject' => 'Welcome',
            'body' => 'Thank you for signing up!'
        ]);

        // Appeler la méthode sendEmail
        $response = $controller->sendEmail($request);

        // Vérifier que la réponse est correcte
        $this->assertEquals('{"message":"Email sent to johndoe@example.com with subject \'Welcome\'"}', $response->getContent());
    }
}

Avantages du Dependency Injection Pattern

  1. Découplage : Les classes sont découplées de leurs dépendances, ce qui facilite leur modification et leur test sans devoir changer l'implémentation interne.
  2. Testabilité améliorée : Avec l'injection de dépendances, il devient facile de substituer des dépendances réelles par des mocks ou des fakes dans les tests unitaires, rendant les tests plus efficaces et indépendants.
  3. Réutilisation : Les services injectés peuvent être réutilisés à différents endroits dans l'application, centralisant ainsi la logique et évitant la duplication de code.
  4. Flexibilité : La manière dont une dépendance est injectée peut être facilement modifiée sans toucher au code qui utilise ces dépendances.

Inconvénients du Dependency Injection Pattern

  1. Complexité supplémentaire : Si mal utilisé, l'injection de dépendances peut entraîner une complexité excessive avec trop de dépendances injectées dans les classes, rendant le code plus difficile à lire.
  2. Surcharge cognitive : Pour les débutants, comprendre comment le Service Container fonctionne et comment Laravel injecte les dépendances automatiquement peut être déroutant au début.

Conclusion

Le Dependency Injection Pattern est un pattern fondamental pour créer des applications modulaires, maintenables et testables. En Laravel, ce pattern est utilisé principalement via le Service Container, qui automatise la gestion et l'injection des dépendances. En séparant la création et l'injection des dépendances du code métier, tu améliores la flexibilité de ton application tout en rendant les tests unitaires plus faciles à écrire. Ce pattern est essentiel pour développer des applications modernes et évolutives avec Laravel.