Projects [SHOW]

Authentication Quickstart

Laravel wird mit mehreren vorgefertigten Authentifizierungs-Controllern ausgeliefert, die sich im Namensraum App\Http\Controllers\Auth befinden. Der RegisterController kümmert sich um die Registrierung neuer Benutzer, der LoginController um die Authentifizierung, der ForgotPasswordController um E-Mail-Links zum Zurücksetzen von Passwörtern und der ResetPasswordController enthält die Logik zum Zurücksetzen von Passwörtern. Jeder dieser Controller verwendet eine Eigenschaft, um ihre notwendigen Methoden zu enthalten. Für viele Anwendungen müssen Sie diese Controller überhaupt nicht ändern.

Routing

Laravel bietet eine schnelle Möglichkeit, mit einem einfachen Befehl alle Routen und Ansichten einzurüsten, die Sie für die Authentifizierung benötigen:

php artisan make:auth

Dieser Befehl sollte bei neuen Anwendungen verwendet werden und installiert eine Layout-Ansicht, Registrierungs- und Anmeldeansichten sowie Routen für alle Authentifizierungs-Endpunkte. Ein HomeController wird auch generiert, um Post-Login-Anforderungen an das Dashboard Ihrer Anwendung zu bearbeiten.

Auth::routes(['register' => false]);

Views

Wie im vorherigen Abschnitt erwähnt, wird der php artisan make:auth Befehl alle Ansichten, die Sie für die Authentifizierung benötigen, erstellen und im Verzeichnis resources/views/auth ablegen.

Der make:auth Befehl wird auch ein resources/views/layout-Verzeichnis erstellen, das ein Basislayout für Ihre Anwendung enthält. Alle diese Views verwenden das Bootstrap CSS-Framework, aber Sie können sie nach Belieben anpassen.

Authenticating

Nun, da Sie die Routen und Ansichten für die enthaltenen Authentifizierungscontroller eingerichtet haben, können Sie neue Benutzer für Ihre Anwendung registrieren und authentifizieren! Sie können auf Ihre Anwendung in einem Browser zugreifen, da die Authentifizierungscontroller bereits die Logik (über ihre Eigenschaften) enthalten, um bestehende Benutzer zu authentifizieren und neue Benutzer in der Datenbank zu speichern.

Path Customization

Wenn ein Benutzer erfolgreich authentifiziert wird, wird er zur /home-URI umgeleitet. Sie können den Ort der Umleitung nach der Authentifizierung anpassen, indem Sie eine redirectTo-Eigenschaft auf dem LoginController, RegisterController, ResetPasswordController und VerificationController definieren:

protected $redirectTo = '/';

Als nächstes sollten Sie die Handle-Methode der RedirectIfAuthenticated-Middleware so ändern, dass bei der Umleitung des Benutzers Ihre neue URI verwendet wird.

Wenn der Umleitungspfad eine benutzerdefinierte Generierungslogik benötigt, können Sie eine RedirectTo-Methode anstelle einer RedirectTo-Eigenschaft definieren:

protected function redirectTo()
{
    return '/path';
}

Username Customization

Standardmäßig verwendet Laravel das email-Feld zur Authentifizierung. Wenn Sie dies anpassen möchten, können Sie eine username-Methode auf Ihrem LoginController definieren:

public function username()
{
    return 'username';
}

Guard Customization

Sie können auch den "Wächter" (guard) anpassen, der zur Authentifizierung und Registrierung von Benutzern verwendet wird. Um zu beginnen, definieren Sie eine guard-Methode auf Ihrem LoginController, RegisterController und ResetPasswordController. Die Methode sollte eine guard instance zurückgeben:

use Illuminate\Support\Facades\Auth;

protected function guard()
{
    return Auth::guard('guard-name');
}

Validation / Storage Customization

