La raison de l'utilisation de l'injection de dépendance (DI) est qu'elle favorise le couplage lache, la testabilité et la maintenabilité du code. 1) Utiliser le constructeur pour injecter les dépendances, 2) éviter d'utiliser les localisateurs de services, 3) Utiliser les conteneurs d'injection de dépendance pour gérer les dépendances, 4) Améliorer la testabilité par l'injection des dépendances, 5) évitez les dépendances de sur-injection, 6) Considérez l'impact des performances de DI.

En ce qui concerne l'injection de dépendance (DI) en PHP, la question se pose souvent: pourquoi devrais-je les deux avec? Eh bien, l'injection de dépendance n'est pas seulement un mot à la mode sophistiqué; C'est un motif de conception puissant qui favorise le couplage, la testabilité et la maintenabilité de votre code. En utilisant DI, vous pouvez facilement échanger des dépendances, ce qui rend votre application plus flexible et plus facile à tester. Mais plongeons plus profondément dans le monde de DI en PHP et explorons certaines meilleures pratiques qui peuvent vraiment élever votre jeu de codage.

Parlons d'abord de l'essence de l'injection de dépendance. Imaginez que vous construisez une maison, et au lieu d'avoir tous les outils et matériaux fixés en permanence, vous avez un système où vous pouvez facilement échanger des outils ou changer de matériel en fonction de ce qui est nécessaire pour le moment. C'est ce que fait DI pour votre code. Il vous permet d'injecter des dépendances dans vos classes plut?t que de les avoir codées durs, ce qui rend votre code plus modulaire et adaptable.

Voici un exemple simple de la fa?on dont vous pourriez implémenter DI dans PHP:

 classe Logger {
    Journal des fonctions publiques ($ message) {
        Echo "Logging:". $ message. "\ n";
    }
}

class userservice {
    $ privé $ logger;

    Fonction publique __construct (logger $ logger) {
        $ this-> logger = $ logger;
    }

    Fonction publique RegisterUser ($ nom d'utilisateur) {
        $ this-> logger-> log ("Enregistrement utilisateur:". $ nom d'utilisateur);
        // Logique d'enregistrement des utilisateurs ici
    }
}

$ logger = new logger ();
$ userService = new UserService ($ logger);
$ userService-> registreUser ("John_Doe");

Dans cet exemple, UserService dépend de Logger , mais au lieu de créer une instance Logger dans UserService , il le re?oit via son constructeur. Cette approche rend UserService plus flexible car vous pouvez facilement éteindre l'enregistreur avec une implémentation différente si nécessaire.

Maintenant, explorons quelques meilleures pratiques pour mettre en ?uvre l'injection de dépendance en PHP qui vont au-delà des bases:

Utilisez l'injection de constructeur chaque fois que possible

L'injection de construction est le moyen le plus courant et recommandé d'injecter des dépendances. Il indique clairement les dépendances dont une classe a besoin dès le début. Voici comment vous pouvez affiner l'exemple précédent:

 class userservice {
    $ privé $ logger;

    Fonction publique __construct (LoggerInterface $ logger) {
        $ this-> logger = $ logger;
    }

    // ... reste de la classe
}

Interface LoggerInterface {
    Journal des fonctions publiques ($ message);
}

class ConsoleLogger implémente LoggerInterface {
    Journal des fonctions publiques ($ message) {
        Echo "Console:". $ message. "\ n";
    }
}

class FileLogger implémente LoggerInterface {
    Journal des fonctions publiques ($ message) {
        file_put_contents ('log.txt', $ message. "\ n", file_append);
    }
}

$ consolelogger = new Consolelogger ();
$ filelogger = new FileLogger ();

$ userServicewithConsole = new UserService ($ consolelogger);
$ userServicewithfile = new UserService ($ filelogger);

En utilisant une interface, LoggerInterface , vous découpez UserService à partir d'implémentations spécifiques du journaliste. Cette approche vous permet de basculer facilement entre différents mécanismes de journalisation sans modifier la classe de UserService .

évitez les localisateurs de services

Les localisateurs de services peuvent sembler un moyen pratique d'accéder aux dépendances, mais ils conduisent souvent à un code étroitement couplé et peuvent masquer les dépendances, ce qui rend votre code plus difficile à tester et à maintenir. Au lieu d'utiliser un localisateur de service, respectez l'injection explicite de dépendance. Voici un exemple de ce qu'il faut éviter:

