Laravel-Di-Inversionsprinzip

Laravel ist ein sehr beliebtes PHP-Framework, das aufgrund seiner Einfachheit, Eleganz und Benutzerfreundlichkeit bei Entwicklern sehr beliebt ist. Tatsächlich ist eine wichtige Funktion des Laravel-Frameworks die Abhängigkeitsinjektion (DI) und die Umkehrung der Kontrolle (IoC), die Laravel eleganter und einfacher bei der Handhabung von Anwendungsabhängigkeiten macht. In diesem Artikel werden wir uns eingehend mit den DI- und Inversionsprinzipien von Laravel befassen.

1. Was ist Abhängigkeitsinjektion?

In einer Anwendung ist eine Klasse normalerweise auf eine andere Klasse oder ein anderes Objekt angewiesen, um ihre Aufgabe zu erledigen. In herkömmlichen Programmiermodellen instanziieren wir diese Abhängigkeiten normalerweise in Klassen. Obwohl dieser Ansatz einfach und klar ist, wird er die Klasse und ihre Abhängigkeiten eng miteinander verknüpfen.

Abhängigkeitsinjektion ist ein Entwurfsmuster, das eine Klasse von den Objekten trennt, von denen sie abhängt, und sie über Schnittstellen verbindet. Abhängigkeiten werden im Konstruktor an die Klasse übergeben, sodass die Klasse sie zur Laufzeit verwenden kann. Daher kann die Abhängigkeitsinjektion die Beziehung zwischen Anwendungen und Klassen flexibler und erweiterbarer machen.

2. Laravels Abhängigkeitsinjektion

Im Laravel-Framework wird die Abhängigkeitsinjektion durch Servicecontainer und Bindungen implementiert. Der Service-Container ist der Abhängigkeitsinjektionscontainer von Laravel, mit dem Sie Abhängigkeiten verwalten und injizieren können.

Binding ist das Binden einer Schnittstelle oder Klasse an eine Instanz im Service-Container. Sobald die Bindung abgeschlossen ist, können Sie den Container-Resolver verwenden, um diese Objekte aus dem Container zu instanziieren.

Im Laravel-Framework können Sie drei Bindungstypen verwenden: Bindungsinstanz, Bindungskontext, Bindungsschnittstelle oder abstrakte Klasse. Schauen wir sie uns einzeln an.

2.1 Bindungsinstanz

Die Verwendung einer Bindungsinstanz ist sehr nützlich, wenn Sie ein Objekt im Servicecontainer registrieren müssen. Diese Situation tritt normalerweise bei Controllern auf, weil wir dort viele verschiedene Objekte einfügen müssen.

Angenommen, wir haben eine TaskController-Klasse und müssen ein TaskRepository-Objekt zur Verarbeitung von Aufgaben einfügen:

class TaskController extends Controller 
{
    protected $taskRepository;

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

Wir können die Abhängigkeitsinjektion verwenden, um TaskRepository-Abhängigkeiten einzufügen. Dazu müssen wir eine Instanz von TaskRepository im Service-Container binden:

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

Im obigen Beispiel verwenden wir die $app-Instanz, um eine neue Instanz von TaskRepository zu erstellen und diese dann zurückzugeben. Sobald wir das TaskRepository an den Container binden, können wir es mithilfe des Konstruktors des TaskControllers in den Controller einfügen.

2.2 Bindungskontext

Der Bindungskontext ermöglicht es uns, eine Instanz einer Klasse im Service-Container zu binden. Wenn eine Klasse aufgelöst wird, versucht der Servicecontainer zunächst, die Klasse im Bindungskontext zu finden und fügt sie dann bei Bedarf ein.

Zum Beispiel können in unserer Anwendung mehrere TaskRepository-Objekte verwendet werden. Wenn wir sie alle in den Container binden, belegt jedes Objekt Speicherplatz und wenn wir das TaskRepository im Controller verwenden, gibt es keine Möglichkeit zu unterscheiden, welches Objekt verwendet wird.

Um dieses Problem zu lösen, können wir Kontextbindung verwenden. Dadurch können wir verschiedene TaskRepository-Instanzen an den Containerkontext binden und anhand des Schlüsselwerts unterscheiden, welche Instanz verwendet wird.

Zum Beispiel:

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

Im obigen Code verwenden wir die when()-Methode des Service-Containers. Diese Methode empfängt einen Klassennamen als Parameter, der angibt, welche Klasse es ist in Abhängigkeiten müssen in den Konstruktor eingefügt werden.

Die Methode „need()“ teilt dem Container mit, welche Abhängigkeit wir benötigen, während die Methode „give()“ tatsächlich die Instanz zurückgibt, die wir benötigen.

2.3 Schnittstellen oder abstrakte Klassen binden

In Laravel verwenden wir normalerweise Schnittstellen oder abstrakte Klassen, um externe Abhängigkeiten zu definieren. In der Anwendung binden wir diese Schnittstellen oder abstrakten Klassen an tatsächliche Implementierungsklassen. Dadurch können wir diese Abhängigkeiten in Controllern oder anderen Klassen verwenden, ohne uns um deren spezifische Implementierung kümmern zu müssen.

Zum Beispiel verfügen wir möglicherweise über eine TaskRepository-Schnittstelle, um einige Vorgänge für Aufgaben abzuwickeln. Wir können diese Schnittstelle an eine konkrete Klasse binden. Wenn wir auf diese Weise ein TaskRepository-Objekt im Controller benötigen, gibt der Servicecontainer automatisch eine Instanz davon zurück.

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

Im obigen Code binden wir die TaskRepository-Schnittstelle an eine konkrete Klasse namens TaskRepositoryImpl.

3. Inversion of Control

Bei der Abhängigkeitsinjektion ist Inversion of Control (IoC) ein sehr wichtiges Konzept. In herkömmlichen Programmiermodellen sind Entwickler typischerweise für die Erstellung von Objekten und die Auflösung von Abhängigkeiten zwischen Objekten verantwortlich. Das ist Kontrollfluss.

Bei der Inversionskontrolle wird der Steuerungsfluss umgekehrt. Die Anwendung ist nicht mehr für die Erstellung und Verwaltung von Objekten verantwortlich, stattdessen kümmert sich das Framework oder der Container um dieses Problem. Alle Abhängigkeiten werden vom Container verwaltet und nicht vom Entwickler verwaltet.

Der Vorteil der Inversionskontrolle besteht darin, dass sie die Kopplung im Code erheblich reduzieren und den Code flexibler und skalierbarer machen kann. Dies erleichtert das Testen und Warten unseres Codes.

4. Zusammenfassung

In diesem Artikel haben wir die Abhängigkeitsinjektion und die Umkehrung des Kontrollmechanismus des Laravel-Frameworks vorgestellt. Mithilfe dieser Mechanismen können wir unsere Anwendungen flexibler und skalierbarer machen, sodass sie einfacher zu testen und zu warten sind. Das Verständnis der DI- und Inversionsprinzipien von Laravel ist für Entwickler sehr hilfreich. Wenn Sie derzeit Laravel zum Entwickeln von Anwendungen verwenden, hoffen Sie, durch diesen Artikel ein allgemeines Verständnis von DI und Inversion zu erlangen.

Das obige ist der detaillierte Inhalt vonLaravel-Di-Inversionsprinzip. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!