Um die Formularfelder zu ändern, die erforderlich sind, wenn sich ein neuer Benutzer in Ihrer Anwendung registriert, oder um anzupassen, wie neue Benutzer in Ihrer Datenbank gespeichert werden, können Sie die RegisterController-Klasse ändern. Diese Klasse ist für die Validierung und das Anlegen neuer Benutzer Ihrer Anwendung verantwortlich.

Die Validator-Methode des RegisterController enthält die Validierungsregeln für neue Benutzer der Anwendung. Es steht Ihnen frei, diese Methode nach Belieben zu modifizieren.

Die create-Methode des RegisterController ist verantwortlich für das Anlegen neuer App\User-Datensätze in Ihrer Datenbank mit Hilfe des Eloquent ORM. Es steht Ihnen frei, diese Methode entsprechend den Bedürfnissen Ihrer Datenbank zu modifizieren.

Retrieving The Authenticated User

Über die Auth-Fassade können Sie auf den authentifizierten Benutzer zugreifen:

use Illuminate\Support\Facades\Auth;

// Get the currently authenticated user...
$user = Auth::user();

// Get the currently authenticated user's ID...
$id = Auth::id();

Alternativ können Sie, sobald ein Benutzer authentifiziert ist, über eine Illuminate\Http\Request-Instanz auf den authentifizierten Benutzer zugreifen. Denken Sie daran, dass typgeprüfte Klassen automatisch in Ihre Controller-Methoden injiziert werden:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ProfileController extends Controller
{
    /**
     * Update the user's profile.
     *
     * @param  Request  $request
     * @return Response
     */
    public function update(Request $request)
    {
        // $request->user() returns an instance of the authenticated user...
    }
}

Determining If The Current User Is Authenticated

Um festzustellen, ob der Benutzer bereits in Ihrer Anwendung angemeldet ist, können Sie die check-Methode auf der Auth-Fassade verwenden, die bei der Authentifizierung des Benutzers den Wert true zurückgibt:

use Illuminate\Support\Facades\Auth;

if (Auth::check()) {
    // The user is logged in...
}

Protecting Routes

Route-Middleware kann verwendet werden, um nur authentifizierten Benutzern den Zugriff auf eine bestimmte Route zu ermöglichen. Laravel wird mit einer Auth-Middleware ausgeliefert, die unter Illuminate\Auth\Middleware\Authenticate definiert ist. Da diese Middleware bereits in Ihrem HTTP-Kernel registriert ist, müssen Sie die Middleware nur noch an eine Routendefinition anhängen:

Route::get('profile', function () {
    // Only authenticated users may enter...
})->middleware('auth');

Wenn Sie Controller verwenden, können Sie die Middleware-Methode aus dem Konstruktor des Controllers aufrufen, anstatt sie direkt in der Routendefinition anzuhängen:

public function __construct()
{
    $this->middleware('auth');
}

Redirecting Unauthenticated Users

Wenn die Auth-Middleware einen nicht autorisierten Benutzer erkennt, wird sie den Benutzer auf die Login-named Route umleiten. Sie können dieses Verhalten ändern, indem Sie die redirectTo-Funktion in Ihrer app/Http/Middleware/Authenticate.php-Datei aktualisieren:

/**
 * Get the path the user should be redirected to.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return string
 */
protected function redirectTo($request)
{
    return route('login');
}

Specifying A Guard

Wenn Sie die Auth-Middleware an eine Route anhängen, können Sie auch angeben, welcher Guard zur Authentifizierung des Benutzers verwendet werden soll. Der angegebene Guard sollte einem der Schlüssel im guards-Array deiner auth.php-Konfigurationsdatei entsprechen:

public function __construct()
{
    $this->middleware('auth:api');
}

Login Throttling

Wenn Sie Laravels eingebaute LoginController-Klasse verwenden, ist die Eigenschaft Illuminate\Foundation\Auth\ThrottlesLogins bereits in Ihrem Controller enthalten. Standardmäßig kann sich der Benutzer eine Minute lang nicht einloggen, wenn er nach mehreren Versuchen nicht die richtigen Zugangsdaten angibt. Die Drosselung ist eindeutig auf den Benutzernamen / die E-Mail-Adresse des Benutzers und seine IP-Adresse bezogen.

