Der Grund für die Verwendung der Abh?ngigkeitsinjektion (DI) ist, dass sie lose Kopplung, Testbarkeit und Wartbarkeit des Codes f?rdert. 1) Verwenden Sie den Konstruktor, um Abh?ngigkeiten zu injizieren.

Wenn es um die Abh?ngigkeitsinjektion (DI) in PHP geht, stellt sich h?ufig die Frage: Warum sollte ich beide damit mithalten? Nun, die Abh?ngigkeitsinjektion ist nicht nur ein ausgefallenes Schlagwort. Es ist ein leistungsstarkes Designmuster, das lose Kopplung, Testbarkeit und Wartbarkeit Ihres Codes f?rdert. Durch die Verwendung von DI k?nnen Sie die Abh?ngigkeiten problemlos austauschen und Ihre Anwendung flexibler und einfacher zu testen. Aber lassen Sie uns tiefer in die Welt der DI in PHP eintauchen und einige Best Practices erkunden, die Ihr Codierungsspiel wirklich erh?hen k?nnen.

Lassen Sie uns zuerst über die Essenz der Abh?ngigkeitsinjektion sprechen. Stellen Sie sich vor, Sie bauen ein Haus und anstatt alle Werkzeuge und Materialien dauerhaft zu reparieren, haben Sie ein System, in dem Sie leicht Werkzeuge austauschen oder Materialien ?ndern k?nnen, basierend auf dem, was derzeit ben?tigt wird. Das macht DI für Ihren Code. Es erm?glicht Ihnen, Abh?ngigkeiten in Ihre Klassen zu injizieren, anstatt sie hart codiert zu haben, wodurch Ihr Code modularer und anpassungsf?higer wird.

Hier ist ein einfaches Beispiel dafür, wie Sie DI in PHP implementieren k?nnen:

 Klassenlogger {
    ?ffentliches Funktionsprotokoll ($ message) {
        Echo "Protokollierung:". $ meldung. "\N";
    }
}

Klasse UserService {
    privater $ logger;

    ?ffentliche Funktion __construct (Logger $ logger) {
        $ this-> logger = $ logger;
    }

    ?ffentlicher Funktion RegisterUser ($ userername) {
        $ this-> logger-> log ("Benutzer registrieren:". $ userername);
        // Benutzerregistrierungslogik hier
    }
}

$ logger = new Logger ();
$ userService = new UserService ($ logger);
$ UserService-> RegisterUser ("John_doe");

In diesem Beispiel ist UserService auf Logger abh?ngig, aber anstatt eine Logger -Instanz in UserService zu erstellen, empf?ngt es sie über seinen Konstruktor. Dieser Ansatz macht UserService flexibler, da Sie den Logger bei Bedarf einfach mit einer anderen Implementierung ausschalten k?nnen.

Lassen Sie uns nun einige Best Practices für die Implementierung der Abh?ngigkeitsinjektion in PHP untersuchen, die über die Grundlagen hinausgehen:

Verwenden Sie nach M?glichkeit Konstruktorinjektion

Die Baueinspritzung ist die h?ufigste und empfohlene Art, Abh?ngigkeiten zu injizieren. Es macht deutlich, welche Abh?ngigkeiten eine Klasse von Anfang an richtig ben?tigt. So k?nnen Sie das vorherige Beispiel verfeinern:

 Klasse UserService {
    privater $ logger;

    ?ffentliche Funktion __construct (Loggerinterface $ logger) {
        $ this-> logger = $ logger;
    }

    // ... Rest der Klasse
}

Schnittstelle loggerinterface {
    ?ffentliches Funktionsprotokoll ($ message);
}

Klasse Consolelogger implementiert loggerinterface {
    ?ffentliches Funktionsprotokoll ($ message) {
        Echo "Konsole:". $ meldung. "\N";
    }
}

Class Filelogger implementiert loggerinterface {
    ?ffentliches Funktionsprotokoll ($ message) {
        Datei_put_Contents ('log.txt', $ message. "\ n", File_Append);
    }
}

$ consolelogger = new consolelogger ();
$ filelogger = neuer filelogger ();

$ UserServiceWithConsole = New UserService ($ consolelogger);
$ UserServiceWithFile = New UserService ($ filelogger);

Durch die Verwendung einer Schnittstelle, LoggerInterface , entkoppeln Sie UserService aus bestimmten Implementierungen des Protokolls. Mit diesem Ansatz k?nnen Sie einfach zwischen verschiedenen Protokollierungsmechanismen wechseln, ohne die UserService -Klasse zu ?ndern.

Vermeiden Sie Service -Locators

Service -Locators k?nnen als bequemer Weg erscheinen, um auf Abh?ngigkeiten zuzugreifen, aber sie führen h?ufig zu eng gekoppelten Code und k?nnen Abh?ngigkeiten verbergen, wodurch Ihr Code schwieriger zu testen und zu warten ist. Halten Sie sich an eine explizite Abh?ngigkeitsinjektion. Hier ist ein Beispiel dafür, was zu vermeiden ist:

 Klasse baduserService {
    ?ffentlicher Funktion RegisterUser ($ userername) {
        $ logger = servicelocator :: getLogger ();
        $ logger-> log ("Benutzer registrieren:". $ userername);
        // Benutzerregistrierungslogik hier
    }
}