 classe baduserservice {
    Fonction publique RegisterUser ($ nom d'utilisateur) {
        $ logger = Servicelocator :: getLogger ();
        $ logger-> log ("Enregistrement de l'utilisateur:". $ nom d'utilisateur);
        // Logique d'enregistrement des utilisateurs ici
    }
}

Cette approche rend plus difficile de voir les dépendances que BadUserService a, et elle peut entra?ner des problèmes lors des tests ou lorsque vous souhaitez changer l'enregistreur.

Tirer parti des conteneurs d'injection de dépendance

Pour les applications plus grandes, la gestion manuelle des dépendances peut devenir lourde. C'est là que les conteneurs d'injection de dépendance sont utiles. Ils vous aident à gérer et à cabler automatiquement vos dépendances. Les conteneurs PHP DI populaires incluent la composante de dépendance de Symfony et PHP-DI. Voici un rapide coup d'?il sur la fa?on dont vous pourriez utiliser PHP-DI:

 utiliser di \ conteneur;

$ conteneur = nouveau conteneur ();

$ conteneur-> set ('logger', function () {
    retourner un nouveau consolelogger ();
});

$ conteneur-> set ('user_service', fonction (conteneur $ c) {
    return newserService ($ c-> get ('logger'));
});

$ userService = $ conteneur-> get ('user_service');
$ userService-> registreUser ("John_Doe");

L'utilisation d'un conteneur DI peut simplifier considérablement votre gestion de votre dépendance, en particulier dans les grandes applications. Cependant, soyez prudent de ne pas utiliser les conteneurs, car ils peuvent introduire la complexité s'ils ne sont pas gérés correctement.

Testabilité et moquerie

L'un des plus grands avantages de la DI est l'amélioration de la testabilité. En injectant les dépendances, vous pouvez facilement les se moquer de les tests. Voici comment vous pourriez tester UserService à l'aide de phpunit et de moquerie:

 Utilisez phpunit \ framework \ testcase;
Utilisez phpUnit \ framework \ MockObject \ MockObject;

Classe UserServiceTest étend TestCase {
    fonction publique TestRegisterUser () {
        / ** @var loggerInterface | MockObject $ logger * /
        $ logger = $ this-> createMOCK (loggerInterface :: class);
        $ logger-> s'attend à ($ this-> une fois ())
            -> Méthode ('log')
           -> avec ('Enregistrement utilisateur: John_Doe');

        $ userService = new UserService ($ logger);
        $ userService-> registreUser ('John_Doe');
    }
}

Ce test garantit que la méthode log de l'enregistreur est appelée exactement une fois avec le message correct, sans rien enregistrer.

évitez trop d'injection

Bien que DI soit puissant, les dépendances excessives peuvent conduire à des classes trop complexes et difficiles à comprendre. Si une classe a trop de dépendances, cela pourrait être un signe que la classe fait trop et devrait être décomposée en classes plus petites et plus ciblées. Voici un exemple de ce qu'il faut éviter:

 class OverloadedService {
    $ privé $ logger;
    base de données privée $;
    $ privé Mailer;
    cache $ privé;
    // ... beaucoup plus de dépendances

    Fonction publique __construct (LoggerInterface $ Logger, base de données $ Base de données, Mailer $ Mailer, Cache $ cache, / * ... * /) {{
        $ this-> logger = $ logger;
        $ this-> base de données = $ la base de données;
        $ this-> Mailer = $ Mailer;
        $ this-> cache = $ cache;
        // ... beaucoup plus de missions
    }

    // ... méthodes utilisant toutes ces dépendances
}

Au lieu de cela, essayez de garder vos cours concentrés et n'injectez que ce qui est nécessaire.

Considérez l'impact des performances

Bien que DI améliore généralement la qualité du code, il peut avoir un léger impact sur les performances en raison de l'indirection supplémentaire. Dans la plupart des cas, cet impact est négligeable, mais dans les applications critiques de performance, vous voudrez peut-être mesurer l'impact du DI et envisager d'optimiser si nécessaire. Par exemple, vous pouvez mettre en cache des objets fréquemment utilisés ou utiliser un chargement paresseux pour les dépendances qui ne sont pas toujours nécessaires.

Conclusion

L'injection de dépendance en PHP est plus qu'une simple technique; C'est un état d'esprit qui favorise une meilleure conception de logiciels. En suivant ces meilleures pratiques, vous pouvez rendre votre code plus modulaire, testable et maintenable. N'oubliez pas que la clé est de garder vos classes concentrées, d'utiliser des interfaces pour définir les dépendances et de tirer parti des conteneurs DI pour des applications plus grandes. Et gardez toujours un ?il sur les performances, en vous assurant que votre utilisation de DI n'introdonne pas des frais généraux inutiles. Avec ces principes à l'esprit, vous serez sur le point d'écrire un code PHP plus propre et plus robuste.

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!