So erstellen Sie einen benutzerdefinierten Authentifizierungsschutz in Laravel

In diesem Artikel behandeln wir das Authentifizierungssystem im Laravel-Framework. Das Hauptziel dieses Artikels ist die Erstellung eines benutzerdefinierten Authentifizierungsschutzes durch Erweiterung des Kernauthentifizierungssystems.

Laravel bietet im Kern ein sehr solides Authentifizierungssystem, das die Implementierung der Basisauthentifizierung zum Kinderspiel macht. Sie müssen lediglich ein paar handwerkliche Befehle ausführen, um das Gerüst eines Authentifizierungssystems einzurichten.

Darüber hinaus ist das System selbst so konzipiert, dass Sie es erweitern und Ihre benutzerdefinierten Authentifizierungsadapter anschließen können. Darauf werden wir in diesem Artikel ausführlich eingehen. Bevor wir uns mit der Implementierung des benutzerdefinierten Authentifizierungsschutzes beschäftigen, beginnen wir mit einer Diskussion der grundlegenden Elemente der Laravel-Authentifizierungssystem-Guards und Provider.

Die Kernelemente: Guards und Providers

Das Laravel-Authentifizierungssystem besteht aus zwei Elementen bei den Kernwächtern und -anbietern.

Wachen

Sie können sich einen Guard vorstellen, um die Logik bereitzustellen, mit der die authentifizierten Benutzer identifiziert werden. Im Kern bietet Laravel verschiedene Wachen wie Sitzung und Token. Der Sitzungswächter behält den Status des Benutzers bei jeder Anforderung durch Cookies bei, und andererseits authentifiziert der Tokenwächter den Benutzer, indem er bei jeder Anforderung ein gültiges Token prüft.

Wie Sie sehen, definiert der Guard also die Logik der Authentifizierung, und es ist nicht notwendig, dass er sich immer damit befasst, indem er gültige Anmeldeinformationen vom Back-End abruft. Sie können einen Guard implementieren, der einfach das Vorhandensein einer bestimmten Sache in Anforderungsheadern überprüft und Benutzer auf dieser Grundlage authentifiziert.

Später in diesem Artikel implementieren wir einen Guard, der bestimmte JSON-Parameter in Anforderungsheadern überprüft und den gültigen Benutzer vom MongoDB-Back-End abruft.

Anbieter

Wenn der Guard die Logik der Authentifizierung definiert, ist der Authentifizierungsanbieter dafür verantwortlich, den Benutzer aus dem Back-End-Speicher abzurufen. Wenn der Guard verlangt, dass der Benutzer gegenüber dem Back-End-Speicher validiert werden muss, wird die Implementierung des Abrufens des Benutzers beim Authentifizierungsanbieter ausgeführt.

Laravel wird mit zwei Standardauthentifizierungsanbietern geliefert: Database und Eloquent. Der Anbieter für die Datenbankauthentifizierung befasst sich mit dem einfachen Abrufen der Benutzeranmeldeinformationen aus dem Back-End-Speicher, während Eloquent eine Abstraktionsebene bereitstellt, die das Notwendige tut.

In unserem Beispiel implementieren wir einen MongoDB-Authentifizierungsanbieter, der die Anmeldeinformationen des Benutzers aus dem MongoDB-Back-End abruft.

Das war also eine grundlegende Einführung in das Sicherheitssystem von Laravel. Ab dem nächsten Abschnitt konzentrieren wir uns auf die Entwicklung des benutzerdefinierten Authentifizierungsschutzes und -anbieters!

Ein kurzer Blick auf das Dateisetup

Werfen wir einen kurzen Blick auf die Liste der Dateien, die wir im Verlauf dieses Artikels implementieren werden.

