Comment utiliser l'injection de dépendances de Laravel

L'injection de dépendances est un modèle de conception qui peut réduire la complexité du code et améliorer la maintenabilité et la testabilité du code. Il s'agit d'une technologie essentielle dans le développement d'applications PHP modernes. Laravel est un framework PHP populaire fourni avec un conteneur d'injection de dépendances qui peut nous aider à mieux gérer la création et la publication d'objets. Dans cet article, nous apprendrons comment utiliser la fonctionnalité d’injection de dépendances de Laravel.

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

L'injection de dépendances est un modèle de programmation qui peut transmettre les dépendances d'un objet à d'autres objets qui l'appellent, réduisant ainsi le couplage. Dans la programmation orientée objet, il existe des dépendances entre les différentes parties qui composent un objet. Chaque objet doit s'appuyer sur des instances d'autres objets pour fonctionner correctement. Le but de l'injection de dépendances est de découpler ces dépendances de l'intérieur de l'objet, afin que les dépendances d'un objet soient gérées par un conteneur externe.

Pour une application PHP, le processus d'injection de dépendances est généralement divisé en les étapes suivantes :

1. Définir les dépendances : Définir d'autres objets ou valeurs dont dépend chaque objet.
2. Configurez le conteneur : enregistrez les instances d'objet requises dans le conteneur.
3. Résoudre les dépendances : lorsqu'une méthode d'un objet doit être appelée, le conteneur résout automatiquement les autres instances d'objet dont il dépend.

Le conteneur d'injection de dépendances de Laravel est un outil très puissant qui peut facilement résoudre les problèmes de gestion des dépendances.

2. L'utilisation de l'injection de dépendances dans Laravel

Voyons comment utiliser l'injection de dépendances dans Laravel.

1. Enregistrement des instances d'objet

Dans Laravel, nous pouvons utiliser la méthode bind du conteneur pour enregistrer les instances d'objet. Par exemple, nous souhaitons enregistrer un objet UserService et ajouter le code suivant dans le fournisseur de services :

public function register()
{
    $this->app->bind(UserService::class, function($app) {
        return new UserService($app->make(UserRepository::class));
    });
}

Ici, nous utilisons la méthode bind pour enregistrer le UserService dans le conteneur et définir une fonction de fermeture pour créer une instance d'objet. Dans la fonction de fermeture, nous utilisons la méthode make du conteneur pour obtenir l'objet UserRepository dont dépend UserService.

2. Utilisation de l'injection de dépendances

Maintenant que nous avons enregistré l'objet UserService dans le conteneur, comment l'utiliser dans le contrôleur ? C'est très simple, il suffit de définir un paramètre UserService dans le constructeur du contrôleur. Par exemple :

use App\Services\UserService;

class UserController extends Controller
{
    private $user;

    public function __construct(UserService $user)
    {
        $this->user = $user;
    }
}

Ici, nous définissons un paramètre d'objet UserService dans le constructeur de UserController. Nous n'avons pas besoin de créer manuellement l'objet UserService, Laravel l'injectera automatiquement dans le paramètre constructeur.

3. Résoudre automatiquement les dépendances

Le conteneur d'injection de dépendances de Laravel peut résoudre automatiquement les dépendances, nous permettant d'utiliser facilement l'injection de dépendances. Par exemple, nous avons enregistré le code suivant chez le fournisseur de services :

public function register()
{
    $this->app->bind(UserService::class, function($app) {
        return new UserService($app->make(UserRepository::class));
    });
}

Ensuite, nous pouvons utiliser UserService directement dans le constructeur de UserController :

use App\Services\UserService;

class UserController extends Controller
{
    private $user;

    public function __construct(UserService $user)
    {
        $this->user = $user;
    }
}

Lorsque nous construisons l'objet UserController, Laravel détectera automatiquement qu'il nécessite un objet UserService, et alors un objet UserService sera automatiquement créé et injecté dans le UserController.

4. Passer des paramètres

Parfois, nous devons transmettre des paramètres lors de la création d'un objet. Par exemple, lorsque nous créons un objet UserService, nous devons transmettre un objet UserRepository.

Nous pouvons réaliser cette fonction en passant des paramètres lors de la liaison de l'objet. Par exemple :

public function register()
{
    $this->app->bind(UserService::class, function($app, $parameters) {
        return new UserService($parameters['userRepository']);
    });
}

$userService = app(UserService::class, ['userRepository' => new UserRepository()]);

Cela crée un objet UserService et lui transmet un nouvel objet UserRepository.

5. Dépendances héritées

Parfois, plusieurs classes dépendent de la même classe, et nous pouvons utiliser l'héritage pour simplifier le code d'injection de dépendances. Par exemple :

class BaseService
{
    protected $repository;

    public function __construct(BaseRepository $repository)
    {
        $this->repository = $repository;
    }
}

class UserService extends BaseService
{
    public function __construct(UserRepository $userRepository)
    {
        parent::__construct($userRepository);
    }
}

Ici, nous définissons une classe BaseService pour gérer les dépendances des objets BaseRepository, et héritons de la classe BaseService dans la classe UserService. De cette manière, l'objet BaseRepository peut être utilisé directement dans UserService.

3. Résumé

Le conteneur d'injection de dépendances de Laravel est un outil très puissant qui peut facilement résoudre les problèmes de gestion des dépendances. Lorsque vous utilisez l'injection de dépendances de Laravel, vous devez faire attention à certains détails :

1. Définir les dépendances : définissez d'autres objets ou valeurs dont dépend chaque objet et utilisez la méthode bind du fournisseur de services pour les enregistrer dans le conteneur.
2. Utilisez l'injection de dépendances : définissez un paramètre d'objet dans les contrôleurs et à d'autres endroits où les instances d'objet doivent être utilisées. Laravel analysera automatiquement les dépendances et injectera des objets pendant l'exécution.
3. Passer les paramètres : vous pouvez utiliser des paramètres pour transmettre des objets dépendants pendant le processus de création d'objet.
4. Dépendances héritées : l'héritage peut être utilisé pour simplifier le code d'injection de dépendances.

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!