Manually Authenticating Users

Beachten Sie, dass Sie nicht verpflichtet sind, die mit Laravel mitgelieferten Authentifizierungs-Controller zu verwenden. Wenn Sie sich entscheiden, diese Controller zu entfernen, müssen Sie die Benutzerauthentifizierung direkt mit den Laravel-Authentifizierungsklassen verwalten. Keine Sorge, es ist ein Kinderspiel!

Wir werden auf die Authentifizierungsdienste von Laravel über die Auth-Fassade zugreifen, also müssen wir sicherstellen, dass die Auth-Fassade an der Spitze der Klasse importiert wird. Als nächstes sehen wir uns die attempt-Methode an:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    /**
     * Handle an authentication attempt.
     *
     * @param  \Illuminate\Http\Request $request
     *
     * @return Response
     */
    public function authenticate(Request $request)
    {
        $credentials = $request->only('email', 'password');

        if (Auth::attempt($credentials)) {
            // Authentication passed...
            return redirect()->intended('dashboard');
        }
    }
}

Die attempt-Methode akzeptiert ein Array von Schlüssel/Wert-Paaren als erstes Argument. Die Werte in dem Array werden verwendet, um den Benutzer in Ihrer Datenbanktabelle zu finden. Im obigen Beispiel wird der Benutzer also über den Wert der Spalte email ermittelt. Wenn der Benutzer gefunden wird, wird das in der Datenbank gespeicherte gehashte Passwort mit dem Passwortwert, der der Methode über das Array übergeben wurde, verglichen. Das als Passwortwert angegebene Passwort sollte nicht gehasht werden, da das Framework den Wert automatisch hasht, bevor er mit dem gehashten Passwort in der Datenbank verglichen wird. Wenn die beiden gehashten Passwörter übereinstimmen, wird eine authentifizierte Sitzung für den Benutzer gestartet.

Die attempt-Methode gibt bei erfolgreicher Authentifizierung true zurück. Andernfalls wird false zurückgegeben.

Die intended-Methode auf dem Redirector leitet den Benutzer zu der URL um, auf die er versucht hat zuzugreifen, bevor er von der Authentifizierungs-Middleware abgefangen wird. Dieser Methode kann eine Fallback-URI gegeben werden, falls das beabsichtigte Ziel nicht verfügbar ist.
 

Angeben zusätzlicher Bedingungen

Wenn Sie möchten, können Sie zusätzlich zur E-Mail und zum Passwort des Benutzers weitere Bedingungen in die Authentifizierungsabfrage aufnehmen. Zum Beispiel können wir überprüfen, ob der Benutzer als "aktiv" markiert ist:

if (Auth::attempt(['email' => $email, 'password' => $password, 'active' => 1])) {
    // The user is active, not suspended, and exists.
}

Accessing Specific Guard Instances

Welche guard-Instanz Sie verwenden möchten, können Sie mit der guard-Methode auf der Auth-Fassade festlegen. Damit können Sie die Authentifizierung für einzelne Teile Ihrer Anwendung über völlig getrennte authentifizierbare Modelle oder Benutzertabellen verwalten.

Der Name des Guard, der der Guard-Methode übergeben wird, sollte einem der in Ihrer Konfigurationsdatei auth.php konfigurierten Guards entsprechen:

if (Auth::guard('admin')->attempt($credentials)) {
    //
}

Logging Out

Um Benutzer aus Ihrer Anwendung abzumelden, können Sie die Logout-Methode auf der Auth-Fassade verwenden. Dadurch werden die Authentifizierungsinformationen in der Sitzung des Benutzers gelöscht:

Auth::logout();

Remembering Users