config / auth.php: Dies ist die Authentifizierungskonfigurationsdatei, in der wir einen Eintrag unseres benutzerdefinierten Schutzes hinzufügen.
config / mongo.php: Diese Datei enthält die MongoDB-Konfiguration.
app / Dienste / Verträge / NosqlServiceInterface.php: Dies ist eine Schnittstelle, die von unserer benutzerdefinierten Mongo-Datenbankklasse implementiert wird.
app / Datenbank / MongoDatabase.php: Dies ist eine Hauptdatenbankklasse, die mit MongoDB interagiert.
app / Models / Auth / User.php: Es ist die Benutzermodellklasse, die den Vertrag "Authenticable" implementiert.
app / Erweiterungen / MongoUserProvider.php: Dies ist eine Implementierung des Authentifizierungsanbieters.
app / Dienste / Auth / JsonGuard.php: Dies ist eine Implementierung des Authentifizierungsschutztreibers.
app / Providers / AuthServiceProvider.php: Dies ist eine vorhandene Datei, die wir zum Hinzufügen unserer Service-Container-Bindungen verwenden.
app / http / controller / mongoController.php: Es ist eine Demo-Controller-Datei, die wir implementieren werden, um unseren benutzerdefinierten Schutz zu testen.

Machen Sie sich keine Sorgen, wenn die Liste der Dateien noch keinen Sinn ergibt, da wir im weiteren Verlauf alles ausführlich besprechen werden.

Eintauchen in die Implementierung

In diesem Abschnitt gehen wir die Implementierung der erforderlichen Dateien durch.

Das erste, was wir tun müssen, ist, Laravel über unseren Zollbeamten zu informieren. Fahren Sie fort und geben Sie die benutzerdefinierten Schutzdetails in die ein config / auth.php Datei wie gezeigt.

… 'Guards' => ['web' => ['driver' => 'session', 'provider' => 'users',], 'api' => ['driver' => 'token', 'provider '=>' Benutzer ',],' Benutzerdefiniert '=> [' Treiber '=>' Json ',' Provider '=>' Mongo ',],],…

Wie Sie sehen können, haben wir unsere benutzerdefinierte Schutzwache unter hinzugefügt Brauch Schlüssel.

Als nächstes müssen wir einen zugehörigen Provider-Eintrag in der Anbieter Sektion.

… 'Provider' => ['users' => ['driver' => 'eloquent', 'model' => App \ User :: class,], 'mongo' => ['driver' => 'mongo' ], // 'Benutzer' => [// 'Treiber' => 'Datenbank', // 'Tabelle' => 'Benutzer', //],],…

Wir haben unseren Anbietereintrag unter hinzugefügt Mongo Schlüssel.

Schließlich ändern wir den Standard-Authentifizierungsschutz von Web auf Benutzerdefiniert.

… 'Defaults' => ['guard' => 'custom', 'passwords' => 'Benutzer',],…

Natürlich funktioniert es noch nicht, da wir die erforderlichen Dateien noch nicht implementiert haben. Und das werden wir in den nächsten Abschnitten besprechen.

Richten Sie den MongoDB-Treiber ein

In diesem Abschnitt implementieren wir die erforderlichen Dateien, die mit der zugrunde liegenden MongoDB-Instanz kommunizieren.

Erstellen wir zunächst eine Konfigurationsdatei config / mongo.php das enthält die standardmäßigen MongoDB-Verbindungseinstellungen.

 ['host' => 'HOST_IP', 'port' => 'HOST_PORT', 'database' => 'DB_NAME']]];

Natürlich müssen Sie die Platzhalterwerte gemäß Ihren Einstellungen ändern.

Anstatt direkt eine Klasse zu erstellen, die mit MongoDB interagiert, erstellen wir zunächst eine Schnittstelle.

Der Vorteil der Erstellung einer Schnittstelle besteht darin, dass sie einen Vertrag bereitstellt, an den sich ein Entwickler bei der Implementierung halten muss. Außerdem kann unsere Implementierung von MongoDB bei Bedarf problemlos mit einer anderen NoSQL-Implementierung ausgetauscht werden.

Erstellen Sie eine Schnittstellendatei app / Dienste / Verträge / NosqlServiceInterface.php mit folgenden Inhalten.

