Pourquoi PHP utilise-t-il l'injection de dépendances ?

Étant donné que l'injection de dépendance réduira le couplage entre la dépendance et le type dépendant, lors de la modification de l'implémentation du type dépendant, il n'est pas nécessaire de modifier l'implémentation du type dépendant en même temps, il peut être plus pratique de le faire ; utilisation pour les tests de type dépendant "Objet moqueur" remplace le type dépendant d'origine pour atteindre l'objectif de tests unitaires indépendants des objets dépendants.

0 Introduction

Dans le domaine du génie logiciel, l'injection de dépendances (Dependency Injection) est utilisée pour mettre en œuvre retour de contrôle. L’un des moyens les plus courants d’inversion de contrôle. Cet article présente principalement les principes et les méthodes de mise en œuvre courantes de l'injection de dépendances, en se concentrant sur les scénarios applicables et les avantages de ce jeune modèle de conception.

1. Pourquoi l'injection de dépendances est-elle nécessaire

L'inversion de contrôle est utilisée pour le découplage ? C'est la première question que je me suis posée lorsque j'ai découvert l'injection de dépendances.

Ci-dessous, je cite une partie du code utilisé par Martin Flower pour expliquer l'injection pour illustrer ce problème.

public class MovieLister {
    private MovieFinder finder;

    public MovieLister() {
        finder = new MovieFinderImpl();
    }
    
    public Movie[] moviesDirectedBy(String arg) {
        List allMovies = finder.findAll();
        for (Iterator it = allMovies.iterator(); it.hasNext();) {
            Movie movie = (Movie) it.next();
            if (!movie.getDirector().equals(arg)) it.remove();
        }
        return (Movie[]) allMovies.toArray(new Movie[allMovies.size()]);
    }
    ...
}

rrree

Nous avons créé une classe nommée MovieLister pour fournir la liste de films requise, et sa méthode moviesDirectedBy fournit un moyen de rechercher des films en fonction des noms de réalisateurs. Ce qui est réellement responsable de la recherche de films est MovieFinderImpl, qui implémente l'interface MovieFinder. Notre classe MovieLister crée un objet MovieFinderImpl dans le constructeur.

Jusqu’à présent, tout semble bien. Cependant, lorsque nous souhaitons modifier le Finder et le remplacer par une nouvelle implémentation (comme l'ajout d'un paramètre à MovieFinder pour indiquer de quelle base de données proviennent les données du film), nous devons non seulement modifier la classe MovieFinderImpl, mais également modifier le MovieFinderImpl créé dans notre code MovieLister.

C'est le couplage que traite l'injection de dépendances. Cette façon de créer MovieFinderImpl dans MovieLister fait que MovieLister s'appuie non seulement sur l'interface MovieFinder, mais également sur l'implémentation de MovieListImpl. Ce type de code qui crée directement des objets d'une autre classe dans une classe, comme des chaînes codées en dur et des nombres codés en dur (nombres magiques), est une mauvaise odeur qui conduit au couplage. On peut dire que la mauvaise odeur est appelée hard init. . Dans le même temps, nous devons également nous rappeler, comme le codage en dur, que le nouveau (la création d'objets) est un poison.

Les principaux inconvénients apportés par Hard Init sont deux aspects : 1) Lors de la modification de son implémentation comme mentionné ci-dessus, vous devez modifier le code où il a été créé 2) Il n'est pas facile à tester, ainsi que les classes ; créé de cette manière (ci-dessus) MovieLister dans cet article) ne peut pas être testé seul, et son comportement est étroitement couplé à MovieFinderImpl. En même temps, cela entraînera également des problèmes de lisibilité du code ("Si un morceau de code n'est pas facile à tester. , alors il ne doit pas être facile à lire.")

2. Comment implémenter l'injection de dépendances

L'injection de dépendances n'est en fait pas magique L'injection de dépendances est utilisée dans beaucoup de nos codes quotidiens, mais nous le remarquons rarement. et utilisent rarement activement l'injection de dépendances pour le découplage. Nous présentons ici brièvement les trois façons de réaliser l’injection de dépendances.

2.1 Injection de constructeur

C'est la méthode d'injection de dépendances la plus simple à mon avis. Modifions le constructeur de MovieList dans le code ci-dessus pour que l'implémentation de MovieFinderImpl soit dans la classe MovieLister créée à l'extérieur. De cette façon, MovieLister dépend uniquement de l'interface MovieFinder que nous avons définie, et non de l'implémentation de MovieFinder.

public interface MovieFinder {
    List findAll();
}

2.2 Injection Setter

De même, nous pouvons ajouter une fonction setter pour transmettre l'objet MovieFinder créé, ce qui peut également éviter une initialisation matérielle de cet objet dans MovieFinder.

public class MovieLister {
    private MovieFinder finder;

    public MovieLister(MovieFinder finder) {
        this.finder = finder;
    }
    ...
}

2.3 Injection d'interface

L'injection d'interface utilise l'interface pour fournir la méthode setter, et son implémentation est la suivante.

Créez d’abord une interface pour l’injection.

public class MovieLister {
    s...
    public void setFinder(MovieFinder finder) {
        this.finder = finder;
    }
}

Après cela, nous avons laissé MovieLister implémenter cette interface.

public interface InjectFinder {
    void injectFinder(MovieFinder finder);
}

Enfin, nous devons créer des implémentations MovieFinder dépendantes selon différents frameworks.

3. Enfin

L'injection de dépendances réduit le couplage entre les dépendances et les types dépendants. Lors de la modification de l'implémentation du type dépendant, il n'est pas nécessaire de modifier l'implémentation de. le type dépendant , en même temps, pour les tests de type dépendant, il est plus pratique d'utiliser un objet moqueur pour remplacer le type dépendant d'origine, afin d'atteindre l'objectif de tests unitaires indépendants des objets dépendants.

Enfin, il convient de noter que l'injection de dépendances n'est qu'un moyen de mettre en œuvre l'inversion de contrôle. Une autre implémentation courante de l’inversion de contrôle est appelée recherche 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!