Wenn Sie in Ihrer Anwendung die "Merken Sie sich mich"-Funktionalität bereitstellen möchten, können Sie der attempt-Methode einen booleschen Wert als zweites Argument übergeben, der den Benutzer auf unbestimmte Zeit oder bis zur manuellen Abmeldung authentifiziert hält. Ihre Benutzertabelle muss die Spalte remember_token enthalten, in der das Token "remember me" gespeichert wird.

if (Auth::attempt(['email' => $email, 'password' => $password], $remember)) {
    // The user is being remembered...
}

Wenn Sie sich an Benutzer "erinnern", können Sie die viaRemember-Methode verwenden, um festzustellen, ob der Benutzer mit dem "remember me"-Cookie authentifiziert wurde:

if (Auth::viaRemember()) {
    //
}

Other Authentication Methods

Authenticate A User Instance

Wenn Sie eine bestehende Benutzerinstanz in Ihrer Anwendung anmelden müssen, können Sie die login-Methode mit der Benutzerinstanz aufrufen. Das angegebene Objekt muss eine Implementierung des Illuminate\Contracts\Auth\Authenticable contract sein. Das in Laravel enthaltene App\User Model implementiert diese Schnittstelle bereits:

Auth::login($user);

// Login and "remember" the given user...
Auth::login($user, true);

Sie können die Guard-Instance angeben, die Sie verwenden möchten:

Auth::guard('admin')->login($user);

Authenticate A User By ID

Um einen Benutzer mit seiner ID in die Anwendung einzuloggen, können Sie die Methode loginUsingId verwenden. Diese Methode akzeptiert den Primärschlüssel des Benutzers, den Sie authentifizieren möchten:

Auth::loginUsingId(1);

// Login and "remember" the given user...
Auth::loginUsingId(1, true);

Authenticate A User Once

Sie können die Methode "once" verwenden, um einen Benutzer für eine einzelne Anfrage in die Anwendung einzuloggen. Es werden keine Sessions oder Cookies verwendet, was bedeutet, dass diese Methode beim Aufbau einer zustandslosen API hilfreich sein kann:

if (Auth::once($credentials)) {
    //
}

HTTP Basic Authentication

Die HTTP-Basisauthentifizierung bietet eine schnelle Möglichkeit, Benutzer Ihrer Anwendung zu authentifizieren, ohne eine spezielle "Login"-Seite einzurichten. Um zu beginnen, fügen Sie die auth.basic-Middleware an Ihre Route an. Die auth.basic-Middleware ist im Laravel-Framework enthalten, so dass Sie sie nicht definieren müssen:

Route::get('profile', function () {
    // Only authenticated users may enter...
})->middleware('auth.basic');

Sobald die Middleware an die Route angeschlossen ist, werden Sie beim Zugriff auf die Route in Ihrem Browser automatisch zur Eingabe der Zugangsdaten aufgefordert. Standardmäßig verwendet die auth.basic-Middleware die email-Spalte des Benutzerdatensatzes als "Benutzername".

A Note On FastCGI

Wenn Sie PHP FastCGI verwenden, funktioniert die HTTP-Basic-Authentifizierung möglicherweise nicht korrekt. Die folgenden Zeilen sollten Ihrer .htaccess-Datei hinzugefügt werden:

RewriteCond %{HTTP:Authorization} ^(.+)$
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

Stateless HTTP Basic Authentication

Sie können die HTTP-Basis-Authentifizierung auch ohne das Setzen eines Benutzer-Identifikations-Cookies in der Sitzung verwenden, was besonders für die API-Authentifizierung nützlich ist. Definieren Sie dazu eine Middleware, die die Methode onceBasic aufruft. Wenn die onceBasic-Methode keine Antwort zurückgibt, kann der Request weiter an die Anwendung übergeben werden:

<?php

namespace App\Http\Middleware;

use Illuminate\Support\Facades\Auth;