Es ist eine ziemlich einfache Schnittstelle, die die grundlegenden CRUD-Methoden deklariert, die eine Klasse definieren muss, die diese Schnittstelle implementiert.
Nun definieren wir eine tatsächliche Klasse bei app / Datenbank / MongoDatabase.php.
Verbindung = neuer MongoClient ("mongodb: // $ host: $ port"); $ this-> database = $ this-> Verbindung -> $ database;  / ** * @see \ App \ Services \ Contracts \ NosqlServiceInterface :: find () * / public-Funktion find ($ collection, Array $ -Skriterium) return $ this-> database -> $ collection -> findOne ( $ kriterien);  public function create ($ collection, Array $ document)  Aktualisierung der öffentlichen Funktion ($ collection, $ id, Array $ document)  öffentliche Funktion delete ($ collection, $ id) 
Ich gehe natürlich davon aus, dass Sie MongoDB und die entsprechende PHP-Erweiterung von MongoDB installiert haben.
Das __konstruieren Methode instanziiert die MongoClient Klasse mit den erforderlichen Parametern. Die andere wichtige Methode, die uns interessiert, ist die finden method, die den Datensatz basierend auf den als Methodenargumenten bereitgestellten Kriterien abruft.
Das war also die Implementierung des MongoDB-Treibers, und ich versuchte, es so einfach wie möglich zu halten.
Richten Sie das Benutzermodell ein
Um die Standards des Authentifizierungssystems einzuhalten, müssen wir das Benutzermodell implementieren, das das implementieren muss Illuminate \ Contracts \ Auth \ Authenticatable Vertrag.
Fahren Sie fort und erstellen Sie eine Datei app / Models / Auth / User.php mit folgenden Inhalten.
conn = $ conn;  / ** * Benutzer über Berechtigungsnachweise abrufen * * @param array $ Berechtigungsnachweise * @return Illuminate \ Contracts \ Auth \ Authenticatable * / public-Funktion fetchUserByCredentials (Array $ credentials) Benutzer ', ["Benutzername" => $ Berechtigungsnachweise ["Benutzername"]]); if (! is_null ($ arr_user)) $ this-> Benutzername = $ arr_user ['Benutzername']; $ this-> password = $ arr_user ['password'];  $ this zurückgeben;  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getAuthIdentifierName () * / public function getAuthIdentifierName () return "Benutzername";  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getAuthIdentifier () * / public function getAuthIdentifier () return $ this -> $ this-> getAuthIdentifierName ();  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getAuthPassword () * / public function getAuthPassword () return $ this-> password;  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getRememberToken () * / public function getRememberToken () if (! empty ($ this-> getRememberTokenName ())) return $ this -> $ this-> getRememberTokenName ();  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: setRememberToken () * / public function setRememberToken ($ value) if (! empty ($ this-> getRememberTokenName ())) $ this -> $ this-> getRememberTokenName () = $ value;  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getRememberTokenName () * / public function getRememberTokenName () return $ this-> rememberTokenName; 
Das hättest du schon gemerkt App \ Models \ Auth \ User implementiert die Illuminate \ Contracts \ Auth \ Authenticatable Vertrag.
Die meisten in unserer Klasse implementierten Methoden sind selbsterklärend. Nachdem wir das gesagt haben, haben wir die definiert fetchUserByCredentials Methode, die den Benutzer aus dem verfügbaren Backend abruft. In unserem Fall ist es eine MongoDatabase Klasse, die aufgerufen wird, um die erforderlichen Informationen abzurufen.
Das ist also die Implementierung des Benutzermodells.
Richten Sie den Authentifizierungsanbieter ein
Wie bereits erwähnt, besteht das Laravel-Authentifizierungssystem aus zwei Element-Guards und Anbietern.
In diesem Abschnitt erstellen wir einen Authentifizierungsanbieter, der sich mit dem Benutzerabruf aus dem Backend befasst.
Fahren Sie fort und erstellen Sie eine Datei app / Erweiterungen / MongoUserProvider.php Wie nachfolgend dargestellt.
model = $ userModel;  / ** * Ruft einen Benutzer anhand der angegebenen Anmeldeinformationen ab. * * @param array $ credentials * @return \ Illuminate \ Contracts \ Auth \ Authenticatable | null * / public Funktion retrieveByCredentials (Array $ credentials) if (empty ($ credentials)) return;  $ user = $ this-> model-> fetchUserByCredentials (['username' => $ credentials ['username']]); $ Benutzer zurückgeben;  / ** * Überprüfe einen Benutzer anhand der angegebenen Anmeldeinformationen. * * @param \ Illuminate \ Contracts \ Auth \ Authenticatable $ user * @param array $ credentials Anforderungsdaten anfordern * @return bool * / public Funktion validateCredentials (Authenticatable $ user, Array $ credentials) == $ user-> getAuthIdentifier () && md5 ($ credentials ['password']) == $ user-> getAuthPassword ());  public function retrieveById ($ Bezeichner)  öffentliche Funktion retrieveByToken ($ Bezeichner, $ token)  öffentliche Funktion updateRememberToken (authentifizierbarer $ user, $ token) 
Auch hier müssen Sie sicherstellen, dass der benutzerdefinierte Anbieter das implementieren muss Illuminate \ Contracts \ Auth \ UserProvider Vertrag.
In der Zukunft werden zwei wichtige Methoden definiert: retrieveByCredentials und validateCredentials.
Das retrieveByCredentials Diese Methode wird verwendet, um die Benutzeranmeldeinformationen mithilfe der in dem vorherigen Abschnitt erörterten Benutzermodellklasse abzurufen. Auf der anderen Seite die validateCredentials Diese Methode wird verwendet, um einen Benutzer anhand der angegebenen Anmeldeinformationen zu überprüfen.
Und das war die Implementierung unseres benutzerdefinierten Authentifizierungsanbieters. Im nächsten Abschnitt erstellen wir einen Wachmann, der mit dem Wächter interagiert MongoUserProvider Authentifizierungsanbieter.
Richten Sie den Authentication Guard ein
Wie bereits erwähnt, gibt der Guard im Laravel-Authentifizierungssystem an, wie der Benutzer authentifiziert wird. In unserem Fall prüfen wir die Anwesenheit von jsondata Anforderungsparameter, der die JSON-codierte Zeichenfolge der Berechtigungsnachweise enthalten soll.
In diesem Abschnitt erstellen wir einen Guard, der mit dem Authentifizierungsanbieter interagiert, der im letzten Abschnitt erstellt wurde.
Fahren Sie fort und erstellen Sie eine Datei app / Dienste / Auth / JsonGuard.php mit folgenden Inhalten.
request = $ request; $ this-> provider = $ provider; $ this-> user = NULL;  / ** * Ermitteln Sie, ob der aktuelle Benutzer authentifiziert ist. * * @return bool * / public function check () return! is_null ($ this-> user ());  / ** * Bestimmen Sie, ob der aktuelle Benutzer ein Gast ist. * * @return bool * / public function guest () return! $ this-> check ();  / ** * Den aktuell authentifizierten Benutzer abrufen. * * @return \ Illuminate \ Contracts \ Auth \ Authenticatable | null * / public function user () if (! is_null ($ this-> user)) return $ this-> user;  / ** * Holen Sie sich die JSON-Parameter von der aktuellen Anfrage. * * @Return string * / public function getJsonParams () $ jsondata = $ this-> request-> query ('jsondata'); return (! empty ($ jsondata)? json_decode ($ jsondata, TRUE): NULL);  / ** * Ruft die ID des aktuell authentifizierten Benutzers ab. * * @return string | null * / public function id () if ($ user = $ this-> user ()) return $ this-> user () -> getAuthIdentifier ();  / ** * Überprüfen Sie die Anmeldeinformationen eines Benutzers. * * @return bool * / public function validate (Array $ credentials = []) if (leer ($ credentials ['username')) || leer ($ credentials ['password'])) if (! $ credentials.) = $ this-> getJsonParams ()) return false;  $ user = $ this-> provider-> retrieveByCredentials ($ credentials); if (! is_null ($ user) && $ this-> provider-> validateCredentials ($ user, $ credentials)) $ this-> setUser ($ user); wahr zurückgeben;  else return false;  / ** * Legt den aktuellen Benutzer fest. * * @param Array $ user Benutzerinfo * @return void * / public function setUser (authentifizierbarer $ user) $ this-> user = $ user; $ dieses zurückgeben; 
Zunächst muss unsere Klasse das implementieren Illuminate \ Contracts \ Auth \ Guard Schnittstelle. Daher müssen alle in dieser Schnittstelle deklarierten Methoden definiert werden.
Das Wichtigste dabei ist, dass das __konstruieren Funktion erfordert eine Implementierung von Illuminate \ Contracts \ Auth \ UserProvider. In unserem Fall übergeben wir eine Instanz von App \ Erweiterungen \ MongoUserProvider, wie wir später sehen werden.
Als nächstes gibt es eine Funktion getJsonParams Dadurch werden die Benutzeranmeldeinformationen aus dem genannten Anforderungsparameter abgerufen jsondata. Da erwartet wird, dass wir eine JSON-codierte Zeichenfolge der Benutzeranmeldeinformationen erhalten, haben wir die verwendet json_decode Funktion zum Dekodieren der JSON-Daten.
In der Validate-Funktion überprüfen wir zunächst die Existenz von $ Berechtigungsnachweise Streit. Wenn es nicht vorhanden ist, rufen wir die an getJsonParams Methode, um Benutzeranmeldeinformationen aus den Anforderungsparametern abzurufen.
Als nächstes rufen wir die retrieveByCredentials Methode der MongoUserProvider Provider, der den Benutzer aus dem Back-End der MongoDB-Datenbank abruft. Endlich ist es das validateCredentials Methode der MongoUserProvider Anbieter, der die Gültigkeit des Benutzers überprüft.
Das war also die Implementierung unseres Custom Guard. Im nächsten Abschnitt wird beschrieben, wie diese Teile zu einem erfolgreichen Authentifizierungssystem zusammengefügt werden.
Alles zusammenfügen
Bisher haben wir alle Elemente des benutzerdefinierten Authentifizierungsschutzes entwickelt, die uns ein neues Authentifizierungssystem bieten sollen. Es funktioniert jedoch nicht sofort, da wir es zuerst mithilfe der Laravel-Service-Containerbindungen registrieren müssen.
Wie Sie bereits wissen sollten, ist der Laravel-Dienstleister der richtige Ort, um die erforderlichen Bindungen zu implementieren.
Fahren Sie fort und öffnen Sie die Datei app / Providers / AuthServiceProvider.php Dadurch können wir Authentifizierungs-Service-Container-Bindungen hinzufügen. Wenn es keine benutzerdefinierten Änderungen enthält, können Sie es einfach durch die folgenden Inhalte ersetzen.
 "App \ Policies \ ModelPolicy",]; / ** * Registrieren Sie alle Authentifizierungs- / Autorisierungsdienste. * * @return void * / public function boot () $ this-> registerPolicies (); $ this-> app-> bind ('App \ Database \ MongoDatabase', Funktion ($ app) neue MongoDatabase zurückgeben (config ('mongo.defaults.host'), config ('mongo.defaults.port'), config ('mongo.defaults.database'));); $ this-> app-> bind ('App \ Models \ Auth \ User', Funktion ($ app) Neuen Benutzer zurückgeben ($ app-> make ('App \ Database \ MongoDatabase'));); // benutzerdefinierten Guard-Anbieter hinzufügen Auth :: provider ('mongo', function ($ app, array $ config) neuen MongoUserProvider zurückgeben ($ app-> make ('App \ Models \ Auth \ User'));; // benutzerdefinierten Schutz hinzufügen Auth :: extend ('json', Funktion ($ app, $ name, Array $ config) neuer JsonGuard (Auth :: createUserProvider ($ config ['provider'])), $ app-> make ("Anfrage")););  public function register () $ this-> app-> bind ('App \ Services \ Contracts \ NosqlServiceInterface', 'App \ Database \ MongoDatabase'); 
