principe d'inversion de laravel di

Laravel est un framework PHP très populaire. Il est largement apprécié par les développeurs pour sa simplicité, son élégance et sa facilité d'utilisation. En fait, une fonctionnalité importante du framework Laravel est l'injection de dépendances (DI) et l'inversion de contrôle (IoC), qui rendent Laravel plus élégant et plus simple lors de la gestion des dépendances des applications. Dans cet article, nous allons approfondir les principes de DI et d’inversion de Laravel.

1. Qu'est-ce que l'injection de dépendance ?

Dans une application, une classe dépend généralement d'une autre classe ou d'un autre objet pour accomplir sa tâche. Dans les modèles de programmation traditionnels, nous instancions généralement ces dépendances dans des classes. Bien que cette approche soit simple et claire, elle couplera étroitement la classe et ses dépendances.

L'injection de dépendances est un modèle de conception qui sépare une classe des objets dont elle dépend et les connecte via des interfaces. Les dépendances sont transmises à la classe dans le constructeur, permettant à la classe de les utiliser au moment de l'exécution. Par conséquent, l’injection de dépendances peut rendre la relation entre les applications et les classes plus flexible et extensible.

2. Injection de dépendances dans Laravel

Dans le framework Laravel, l'injection de dépendances est implémentée via des conteneurs de services et des liaisons. Le conteneur de services est le conteneur d'injection de dépendances de Laravel, qui vous permet de gérer et d'injecter des dépendances.

La liaison consiste à lier une interface ou une classe à une instance dans le conteneur de service. Une fois la liaison terminée, vous pouvez utiliser le résolveur de conteneur pour instancier ces objets à partir du conteneur.

Dans le framework Laravel, vous pouvez utiliser trois types de liaison : instance de liaison, contexte de liaison, interface de liaison ou classe abstraite. Examinons-les séparément.

2.1 Instance de liaison

L'utilisation d'une instance de liaison est très utile lorsque vous devez enregistrer un objet dans un conteneur de service. Cette situation se produit généralement dans les contrôleurs car nous devons y injecter de nombreux objets différents.

Par exemple, supposons que nous ayons une classe TaskController et que nous devions injecter un objet TaskRepository pour gérer les tâches :

class TaskController extends Controller 
{
    protected $taskRepository;

    public function __constructor(TaskRepository $taskRepository) 
    {
        $this->taskRepository = $taskRepository;
    }
}

Nous pouvons utiliser l'injection de dépendances pour injecter la dépendance TaskRepository. Pour ce faire, nous devons lier une instance de TaskRepository dans le conteneur de service :

$this->app->bind('TaskRepository', function($app) {
    return new TaskRepository();
});

Dans l'exemple ci-dessus, nous utilisons l'instance $app pour créer une nouvelle instance de TaskRepository puis la renvoyer. Une fois que nous avons lié le TaskRepository au conteneur, nous pouvons l'injecter dans le contrôleur à l'aide du constructeur du TaskController.

2.2 Contexte de liaison

Le contexte de liaison nous permet de lier une instance d'une classe dans le conteneur de service. Lorsqu'une classe est résolue, le conteneur de services tente d'abord de trouver la classe à partir du contexte de liaison, puis l'injecte si nécessaire.

Par exemple, plusieurs objets TaskRepository peuvent être utilisés dans notre application. Si nous les lions tous dans le conteneur, alors chaque objet occupera de l'espace mémoire, et lorsque nous utilisons le TaskRepository dans le contrôleur, il n'y a aucun moyen de distinguer quel objet est utilisé.

Pour résoudre ce problème, nous pouvons utiliser la liaison de contexte. Cela nous permet de lier différentes instances de TaskRepository au contexte du conteneur et de distinguer quelle instance est utilisée via la valeur Key.

Par exemple :

$this->app->when('AppHttpControllersTaskController')
    ->needs('TaskRepository')
    ->give(function ($app) {
        if (session('useMock')) {
            return new TaskRepositoryMock();
        } else {
            return new TaskRepository();
        }
    });

Dans le code ci-dessus, nous utilisons la méthode when() du conteneur de service. Cette méthode reçoit un nom de classe en paramètre, indiquant quel constructeur de classe doit injecter des dépendances. La méthode

needs() indique au conteneur de quelle dépendance nous avons besoin, tandis que la méthode give() renvoie en fait l'instance dont nous avons besoin.

2.3 Interfaces de liaison ou classes abstraites

Dans Laravel, nous utilisons généralement des interfaces ou des classes abstraites pour définir des dépendances externes. Dans l'application, nous lions ces interfaces ou classes abstraites aux classes d'implémentation réelles. Cela nous permet d'utiliser ces dépendances dans des contrôleurs ou d'autres classes sans nous soucier de leur implémentation spécifique.

Par exemple, nous pouvons avoir une interface TaskRepository qui gère certaines opérations sur les tâches. Nous pouvons lier cette interface à une classe concrète. De cette façon, lorsque nous avons besoin d'un objet TaskRepository dans le contrôleur, le conteneur de service en renverra automatiquement une instance.

$this->app->bind('TaskRepository', 'TaskRepositoryImpl');

Dans le code ci-dessus, nous lions l'interface TaskRepository à une classe concrète appelée TaskRepositoryImpl.

3. Inversion de Contrôle

Dans l'injection de dépendances, l'Inversion de Contrôle (IoC) est un concept très important. Dans les modèles de programmation traditionnels, les développeurs sont généralement responsables de la création d'objets et de la résolution des dépendances entre les objets. Il s’agit du flux de contrôle.

En contrôle d'inversion, le flux de contrôle est inversé. L'application n'est plus responsable de la création et de la gestion des objets, mais le framework ou le conteneur s'occupe de ce problème. Toutes les dépendances sont gérées par le conteneur plutôt que gérées par le développeur.

L'avantage du contrôle d'inversion est qu'il peut réduire considérablement le couplage dans le code, rendant le code plus flexible et évolutif. Cela rend notre code plus facile à tester et à maintenir.

4. Résumé

Dans cet article, nous avons présenté l'injection de dépendances et le mécanisme d'inversion de contrôle du framework Laravel. Grâce à ces mécanismes, nous pouvons rendre nos applications plus flexibles et évolutives, ce qui les rend plus faciles à tester et à maintenir. Comprendre les principes de DI et d'inversion de Laravel est très utile pour les développeurs. Si vous utilisez actuellement Laravel pour développer des applications, vous espérez avoir une compréhension générale de la DI et de l'inversion grâce à cet article.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!