Dieser Ansatz macht es schwieriger zu sehen, welche Abh?ngigkeiten BadUserService hat, und kann beim Testen zu Problemen führen oder wann Sie den Logger ausschalten m?chten.

Hebel -Abh?ngigkeitsinjektionsbeh?lter nutzen

Bei gr??eren Anwendungen kann manuelles Management von Abh?ngigkeiten umst?ndlich werden. Hier sind Abh?ngigkeitsinjektionsbeh?lter nützlich. Sie helfen Ihnen dabei, Ihre Abh?ngigkeiten automatisch zu verwalten und zu verkaufen. Zu den beliebten PHP-DI-Containern geh?ren die Abh?ngigkeitskomponente von Symfony und PHP-DI. Hier finden Sie einen kurzen Blick darauf, wie Sie PHP-DI verwenden k?nnten:

 Verwenden Sie di \ container;

$ container = neuer Container ();

$ container-> set ('logger', function () {
    Return New Consolelogger ();
});

$ container-> set ('user_service', function (container $ c) {
    Neue UserService zurückgeben ($ c-> get ('logger'));
});

$ userService = $ container-> get ('user_service');
$ UserService-> RegisterUser ("John_doe");

Die Verwendung eines DI -Containers kann Ihr Abh?ngigkeitsmanagement erheblich vereinfachen, insbesondere in gro?en Anwendungen. Seien Sie jedoch vorsichtig, wenn sie nicht zu überbeanspruchen, da sie Komplexit?t einführen k?nnen, wenn sie nicht ordnungsgem?? verwaltet werden.

Testbarkeit und Verspottung

Einer der gr??ten Vorteile von DI ist die Verbesserung der Testbarkeit. Durch die Injektion von Abh?ngigkeiten k?nnen Sie sie leicht in Ihren Tests verspotten. So testen Sie UserService mit Phpunit und Spott:

 Verwenden Sie Phpunit \ Framework \ TestCase;
Verwenden Sie Phpunit \ Framework \ MockObject \ MockObject;

Klasse userServicetest erweitert testCase {
    public function TestregisterUser () {
        /** @var loggerinterface | MockObject $ logger*/
        $ logger = $ this-> createMock (loggerinterface :: class);
        $ logger-> erwartet ($ this-> einmal ())
            -> Methode ('log')
           -> mit ('Benutzer registrieren: John_doe');

        $ userService = new UserService ($ logger);
        $ UserService-> RegisterUser ('John_doe');
    }
}

Dieser Test stellt sicher, dass die log des Loggers genau einmal mit der richtigen Nachricht aufgerufen wird, ohne tats?chlich etwas zu protokollieren.

Vermeiden Sie eine übereinstimmung

W?hrend DI leistungsstark ist, k?nnen überladende Abh?ngigkeiten zu Klassen führen, die zu komplex und schwer zu verstehen sind. Wenn eine Klasse zu viele Abh?ngigkeiten hat, ist dies m?glicherweise ein Zeichen dafür, dass die Klasse zu viel tut und in kleinere, fokussiertere Klassen unterteilt werden sollte. Hier ist ein Beispiel dafür, was zu vermeiden ist:

 Klassenüberladungspflicht {
    privater $ logger;
    private $ Datenbank;
    privat $ mailer;
    privat $ cache;
    // ... viele weitere Abh?ngigkeiten

    ?ffentliche Funktion __construct (Loggerinterface $ logger, Datenbank $ Datenbank, Mailer $ mailer, cache $ cache, / * ... * /) {
        $ this-> logger = $ logger;
        $ this-> database = $ Datenbank;
        $ this-> mailer = $ mailer;
        $ this-> cache = $ cache;
        // ... viele weitere Aufgaben
    }

    // ... Methoden mit all diesen Abh?ngigkeiten mit
}

Versuchen Sie stattdessen, Ihre Klassen fokussiert zu halten und nur das zu injizieren, was notwendig ist.

Betrachten Sie die Leistungsauswirkungen

W?hrend DI im Allgemeinen die Codequalit?t verbessert, kann es aufgrund der zus?tzlichen Indirektion eine leichte Leistungswirkung haben. In den meisten F?llen ist diese Auswirkung vernachl?ssigbar, aber in leistungskritischen Anwendungen m?chten Sie m?glicherweise die Auswirkungen von DI messen und bei Bedarf in Betracht ziehen. Beispielsweise k?nnen Sie h?ufig verwendete Objekte zwischenspeichern oder faulen Laden für Abh?ngigkeiten verwenden, die nicht immer ben?tigt werden.

Abschluss

Die Abh?ngigkeitsinjektion in PHP ist mehr als nur eine Technik. Es ist eine Denkweise, die ein besseres Softwaredesign f?rdert. Wenn Sie diesen Best Practices folgen, k?nnen Sie Ihren Code modularer, prüfbarer und wartbarer machen. Denken Sie daran, der Schlüssel ist, Ihre Klassen fokussiert zu halten, Schnittstellen zu verwenden, um Abh?ngigkeiten zu definieren und DI -Container für gr??ere Anwendungen zu nutzen. Und behalten Sie die Leistung immer im Auge und stellen Sie sicher, dass Ihre Verwendung von DI keinen unn?tigen Overhead einführt. Unter Berücksichtigung dieser Prinzipien sind Sie auf dem besten Weg, saubereren, robusteren PHP -Code zu schreiben.

Das obige ist der detaillierte Inhalt vonBest Practices für die Abh?ngigkeitsinjektion in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!