Lass uns durch gehen Stiefel Methode, die die meisten Anbieterbindungen enthält.
Zunächst erstellen wir Bindungen für die App \ Database \ MongoDatabase und App \ Models \ Auth \ User Elemente.
$ this-> app-> bind ('App \ Database \ MongoDatabase', Funktion ($ app) neue MongoDatabase zurückgeben (config ('mongo.defaults.host'), config ('mongo.defaults.port'), config ('mongo.defaults.database'));); $ this-> app-> bind ('App \ Models \ Auth \ User', Funktion ($ app) Neuen Benutzer zurückgeben ($ app-> make ('App \ Database \ MongoDatabase')););
Es ist eine Weile, dass wir über Anbieter und Wächter gesprochen haben, und es ist Zeit, unseren eigenen Wächter an das Laravel-Authentifizierungssystem anzuschließen.
Wir haben die Anbietermethode des verwendet Auth Fügen Sie unseren benutzerdefinierten Authentifizierungsanbieter unter dem Schlüssel hinzu Mongo. Denken Sie daran, dass der Schlüssel die Einstellungen widerspiegelt, die zuvor im hinzugefügt wurden auth.php Datei.
Auth :: provider ('mongo', Funktion ($ app, array $ config) neuen MongoUserProvider zurückgeben ($ app-> make ('App \ Models \ Auth \ User')););
Auf ähnliche Weise injizieren wir unsere Custom Guard-Implementierung mit der Erweiterungsmethode von Auth Fassade.
Auth :: extend ('json', Funktion ($ app, $ name, Array $ config) neuen JsonGuard zurückgeben (Auth :: createUserProvider ($ config ['provider'])), $ app-> make ('request') ;);
Als nächstes gibt es eine registrieren Methode, mit der wir die gebunden haben App \ Services \ Contracts \ NosqlServiceInterface Schnittstelle zum App \ Database \ MongoDatabase Implementierung.
$ this-> app-> bind ('App \ Services \ Contracts \ NosqlServiceInterface', 'App \ Database \ MongoDatabase');
Wann immer es also notwendig ist, das Problem zu lösen App \ Services \ Contracts \ NosqlServiceInterface Abhängigkeit, antwortet Laravel mit der Implementierung der App \ Database \ MongoDatabase Adapter.
Der Vorteil dieses Ansatzes besteht darin, dass die gegebene Implementierung leicht mit einer benutzerdefinierten Implementierung ausgetauscht werden kann. Nehmen wir einmal an, jemand möchte das ersetzen App \ Database \ MongoDatabase Implementierung mit dem CouchDB-Adapter in Zukunft. In diesem Fall müssen sie lediglich die entsprechende Bindung in der Registermethode hinzufügen.
Das war also der Dienstleister zu Ihrer Verfügung. In diesem Moment haben wir alles, um unsere Custom Guard-Implementierung zu testen, also geht es im nächsten und abschließenden Abschnitt darum.
Funktioniert es?
Sie haben all die harte Arbeit erledigt, um Ihren ersten benutzerdefinierten Authentifizierungswächter einzurichten, und jetzt ist es an der Zeit, die Vorteile auszunutzen, während wir fortfahren und es ausprobieren.
Lassen Sie uns schnell eine ziemlich einfache Controller-Datei implementieren app / http / controller / mongoController.php Wie nachfolgend dargestellt.
validate ()) // Liefert den aktuellen authentifizierten Benutzer $ user = $ auth_guard-> user (); Echo 'Erfolg!';  else echo 'Keine Berechtigung zum Zugriff auf diese Seite!'; 
Schauen Sie sich die Abhängigkeit der Anmeldemethode genau an, die die Implementierung der Illuminate \ Contracts \ Auth \ Guard bewachen. Da haben wir die eingestellt Brauch Wache als Standardwächter in der auth.php Datei, es ist die App \ Dienste \ Auth \ JsonGuard das wird eigentlich gespritzt!
Als nächstes haben wir das angerufen bestätigen Methode der App \ Dienste \ Auth \ JsonGuard Klasse, die wiederum eine Reihe von Methodenaufrufen auslöst:
 Es nennt das retrieveByCredentials Methode der App \ Erweiterungen \ MongoUserProvider Klasse.
 Das retrieveByCredentials Methode ruft die fetchUserByCredentials Methode des Benutzers App \ Models \ Auth \ User Klasse.
 Das fetchUserByCredentials Methode ruft die finden Methode der App \ Database \ MongoDatabase um die Benutzeranmeldeinformationen abzurufen.
 Endlich, das finden Methode der App \ Database \ MongoDatabase gibt die Antwort zurück!
 