class AuthenticateOnceWithBasicAuth
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, $next)
    {
        return Auth::onceBasic() ?: $next($request);
    }

}

Als nächstes registrieren Sie die Route-Middleware und fügen sie einer Route hinzu:

Route::get('api/user', function () {
    // Only authenticated users may enter...
})->middleware('auth.basic.once');

Logging Out

Um Benutzer manuell aus Ihrer Anwendung abzumelden, können Sie die Logout-Methode auf der Auth-Fassade verwenden. Dadurch werden die Authentifizierungsinformationen in der Sitzung des Benutzers gelöscht:

use Illuminate\Support\Facades\Auth;

Auth::logout();

Invalidating Sessions On Other Devices

Laravel bietet auch einen Mechanismus für die Ungültigkeitserklärung und "Ausloggen" der Sitzungen eines Benutzers, die auf anderen Geräten aktiv sind, ohne die Sitzung auf ihrem aktuellen Gerät zu ungültig zu machen. Bevor Sie anfangen, sollten Sie sicherstellen, dass die Illuminate\Session\Middleware\AuthenticateSession-Middleware in der Web-Middleware-Gruppe Ihrer app/Http/Kernel.php-Klasse vorhanden und unkommentiert ist:

'web' => [
    // ...
    \Illuminate\Session\Middleware\AuthenticateSession::class,
    // ...
],

Dann können Sie die Methode logoutOtherDevices auf der Auth-Fassade verwenden. Bei dieser Methode muss der Benutzer sein aktuelles Passwort angeben, das Ihre Anwendung über ein Eingabeformular akzeptieren sollte:

use Illuminate\Support\Facades\Auth;

Auth::logoutOtherDevices($password);

Adding Custom Guards

Mit der Extend-Methode auf der Auth-Fassade können Sie eigene Authentifizierungswächter definieren. Sie sollten diesen Aufruf zum Erweitern innerhalb eines Service Providers platzieren. Da Laravel bereits mit einem AuthServiceProvider ausgeliefert wird, können wir den Code in diesem Provider platzieren:

<?php

namespace App\Providers;

use App\Services\Auth\JwtGuard;
use Illuminate\Support\Facades\Auth;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;

class AuthServiceProvider extends ServiceProvider
{
    /**
     * Register any application authentication / authorization services.
     *
     * @return void
     */
    public function boot()
    {
        $this->registerPolicies();

        Auth::extend('jwt', function ($app, $name, array $config) {
            // Return an instance of Illuminate\Contracts\Auth\Guard...

            return new JwtGuard(Auth::createUserProvider($config['provider']));
        });
    }
}

Wie Sie im obigen Beispiel sehen können, sollte der an die extend-Methode übergebene Callback eine Implementierung von Illuminate\Contracts\Auth\Guard zurückgeben. Dieses Interface enthält einige Methoden, die Sie implementieren müssen, um einen benutzerdefinierten Wächter zu definieren. Sobald Ihr benutzerdefinierter Wächter definiert wurde, können Sie diesen Wächter in der guard-Konfiguration Ihrer auth.php-Konfigurationsdatei verwenden:

'guards' => [
    'api' => [
        'driver' => 'jwt',
        'provider' => 'users',
    ],
],

Closure Request Guards

Der einfachste Weg, ein benutzerdefiniertes, auf HTTP-Anfragen basierendes Authentifizierungssystem zu implementieren, ist die Verwendung der Auth::viaRequest-Methode. Diese Methode ermöglicht es Ihnen, Ihren Authentifizierungsprozess mit einem einzigen Closure schnell zu definieren.

Um zu beginnen, rufen Sie die Auth::viaRequest-Methode innerhalb der Boot-Methode Ihres AuthServiceProviders auf. Die viaRequest-Methode akzeptiert einen Authentifizierungstreiber als erstes Argument. Dieser Name kann eine beliebige Zeichenfolge sein, die Ihren benutzerdefinierten Wächter beschreibt. Das zweite Argument, das an die Methode übergeben wird, sollte ein Closure sein, der die eingehende HTTP-Anforderung empfängt und eine Benutzerinstanz zurückgibt oder, wenn die Authentifizierung fehlschlägt, null:

