Comment personnaliser la logique d'authentification des utilisateurs de Laravel?

Personnalisation La logique d'authentification de l'utilisateur de Laravel peut être implémentée via les étapes suivantes: 1. Ajoutez des conditions de vérification supplémentaires lors de la connexion, telles que la vérification des boîtes aux lettres. 2. Créez une classe de garde personnalisée pour étendre le processus d'authentification. La logique d'authentification personnalisée nécessite une compréhension approfondie du système d'authentification de Laravel et prêter attention à la sécurité, aux performances et à la maintenance.

La personnalisation de la logique d'authentification des utilisateurs de Laravel rend en fait votre application plus personnalisée et mieux s'adapter aux besoins spécifiques de l'entreprise. Il s'agit d'un processus amusant et difficile, car il vous oblige à avoir une compréhension approfondie du système de certification de Laravel, et vous oblige également à avoir une compréhension claire de votre logique commerciale.

Avant de commencer, réfléchissons à la raison pour laquelle nous devons personnaliser la logique d'authentification. Laravel fournit un système d'authentification très puissant, mais parfois nous devons faire des ajustements, comme l'ajout d'étapes d'authentification supplémentaires, à l'aide d'un modèle d'utilisateur personnalisé ou à intégrer des services d'authentification tiers. Ces exigences personnalisées nous font devoir modifier le processus de certification Laravel.

Tout d'abord, nous devons comprendre comment fonctionne le système de certification de Laravel. Laravel Guard Middleware AuthManager traiter les demandes Illuminate\Auth authentification, principalement via auth Middleware pour vérifier si l'utilisateur est connecté. Comprendre ces composants est la base de notre logique d'authentification personnalisée.

Commençons par un exemple simple, supposons que nous voulons vérifier les conditions supplémentaires lorsque l'utilisateur se connecte, tel que l'utilisateur a passé la vérification de la boîte aux lettres. Nous pouvons faire ceci:

 // app / http / contrôlers / auth / loginController.php

Namespace App \ Http \ Controllers \ Auth;

Utiliser illuminate \ http \ request;
Utilisez App \ Http \ Controllers \ Controller;
Utiliser illuminate \ support \ FACADES \ Auth;

Class LoginController étend le contrôleur
{
    Connexion de la fonction publique (demande $ demande)
    {
        $ indentings = $ request-> uniquement (['e-mail', 'mot de passe']);

        if (auth :: tentating ($ indentings)) {
            $ user = auth :: user ();
            if ($ user-> email_verified_at) {
                return redirect () -> destiné («tableau de bord»);
            } autre {
                Auth :: Logout ();
                return redirect () -> back () -> witherrors (['email' => 'Veuillez vérifier d'abord votre e-mail.']);
            }
        }

        return redirect () -> back () -> witherrors (['e-mail' => 'Ces informations d'identification ne correspondent pas à nos enregistrements.']);
    }
}

Dans cet exemple, nous vérifions le champ email_verified_at de l'utilisateur lors de la connexion. Si l'utilisateur ne transmet pas la vérification de la boîte aux lettres, nous les obligerons d'abord à vérifier la boîte aux lettres, puis à se connecter.

Si vous souhaitez aller plus loin et personnaliser l'intégralité du processus d'authentification, vous pouvez créer votre propre Guard . Cela vous oblige à avoir une compréhension plus profonde du système d'authentification de Laravel et peut avoir besoin de modifier le fichier config/auth.php pour configurer le nouveau garde d'authentification.

 // app / fournisseurs / authServiceProvider.php

Namespace App \ Providers;

Utiliser Illuminate \ Foundation \ Support \ Providers \ AuthServiceProvider comme ServiceProvider;
Utiliser illuminate \ support \ FACADES \ Auth;

Class AuthServiceProvider étend ServiceProvider
{
    Politiques $ protégées = [
        // Vos politiques ici
    ]]

    Boot de fonction publique ()
    {
        $ this-> regritsPolicies ();

        Auth :: Extend ('Custom', fonction ($ app, $ name, array $ config) {
            // Renvoie une implémentation d'illuminate \ contracts \ auth \ gard
            return new \ App \ Auth \ CustomGuard (Auth :: CreateUserProvider ($ config ['provider']));
        });
    }
}

Ensuite, vous devez implémenter CustomGuard , qui doit implémenter Illuminate\Contracts\Auth\Guard . Ce processus est plus compliqué car vous devez gérer la connexion, la déconnexion et la gestion de la session des utilisateurs.

 // app / auth / customguard.php

namespace app \ auth;

Utiliser illuminate \ contracts \ auth \ gard;
Utiliser Illuminate \ Contracts \ Auth \ UserProvider;
Utiliser illuminate \ http \ request;

classe CustomGuard implémente la garde
{
    demande de $ protégée;
    fournisseur de $ protégé;

    Fonction publique __construct (fournisseur UserProvider $, demande $ demande)
    {
        $ this-> request = $ request;
        $ this-> fournisseur = $ fournisseur;
    }

    vérification de la fonction publique ()
    {
        // Vérifiez si l'utilisateur est authentifié
        retour ! is_null ($ this-> user ());
    }

    Fonction publique invité ()
    {
        retour ! $ this-> check ();
    }

    Fonction publique User ()
    {
        // Récupérer l'utilisateur de la session ou de tout autre stockage
        // c'est un exemple simplifié
        $ id = $ this-> request-> session () -> get ('user_id');
        retourner $ this-> fournisseur-> récupérerById ($ id);
    }

    ID de fonction publique ()
    {
        $ user = $ this-> user ();
        retourner $ utilisateur? $ user-> getAuthIdentifier (): null;
    }

    Fonction publique Valider (Array $ Contalings = [])
    {
        // valider les informations d'identification de l'utilisateur
        $ user = $ this-> fournisseur-> récupéreryCredentials ($ indentings);
        return $ this-> hasher-> chèque ($ indentings ['mot de passe'], $ user-> getAuthPassword ());
    }

    SetUser de fonction publique ($ utilisateur)
    {
        // Définissez l'utilisateur dans la session ou tout autre stockage
        $ this-> request-> session () -> put ('user_id', $ user-> getAuthIdentifier ());
    }
}

Il y a des points à qui prêter attention lors de la mise en œuvre de la logique d'authentification personnalisée:

• Sécurité : la logique d'authentification personnalisée peut introduire des vulnérabilités de sécurité pour vous assurer de suivre les meilleures pratiques telles que l'utilisation de mots de passe hachés, la prévention de l'injection SQL, etc.
• Performances : l'authentification personnalisée peut affecter les performances de l'application, en particulier dans une concurrence élevée, en garantissant que votre implémentation est efficace.
• Maintenance : le code personnalisé nécessite une bonne documentation et des tests pour garantir la maintenance et les extensions futures.

Dans l'ensemble, la personnalisation de la logique d'authentification des utilisateurs de Laravel est un processus difficile mais aussi très précieux. Il vous permet d'ajuster le processus de certification en fonction de vos besoins, ce qui rend votre application plus flexible et puissante. Grâce aux exemples et suggestions ci-dessus, j'espère que vous pourrez aller plus loin sur la route de la logique d'authentification personnalisée.

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!