Wenn alles wie erwartet funktioniert, sollten wir einen authentifizierten Benutzer erhalten, indem wir die Nutzer Methode unserer Wache.
Um auf den Controller zuzugreifen, sollten Sie eine verknüpfte Route in der hinzufügen routen / web.php Datei.
Route :: get ('/ custom / mongo / login', 'MongoController @ login');
Versuchen Sie, auf die URL http: // Ihre-Laravel-Site / custom / mongo / login zuzugreifen, ohne Parameter zu übergeben, und es sollte eine Meldung "nicht autorisiert" angezeigt werden.
Versuchen Sie auf der anderen Seite etwas wie http: // Ihre-Laravel-Site / custom / mongo / login? Jsondata = "username": "admin", "password": "admin" und dies sollte eine Erfolgsmeldung zurückgeben wenn der Benutzer in Ihrer Datenbank vorhanden ist.
Bitte beachten Sie, dass dies nur zu Beispielzwecken dient, um zu zeigen, wie der Custom Guard funktioniert. Sie sollten eine narrensichere Lösung für eine Funktion wie Login implementieren. Ich habe gerade einen Einblick in den Authentifizierungsfluss gegeben. Sie sind dafür verantwortlich, eine robuste und sichere Lösung für Ihre Anwendung zu entwickeln.
Damit ist unsere Reise heute zu Ende, und ich hoffe, ich komme mit mehr nützlichen Sachen zurück. Wenn Sie möchten, dass ich zu bestimmten Themen schreibe, vergessen Sie nicht, mir eine Zeile zu schreiben!
Fazit
Das Laravel-Framework bietet im Kern ein solides Authentifizierungssystem, das erweitert werden kann, wenn Sie ein benutzerdefiniertes implementieren möchten. Das war das Thema des heutigen Artikels, um einen benutzerdefinierten Schutz zu implementieren und ihn in den Laravel-Authentifizierungsworkflow einzubinden.
Im Zuge dessen haben wir ein System entwickelt, das den Benutzer anhand der JSON-Nutzdaten in der Anforderung authentifiziert und der MongoDB-Datenbank zuordnet. Um dies zu erreichen, haben wir am Ende einen benutzerdefinierten Guard und eine Implementierung eines benutzerdefinierten Providers erstellt.
Ich hoffe, die Übung hat Ihnen einen Einblick in den Laravel-Authentifizierungsablauf verschafft, und Sie sollten sich jetzt sicherer mit dem inneren Ablauf befassen.
Für diejenigen unter Ihnen, die entweder gerade mit Laravel beginnen oder Ihr Wissen, Ihre Site oder Anwendung mit Erweiterungen erweitern möchten, haben wir eine Reihe von Dingen, die Sie auf dem Envato-Markt studieren können.
Ich würde mich freuen, Ihre Rückmeldungen und Vorschläge zu hören!




		
			
	   
	




Code