use App\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

/**
 * Register any application authentication / authorization services.
 *
 * @return void
 */
public function boot()
{
    $this->registerPolicies();

    Auth::viaRequest('custom-token', function ($request) {
        return User::where('token', $request->token)->first();
    });
}

Sobald Ihr benutzerdefinierter Authentifizierungstreiber definiert wurde, verwenden Sie ihn als Treiber innerhalb der guard-Konfiguration Ihrer auth.php-Konfigurationsdatei:

'guards' => [
    'api' => [
        'driver' => 'custom-token',
    ],
],

Adding Custom User Providers

Wenn Sie nicht eine traditionelle relationale Datenbank zur Speicherung Ihrer Benutzer verwenden, müssen Sie Laravel mit Ihrem eigenen Authentifizierungs-Benutzer-Provider erweitern. Wir werden die Provider-Methode auf der Auth-Fassade verwenden, um einen benutzerdefinierten Benutzer-Provider zu definieren:

<?php

namespace App\Providers;

use Illuminate\Support\Facades\Auth;
use App\Extensions\RiakUserProvider;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;

class AuthServiceProvider extends ServiceProvider
{
    /**
     * Register any application authentication / authorization services.
     *
     * @return void
     */
    public function boot()
    {
        $this->registerPolicies();

        Auth::provider('riak', function ($app, array $config) {
            // Return an instance of Illuminate\Contracts\Auth\UserProvider...

            return new RiakUserProvider($app->make('riak.connection'));
        });
    }
}

Nachdem Sie den Provider mit der Provider-Methode registriert haben, können Sie in Ihrer Konfigurationsdatei auth.php auf den neuen Benutzer-Provider wechseln. Definieren Sie zunächst einen Provider, der Ihren neuen Treiber verwendet:

'providers' => [
    'users' => [
        'driver' => 'riak',
    ],
],

Schließlich können Sie diesen Provider in Ihrer Guard-Konfiguration verwenden:

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
],

The User Provider Contract

Die Illuminate\Contracts\Auth\UserProvider-Implementierungen sind nur dafür zuständig, eine Illuminate\Contracts\Auth\Authenticable-Implementierung aus einem persistenten Speichersystem wie MySQL, Riak, etc. zu holen. Diese beiden Schnittstellen erlauben es, dass die Laravel-Authentifizierungsmechanismen weiterhin funktionieren, unabhängig davon, wie die Benutzerdaten gespeichert sind oder welche Art von Klasse sie repräsentieren.

Werfen wir einen Blick auf den Illuminate\Verträge\Auth\UserProvider-Vertrag:

<?php

namespace Illuminate\Contracts\Auth;

interface UserProvider {

    public function retrieveById($identifier);
    public function retrieveByToken($identifier, $token);
    public function updateRememberToken(Authenticatable $user, $token);
    public function retrieveByCredentials(array $credentials);
    public function validateCredentials(Authenticatable $user, array $credentials);

}

Die Funktion retrieveById erhält typischerweise einen Schlüssel, der den Benutzer repräsentiert, wie z.B. eine automatisch inkrementierende ID aus einer MySQL-Datenbank. Die Authenticatable-Implementierung, die mit der ID übereinstimmt, sollte von der Methode abgerufen und zurückgegeben werden.

Die Funktion retrieveByToken ruft einen Benutzer über seine eindeutige $identifier und das "remember me" $token ab, das in einem Feld remember_token gespeichert ist. Wie bei der vorherigen Methode sollte die Authenticatable-Implementierung zurückgegeben werden.

Die updateRememberToken-Methode aktualisiert das $user-Feld remember_token mit dem neuen $token. Ein neues Token wird bei einem erfolgreichen "remember me"-Anmeldeversuch oder beim Ausloggen des Benutzers zugewiesen.

Die Methode retrieveByCredentials empfängt das Array der Anmeldeinformationen, die beim Versuch, sich bei einer Anwendung anzumelden, an die Methode Auth::attempt übergeben werden. Die Methode sollte dann den zugrundeliegenden persistenten Speicher für den Benutzer, der diesen Anmeldeinformationen entspricht, "abfragen". Normalerweise führt diese Methode eine Abfrage mit einer "where"-Bedingung auf $credentials['username'] aus. Die Methode sollte dann eine Implementierung von Authenticatable zurückgeben. Diese Methode sollte nicht versuchen, eine Passwortvalidierung oder Authentifizierung durchzuführen.

Die validateCredentials-Methode sollte den angegebenen $user mit den $credentials vergleichen, um den Benutzer zu authentifizieren. Zum Beispiel sollte diese Methode wahrscheinlich Hash::check verwenden, um den Wert von $user->getAuthPassword() mit dem Wert von $credentials['password'] zu vergleichen. Diese Methode sollte true oder false zurückgeben und damit angeben, ob das Passwort gültig ist.

The Authenticatable Contract

Nachdem wir nun jede der Methoden auf dem UserProvider untersucht haben, werfen wir einen Blick auf den Authenticable-Vertrag. Denken Sie daran, dass der Provider Implementierungen dieses Interfaces aus den Methoden retrieveById, retrieveByToken und retrieveByCredentials zurückgeben sollte:

<?php

namespace Illuminate\Contracts\Auth;

interface Authenticatable {

    public function getAuthIdentifierName();
    public function getAuthIdentifier();
    public function getAuthPassword();
    public function getRememberToken();
    public function setRememberToken($value);
    public function getRememberTokenName();

}

Diese Schnittstelle ist einfach. Die Methode getAuthIdentifierName sollte den Namen des "Primärschlüssel"-Feldes des Benutzers zurückgeben und die Methode getAuthIdentifier sollte den "Primärschlüssel" des Benutzers zurückgeben. In einem MySQL-Backend wäre das wiederum der automatisch inkrementierende Primärschlüssel. Die getAuthPassword-Methode sollte das gehashte Passwort des Benutzers zurückgeben. Diese Schnittstelle erlaubt es dem Authentifizierungssystem, mit jeder Benutzerklasse zu arbeiten, unabhängig davon, welche ORM- oder Speicherabstraktionsschicht Sie benutzen. Standardmäßig enthält Laravel eine User-Klasse im app-Verzeichnis, die diese Schnittstelle implementiert, so dass Sie diese Klasse für ein Implementierungsbeispiel konsultieren können.

Events

Laravel wirft eine Vielzahl von Ereignissen während des Authentifizierungsprozesses auf. Sie können Listener an diese Ereignisse in Ihrem EventServiceProvider anhängen:

/**
 * The event listener mappings for the application.
 *
 * @var array
 */
protected $listen = [
    'Illuminate\Auth\Events\Registered' => [
        'App\Listeners\LogRegisteredUser',
    ],

    'Illuminate\Auth\Events\Attempting' => [
        'App\Listeners\LogAuthenticationAttempt',
    ],

    'Illuminate\Auth\Events\Authenticated' => [
        'App\Listeners\LogAuthenticated',
    ],

    'Illuminate\Auth\Events\Login' => [
        'App\Listeners\LogSuccessfulLogin',
    ],

    'Illuminate\Auth\Events\Failed' => [
        'App\Listeners\LogFailedLogin',
    ],

    'Illuminate\Auth\Events\Logout' => [
        'App\Listeners\LogSuccessfulLogout',
    ],

    'Illuminate\Auth\Events\Lockout' => [
        'App\Listeners\LogLockout',
    ],

    'Illuminate\Auth\Events\PasswordReset' => [
        'App\Listeners\LogPasswordReset',
    ],
];