Récupérer les utilisateurs vérifiés

• Protection du chemin
  • Restrictions de connexion
• Vérifier manuellement l'utilisateur
  • Mémoriser l'utilisateur
  • Autres méthodes d'authentification
  Authentification de base HTTP
  Authentification de base HTTP sans état
  • Déconnexion
Sessions invalides pour d'autres appareils
• • Authentification sociale
  • Ajouter une protection personnalisée
Fermer la protection des demandes
• • Ajouter un fournisseur d'utilisateurs personnalisé
Contrat Utilisateur Fournisseur
• Contrat Certifiable
Événements

• • Citations

    {tip} Vous voulez commencer rapidement ? Exécutez simplement php artisan make:auth et php artisan migrate dans une nouvelle application Laravel. Ensuite, accédez à votre navigateur jusqu'à http://your-app.test/register ou à toute autre URL attribuée à votre application. Ces deux commandes seront chargées de construire l’intégralité du système d’authentification ! php artisan make:auth 和 php artisan migrate 就可以了。 然后，把你的浏览器导航到 http://your-app.test/register 或者其他任意一个分配给你的程序的 URL。这两个命令将负责构建整个认证系统！

    Laravel 使得实现身份验证非常简单。 事实上，几乎所有的配置都是现成的。 身份验证配置文件位于 config/auth.php， 其中包含几个有良好文档记录的选项，用于调整身份验证服务的行为。

    在其核心，Laravel 的认证设施由 “警卫” 和 “提供者” 组成。守卫决定如何对每个请求的用户进行身份验证。比如，Laravel 带有一个 session 保护，它使用会话存储和 Cookies 来维护状态。

    提供者决定如何从持久储存中检索用户。 Laravel 支持使用 Eloquent 和数据库查询生成器检索用户。但是，你可以根据应用程序的需要来自由定义其他提供者。

    如果这些听起来让你很困惑，别担心！许多应用程序永远不需要修改默认的身份验证配置。

    数据库注意事项

    默认情况下， Laravel 包含一个 AppUser Eloquent model 在你的 app 目录下。 这个模型可与默认的 Eloquent 身份验证驱动程序一起使用。如果你的应用程序没有使用 Eloquent，你可以用 database 身份验证驱动程序，它用的是 Laravel 查询生成器。

    当为 AppUser 模型生成数据库架构时，确保密码的长度至少为 60 个字符。保持默认的字符串长度为 255 个字符是一个不错的选择。

    另外，你应该验证 “users”（或等效）表是否包含一个可空的，含有 100 个字符的 remember_token 字符串。此列将用于存储用户登录应用程序时选择 “记住我” 选项的令牌。

    用户认证快速指南

    Laravel 附带了几个预构建的身份验证控制器，它们位于 AppHttpControllersAuth 命名空间中。RegisterController 处理新的用户注册，LoginController 处理身份验证，ForgotPasswordController 处理用于重置密码的电子邮件链接，ResetPasswordController

    Laravel rend la mise en œuvre de l'authentification très simple. En fait, presque toutes les configurations sont prêtes à l'emploi. Le fichier de configuration d'authentification se trouve dans config/auth.php et contient plusieurs options bien documentées pour ajuster le comportement du service d'authentification.

    À la base, la fonction d'authentification de Laravel se compose de « Gardes » et de « Fournisseurs ». Le gardien décide comment authentifier l'utilisateur pour chaque demande. Par exemple, Laravel est livré avec un garde session, qui utilise le stockage de session et les cookies pour maintenir l'état.

    Le fournisseur décide comment récupérer l'utilisateur du stockage persistant. Laravel prend en charge la récupération d'utilisateurs à l'aide d'Eloquent et du générateur de requêtes de base de données. Cependant, vous êtes libre de définir d'autres prestataires en fonction des besoins de votre application.
    Si cela vous semble déroutant, ne vous inquiétez pas ! De nombreuses applications n'ont jamais besoin de modifier la configuration d'authentification par défaut. 🎜🎜🎜🎜
    🎜

    Considérations sur la base de données

    🎜Par défaut, Laravel inclut un < code>AppUser Le modèle Eloquent se trouve dans votre répertoire app. Ce modèle peut être utilisé avec le pilote d'authentification Eloquent par défaut. Si votre application n'utilise pas Eloquent, vous pouvez utiliser le pilote d'authentification database, qui utilise le générateur de requêtes Laravel. 🎜🎜Lors de la génération du schéma de base de données pour le modèle AppUser, assurez-vous que le mot de passe comporte au moins 60 caractères. Conserver la longueur de chaîne par défaut de 255 caractères est un bon choix. 🎜🎜De plus, vous devez vérifier que la table "users" (ou équivalent) contient une chaîne remember_token de 100 caractères nullable. Cette colonne sera utilisée pour stocker le jeton lorsque l'utilisateur sélectionne l'option « Se souvenir de moi » lors de sa connexion à l'application. 🎜🎜🎜🎜

    🎜🎜Guide rapide de l'authentification des utilisateurs🎜🎜Laravel est livré avec plusieurs contrôleurs d'authentification prédéfinis, ils sont situé dans l'espace de noms AppHttpControllersAuth. RegisterController gère l'enregistrement des nouveaux utilisateurs, LoginController gère l'authentification, ForgotPasswordController gère les liens de courrier électronique pour réinitialiser les mots de passe, ResetPasswordController Contient la logique pour réinitialiser les mots de passe. Chacun de ces contrôleurs utilise un attribut pour contenir les méthodes nécessaires. Pour de nombreuses applications, vous n'avez pas du tout besoin de modifier ces contrôleurs. 🎜🎜🎜🎜🎜🎜🎜

    Routing

    Laravel fournit un moyen rapide d'échafauder toutes les routes et vues nécessaires à l'authentification avec une simple commande :

    php artisan make:auth

    Cette commande doit être utilisée pour les nouvelles applications et installera les vues de mise en page, l'enregistrement, la vue de connexion et le routage pour tous. points de terminaison d’authentification. Un HomeController sera également généré pour gérer les demandes de post-connexion pour le tableau de bord de l'application. HomeController 来处理应用程序仪表板的登录后请求。

    {tip} 如果应用程序不需要注册，可以通过删除新创建的 RegisterController 并修改路由声明来禁用它： Auth::routes(['register' => false]);。

    视图

    如前一节所述， php artisan make:auth 命令将创建认证所需的所有视图，并将它们放在 resources/views/auth 目录中。

    make:auth 命令还将创建一个包含应用程序基本布局的 resources/views/layouts 目录。所有这些视图都使用了 Bootstrap CSS 框架，但是你可以自由地定制它们。

    认证

    现在已经给认证的控制器设置好了路由和视图，你可以在应用中注册和认证新用户了！因为控制器已经默认包含了验证用户是否存在和保存用户到数据库中的认证逻辑（通过 traits 实现的），现在你已经可以在浏览器中访问应用了。

    自定义路径

    当用户认证成功，他们会被重定向到 /home 这个 URI 下。你可以在 LoginController，RegisterController， ResetPasswordController，还有 VerificationController 控制器中定义 redirectTo 属性来自定义验证后的重定向位置：

    protected $redirectTo = '/';

    接下，你应该修改 RedirectIfAuthenticated 中间件中的 handle 方法，以便在重定向用户时重定向到新的 URI。

    如果重定向路径需要自定义生成逻辑，你可以定义 redirectTo 方法替代 redirectTo 属性：

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

    {提示}  redirectTo 方法优先于 redirectTo 属性。

    自定义用户名

    Laravel 默认使用 email 字段来认证。如果你想使用其他的字段，可以在 LoginController 控制器里面定义一个 username

    {tip} Si votre application ne nécessite pas d'enregistrement, vous pouvez la désactiver en supprimant le RegisterController nouvellement créé et en modifiant la déclaration de route : Auth::routes(['register ' = > faux]);.

    🎜

    🎜🎜Views🎜🎜Comme mentionné dans la section précédente, php artisan make:auth créera toutes les vues requises pour l'authentification et les placera dans le répertoire resources/views/auth. 🎜🎜La commande make:auth créera également un répertoire resources/views/layouts qui contient la présentation de base de l'application. Toutes ces vues utilisent le framework CSS Bootstrap, mais vous êtes libre de les personnaliser. 🎜🎜🎜

    🎜🎜Authentification🎜🎜Maintenant, le routage et la vue ont été configurés pour le contrôleur authentifié , vous pouvez enregistrer et authentifier de nouveaux utilisateurs dans l'application ! Étant donné que le contrôleur contient déjà une logique d'authentification par défaut pour vérifier que l'utilisateur existe et enregistrer l'utilisateur dans la base de données (implémenté via des traits), vous pouvez désormais accéder à l'application dans le navigateur. 🎜

    🎜

    Chemin personnalisé

    🎜Lorsque l'utilisateur est authentifié avec succès, il sera redirigé vers l'URI /home Vers le bas. Vous pouvez définir redirectToLoginController, RegisterController, ResetPasswordController et VerificationController. code> pour personnaliser l'emplacement de redirection après l'authentification : 🎜

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

    🎜 Ensuite, vous devez modifier la méthode handle dans le middleware RedirectIfAuthenticated pour rediriger l'utilisateur lors de la redirection Direct vers un nouvel URI . 🎜🎜Si le chemin de redirection nécessite une logique de génération personnalisée, vous pouvez définir la méthode redirectTo au lieu de l'attribut redirectTo : 🎜

    use Illuminate\Support\Facades\Auth;protected function guard(){ 
       return Auth::guard('guard-name');
     }

    🎜{Astuce} La méthode redirectTo prend priorité sur l'attribut redirectTo. 🎜

    🎜

    Nom d'utilisateur personnalisé

    🎜Laravel utilise le champ email pour l'authentification par défaut. Si vous souhaitez utiliser d'autres champs, vous pouvez définir une méthode username dans le contrôleur LoginController : 🎜

    use Illuminate\Support\Facades\Auth;
    // 获取当前通过认证的用户...
    $user = Auth::user();
    // 获取当前通过认证的用户 ID...
    $id = Auth::id();

    🎜🎜

    Observateur personnalisé

    Vous pouvez également personnaliser le « observateur » pour l'authentification et l'enregistrement des utilisateurs. Pour implémenter cette fonctionnalité, les méthodes guard doivent être définies dans LoginController, RegisterController et ResetPasswordController. Cette méthode renverra une instance de garde : LoginController,RegisterController 和 ResetPasswordController 中定义 guard 方法。该方法会返回一个看守器实例：

    <?php
       namespace App\Http\Controllers;
       use Illuminate\Http\Request;
       class ProfileController extends Controller{ 
        /**
         * 更新用户资料。
         *
         * @param  Request  $request
         * @return Response
         */  
       public function update(Request $request)  
         {       
          // $request->user() 返回一个认证用户实例...   
          }
      }

    自定义验证 / 存储

    为了修改新用户在注册时所需要填写的表单字段，或者自定义如何将新用户存储到数据库中，你可以修改  RegisterController 类。该类负责验证和创建新用户。

    RegisterController 类的 validator 方法包含了验证新用户的规则，你可以随心所欲地自定义该方法。

    RegisterController 的 create 方法负责使用  Eloquent ORM 在数据库中创建新的 AppUser 记录。你可以根据数据库的需要自定义该方法。

    检索认证用户

    你可以通过 Auth facade 来访问已认证的用户：

    use Illuminate\Support\Facades\Auth;
    if (Auth::check()) {   
     // 用户已经登录了...
    }

    或者，你可以通过 IlluminateHttpRequest 实例来访问已认证的用户。别忘了，类型提示的类会被自动注入到你的控制器方法中：

    Route::get('profile', function () {  
      // 只有认证过的用户可以进入...
     })->middleware('auth');

    确定当前用户是否已经认证

    你可以使用 Auth facade 的 check 方法来检查用户是否已认证。如果已认证，将会返回 true：

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

    {提示} 虽然可以使用 check 方法确认用户是否被认证，但是在允许用户访问的某些路由 / 控制器之前，通常还是会使用中间件来验证用户是否进行过身份验证。想要了解更多信息，请查看有关 保护路由 的文档。

    保护路由

    路由中间件 可以用于只允许通过认证的用户访问给定的路由。Laravel 自带了一个 auth 中间件，它定义在 IlluminateAuthMiddlewareAuthenticate 中。由于这个中间件已经在 HTTP 内核中注册，你只需把这个中间件附加到路由定义中：

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

    当然，如果你使用 控制器，你可以在控制器的构造函数中调用  middleware

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

    Validation/stockage personnalisé

    🎜Pour modifier les champs du formulaire que les nouveaux utilisateurs doivent remplir lors de leur inscription, ou Pour Pour personnaliser la façon dont les nouveaux utilisateurs sont stockés dans la base de données, vous pouvez modifier la classe RegisterController. Cette classe est responsable de la validation et de la création de nouveaux utilisateurs. 🎜🎜La méthode validator de la classe RegisterController contient les règles de validation des nouveaux utilisateurs. Vous pouvez personnaliser cette méthode à votre guise. La méthode create de 🎜🎜RegisterController est responsable de la création d'un nouvel enregistrement AppUser dans la base de données à l'aide d'Eloquent ORM. Vous pouvez personnaliser cette méthode en fonction des besoins de la base de données. 🎜🎜🎜

    🎜

    Récupérer l'utilisateur authentifié

    🎜Vous pouvez Accédez aux utilisateurs authentifiés via la façade Auth : 🎜

    <?php
        namespace App\Http\Controllers;
        use Illuminate\Http\Request;
        use Illuminate\Support\Facades\Auth;
        class LoginController extends Controller{  
         /**
         * 处理身份验证尝试。
         *
         * @param  \Illuminate\Http\Request $request
         *
         * @return Response
         */   
        public function authenticate(Request $request)   
         {       
            $credentials = $request->only('email', 'password');      
            if (Auth::attempt($credentials)) {        
                // 身份验证通过...           
               return redirect()->intended('dashboard');    
                 }   
               }
            }

    🎜 Alternativement, vous pouvez accéder aux utilisateurs authentifiés via une instance IlluminateHttpRequest. N'oubliez pas que la classe typée sera automatiquement injectée dans votre méthode de contrôleur : 🎜

    if (Auth::attempt(['email' => $email, 'password' => $password, 'active' => 1])) {  
      // 用户存在，已激活且未被禁用。
     }

    🎜🎜Pour déterminer si l'utilisateur actuel a été authentifié🎜🎜Vous peut utiliser La méthode check de la façade Auth vérifie si l'utilisateur a été authentifié. S'il est authentifié, true sera renvoyé : 🎜

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

    🎜{Tip} Bien que vous puissiez utiliser la méthode check pour confirmer si l'utilisateur est authentifié, mais lorsque l'utilisateur est autorisé à accéder à un Avant certaines routes/contrôleurs, il était courant d'utiliser encore un middleware pour vérifier que l'utilisateur était authentifié. Pour plus d’informations, consultez la documentation sur le routage protégé. 🎜

    🎜🎜

    🎜

    Protéger les routes

    🎜Le middleware de routage peut être utilisé pour permettre uniquement aux utilisateurs authentifiés d’accéder à un itinéraire donné. Laravel est livré avec un middleware auth, qui est défini dans IlluminateAuthMiddlewareAuthenticate. Puisque ce middleware est déjà enregistré dans le noyau HTTP, il vous suffit de joindre ce middleware à la définition de la route : 🎜

    Auth::logout();

    🎜 Bien sûr, si vous utilisez un contrôleur, vous pouvez appeler middleware< dans le constructeur /code> du contrôleur méthode pour l'ajouter directement à la définition de l'itinéraire : 🎜

    if (Auth::attempt(['email' => $email, 'password' => $password], $remember)) { 
       // 用户被记住...
    }

    🎜🎜

    Redirection des utilisateurs non authentifiés

    Lorsque le middleware auth détecte un utilisateur non authentifié, il redirigera l'utilisateur vers une route nommée nommée login.
    Vous pouvez modifier ce comportement en modifiant la fonction redirectTo dans le fichier app/Http/Middleware/Authenticate.php : auth 中间件检测到一个未认证用户时，它会把用户重定向到名为 login 的 命名路由上。
    您可以通过修改 app/Http/Middleware/Authenticate.php 文件中的 redirectTo 函数来修改此行为：

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

    指定看守器

    当你把 auth 中间件添加到路由中时，同时也能指定使用哪个看守器进行用户认证。指定的看守器应该对应 auth.php 配置文件中 guards 数组中的的一个键：

    Auth::login($user);
    // 登录并「记住」给定的用户...
    Auth::login($user, true);

    登录限流

    如果你使用 Laravel 内置的 LoginController 类，IlluminateFoundationAuthThrottlesLogins trait 已经包含在该控制器中了。默认情况下，如果用户多次尝试却无法提供正确的登录凭据，那么该用户在一分钟内将不能再次尝试登录。这种限流策略基于用户的用户名 / 邮箱地址及其 IP 地址的唯一性。

    手动验证用户

    不一定非要在 Lavarel 中使用验证控制器。如果选择删除这些控制器，就需要直接使用 Lavarel 验证类。别担心，很容易！

    可以借助 Auth facade 访问 Laravel 服务，因此需要在类的开头导入  Auth 。下面来看看 attempt 方法：

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

    attempt 方法的每个参数是一个关联数组。数组值用于在数据库中查找用户。在上面的例子中，将通过 email 列的值查找用户。如果找到该用户，将用存储在数据库中的哈希密码与数组中的 password 值做比较。不需要对 password 做哈希运算，框架在与数据库中的哈希密码做比较前自动对此值做哈希运算。如果两个哈希值匹配，将为该用户建立验证通过的 session。

    如果验证成功， attempt 方法返回  true ，否则返回 false 。

    重定向中的 intended 方法将经由身份验证中间件将用户重定向到身份验证前截获的 URL 。如果预期目标不存在，可以为此方法指定一个回退 URI 。

    指定额外条件

    除了用户的电子邮件和密码之外，还可以向身份验证查询添加其他条件。例如， 我们可以验证用户是不是已经被标记为 「激活」：

    Auth::loginUsingId(1);
    // 登录并「记住」给定用户...
    Auth::loginUsingId(1, true);

    {note} 在这些例子中， email

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

    Spécifiez l'observateur

    Lorsque vous ajoutez le middleware auth à la route, vous pouvez également spécifier quel observateur utiliser pour l'authentification de l'utilisateur. La garde spécifiée doit correspondre à une clé du tableau guards dans le fichier de configuration auth.php : 🎜

    Route::get('profile', function () { 
       // 只有认证过的用户可以进入...
     })->middleware('auth.basic');

    🎜🎜

    🎜

    Limitation de connexion

    🎜Si vous utilisez la classe LoginController intégrée de Laravel, IlluminateFoundationAuthThrottlesLogins< Le trait /code> est déjà inclus dans ce contrôleur. Par défaut, si un utilisateur ne parvient pas à fournir les informations de connexion correctes après plusieurs tentatives, il ne pourra pas tenter de se reconnecter pendant une minute. Cette politique de limitation est basée sur le caractère unique du nom d'utilisateur/de l'adresse e-mail d'un utilisateur et de son adresse IP. 🎜🎜🎜

    🎜

    Authentifier manuellement les utilisateurs

    🎜Pas nécessairement dans Lavarel Utiliser la validation contrôleurs. Si vous choisissez de supprimer ces contrôleurs, vous devrez utiliser directement les classes de validation Lavarel. Ne vous inquiétez pas, c'est facile ! 🎜🎜Vous pouvez accéder au service Laravel à l'aide de la façade Auth, vous devez donc importer Auth au début du cours. Jetons un coup d'œil à la méthode attempt : 🎜

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

    🎜 Chaque paramètre de la méthode attempt est un tableau associatif. Les valeurs du tableau sont utilisées pour rechercher des utilisateurs dans la base de données. Dans l'exemple ci-dessus, l'utilisateur sera trouvé par la valeur de la colonne email. Si l'utilisateur est trouvé, le mot de passe haché stocké dans la base de données est comparé à la valeur password dans le tableau. Il n'est pas nécessaire de hacher le mot de passe, le framework hache automatiquement la valeur avant de la comparer au mot de passe haché dans la base de données. Si les deux hachages correspondent, une session authentifiée sera établie pour l'utilisateur. 🎜🎜Si la vérification réussit, la méthode attempt renvoie true, sinon elle renvoie false. 🎜🎜La méthode prévue en redirection redirigera l'utilisateur vers l'URL interceptée avant l'authentification via le middleware d'authentification. Si la cible attendue n'existe pas, vous pouvez spécifier un URI de secours pour cette méthode. 🎜

    🎜🎜Spécifier des conditions supplémentaires 🎜🎜En plus de l'e-mail et du mot de passe de l'utilisateur, vous pouvez ajouter des conditions supplémentaires à la requête d'authentification. Par exemple, nous pouvons vérifier que l'utilisateur a été marqué comme "activé" : 🎜

    <?php
      namespace App\Http\Middleware;
      use Illuminate\Support\Facades\Auth;
      class AuthenticateOnceWithBasicAuth{   
           /**
         * 处理传入的请求
         *
         * @param  \Illuminate\Http\Request  $request
         * @param  \Closure  $next
         * @return mixed
         */  
      public function handle($request, $next)  
        {       
           return Auth::onceBasic() ?: $next($request);  
         }
       }

    🎜{note} Dans ces exemples, email n'est pas une option obligatoire, c'est uniquement à des fins de démonstration . Vous devez utiliser des noms de colonnes qui correspondent au « nom d'utilisateur » dans votre base de données. 🎜🎜🎜🎜

    Accédez à l'instance de garde spécifiée

    Vous pouvez utiliser la méthode guard de la façade Auth pour spécifier l'instance de garde que vous souhaitez utiliser. Cela vous permet d'utiliser des modèles vérifiables ou des tables utilisateur totalement indépendants pour gérer la validation de différentes parties de votre application. Auth facade 的 guard 方法指定想要使用的看守器实例。这允许你使用完全独立的可验证模型或用户表来管理应用程序各个部分的验证。

    传递给 guard 方法的看守器名称需要与 auth.php 配置中的配置项之一相匹配：

    Route::get('api/user', function () {  
      // 只有认证过的用户可以进入...
    })->middleware('auth.basic.once');

    登出

    用户登出需要使用 Auth facade 的 logout 方法。它会清除用户会话（session）中的用户验证信息：

    use Illuminate\Support\Facades\Auth;Auth::logout();

    记住用户

    如果想在应用中提供 「记住我」功能，可以给 attempt 方法传递一个布尔值作为其第二个参数，这会无限期保持用户身份验证，直到用户手动登出。用户表需要包含字符串类型的 remember_token 列用于存储令牌。

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

    {tip} 如果使用了 Laravel 内置的 LoginController，「记住」用户的正确逻辑已经由控制器所用的 traits 实现。

    如果启用了「记住用户」，可以使用 viaRemember 方法判断是否使用了「记住我」cookie 对用户做身份验证：

    use Illuminate\Support\Facades\Auth;
    Auth::logoutOtherDevices($password);

    其它身份验证方法

    验证用户实例

    如果要将已经存在的用户登入应用，可以调用 login 方法，并以用户实例作为其参数 。该对象必须实现 IlluminateContractsAuthAuthenticatable 契约 。Laravel 自带的 AppUser 模型已经实现了这个接口：

    <?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{   
          /**
         * 注册任意应用认证／授权服务。
         *
         * @return void
         */   
      public function boot()  
       {      
         $this->registerPolicies();        
         Auth::extend('jwt', function ($app, $name, array $config) {         
           // 返回一个 Illuminate\Contracts\Auth\Guard 实例...           
            return new JwtGuard(Auth::createUserProvider($config['provider']));     
             });   
        }}

    使用如下方式指定想要的看守器实例：

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

    通过 ID 验证用户身份

    可以使用 loginUsingId 方法通过 ID 将用户登录到应用。这个方法接受希望验证身份用户的主键：

    use App\User;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Auth;
      /**
     * 注册任意应用认证／授权服务。
     *
     * @return void
     */
     public function boot(){  
       $this->registerPolicies();  
        Auth::viaRequest('custom-token', function ($request) {     
           return User::where('token', $request->token)->first();  
           });
         }

    仅验证一次用户身份

    可以使用 once

    Le nom de garde transmis à la méthode guard doit correspondre à l'un des éléments de configuration dans la configuration auth.php :

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

    Déconnexion

    Les utilisateurs doivent utiliser la méthode logout de la façade Auth pour se déconnecter. Il efface les informations d'authentification de l'utilisateur dans la session utilisateur :

    <?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) {         
                // 返回 Illuminate\Contracts\Auth\UserProvider 实例...            
                return new RiakUserProvider($app->make('riak.connection'));       
               });   
            }}

    🎜🎜🎜

    🎜

    Mémoriser l'utilisateur

    🎜Si vous souhaitez fournir la fonctionnalité "se souvenir de moi" dans votre application, vous pouvez transmettre une valeur booléenne à la méthode attempt comme deuxième paramètre, ce qui maintiendra l'utilisateur authentifié indéfiniment jusqu'à ce que l'utilisateur se connecte. manuellement. La table utilisateur doit contenir une colonne remember_token de type chaîne pour stocker le jeton. 🎜

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

    🎜{tip} Si vous utilisez le LoginController intégré de Laravel, la logique correcte pour "se souvenir" de l'utilisateur est déjà implémentée par les traits utilisés par le contrôleur. 🎜

    🎜Si « Se souvenir de l'utilisateur » est activé, vous pouvez utiliser la méthode viaRemember pour déterminer si le cookie « Se souvenir de moi » est utilisé pour authentifier l'utilisateur : 🎜

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

    🎜🎜🎜

    🎜

    Autres méthodes d'authentification

    🎜🎜Vérifier l'instance utilisateur🎜🎜Si vous souhaitez connecter un utilisateur existant à l'application, vous pouvez appeler la méthode login et utiliser l'instance utilisateur comme paramètre. L'objet doit implémenter le contrat IlluminateContractsAuthAuthenticatable . Le propre modèle AppUser de Laravel a implémenté cette interface : 🎜

    <?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);
         }

    🎜Spécifiez l'instance de garde souhaitée comme suit : 🎜

    <?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();
         }

    🎜🎜Vérifiez l'identité de l'utilisateur en ID🎜🎜Vous pouvez utiliser la méthode loginUsingId pour connecter l'utilisateur à l'application par ID. Cette méthode accepte la clé primaire de l'utilisateur que vous souhaitez authentifier : 🎜

    /**
     * 应用的事件监听器映射。
     *
     * @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',   
             ],
          ];

    🎜🎜Authentifier l'utilisateur une seule fois🎜🎜Vous pouvez utiliser le une fois méthode en un seul Connectez l’utilisateur à l’application pendant la demande. Cela n'utilisera pas de sessions ni de cookies, ce qui signifie que cette méthode permet de créer une API sans état : 🎜rrreee🎜🎜🎜🎜🎜🎜

    Authentification de base HTTP

    Authentification de base HTTP fournit un moyen rapide d'authentifier les utilisateurs de votre application sans configurer une page de « connexion » dédiée. Avant de commencer, attachez le middleware auth.basic à votre itinéraire. Le middleware auth.basic est déjà inclus dans le framework Laravel, vous n'avez donc pas besoin de le définir : auth.basic 中间件 附加到你的路由中。auth.basic 中间件已包含在 Laravel 框架中，所以你不需要定义它：

    rrreee

    将中间件附加到路由后，在浏览器中访问此路由时将自动提示您输入凭据。默认的，auth.basic 中间件把用户记录上的 email 字段 作为「用户名」。

    FastCGI 的注意事项

    如果你正使用 PHP FastCGI 模式，HTTP 基础认证可能无法正常工作。需要把下面几行添加到你的 .htaccess 文件中：

    rrreee

    无状态 HTTP 基础认证

    你也可以使用 HTTP 基础身份验证，而无需在会话中设置用户标识符 cookie，这对 API 的身份验证特别有用。为此 ，请定义一个中间件 它将调用 onceBasic 方法。如果 onceBasic 方法没有返回任何响应，那么请求就可以进一步传递到应用程序中：

    rrreee

    接着， 注册路由中间件 并将它附加到路由：

    rrreee

    退出

    要手动把用户从应用中退出登录，你可以使用 Auth facade 上的 logout 方法。这将清除用户会话中的身份认证信息：

    rrreee

    让其它设备上的 Session 失效

    Laravel 还提供了一种机制，用于将其它设备上的用户 Session 失效和「注销」，而不会使其当前设备上的 Session 失效。首先，你需要保证 IlluminateSessionMiddlewareAuthenticateSession 中间件在你的 app/Http/Kernel.php 类中的 web 中间件组中，并且没有被注释掉：

    rrreee

    然后， 你就可以使用 Auth facade 上的 logoutOtherDevices 方法。此方法要求用户提供其当前密码，你的应用程序应通过输入表单接受该密码：

    rrreee

    {note} 当调用 logoutOtherDevicesrrreee

    Après avoir attaché le middleware à une route, vous serez automatiquement invité à saisir une entrée lors de l'accès cet itinéraire dans les informations d'identification du navigateur. Par défaut, le middleware auth.basic utilise le champ email de l'enregistrement utilisateur comme « nom d'utilisateur ».

    Notes FastCGI

    Si vous utilisez le mode PHP FastCGI, l'authentification de base HTTP peut ne pas fonctionner correctement. Vous devez ajouter les lignes suivantes à votre fichier .htaccess : rrreee

    🎜

    Authentification HTTP de base sans état

    🎜Vous pouvez également utiliser l'authentification de base HTTP sans définir de cookie d'identification d'utilisateur dans la session, ce qui est particulièrement utile pour l'authentification API. Pour ce faire, définissez un middleware qui appelle la méthode onceBasic. Si la méthode onceBasic ne renvoie aucune réponse, la requête peut être transmise plus loin dans l'application : 🎜rrreee🎜 Ensuite, enregistrez le middleware de routage et attachez-le à la route : 🎜rrreee🎜🎜🎜

    🎜🎜Déconnexion🎜🎜Pour déconnecter manuellement l'utilisateur de l'application, vous pouvez utiliser le Auth façade La méthode logout. Cela effacera les informations d'authentification dans la session de l'utilisateur : 🎜rrreee🎜🎜🎜

    🎜

    Invalider les sessions sur d'autres appareils

    🎜Laravel fournit également un mécanisme pour invalider et « déconnecter » les sessions utilisateur sur d'autres appareils sans invalider la session sur l'appareil actuel. Tout d'abord, vous devez vous assurer que le middleware IlluminateSessionMiddlewareAuthenticateSession se trouve dans le groupe de middlewares web dans votre classe app/Http/Kernel.php, et là is no Commenté : 🎜rrreee🎜 Ensuite, vous pouvez utiliser la méthode logoutOtherDevices sur la façade Auth. Cette méthode nécessite que l'utilisateur fournisse son mot de passe actuel, que votre application doit accepter via le formulaire de saisie : 🎜rrreee

    🎜{note} Lorsque la méthode logoutOtherDevices est appelée, les autres sessions de l'utilisateur seront complètement désactivé, ce qui signifie qu'ils « quitteront » tous les observateurs auprès desquels ils étaient précédemment authentifiés. 🎜🎜🎜🎜🎜🎜🎜🎜

    Ajouter un observateur personnalisé

    Vous pouvez définir votre propre observateur d'authentification en utilisant la méthode extend de la façade Auth. Vous devez appeler la méthode extend dans le fournisseur de services. Puisque Laravel est déjà livré avec AuthServiceProvider, nous pouvons mettre le code dans ce fournisseur : Auth facade 的 extend 方法来定义自己的身份验证看守器。你应该在 服务提供器 中调用  extend 方法。由于 Laravel 已经附带了 AuthServiceProvider，我们可以将代码放在该提供器中：

    rrreee

    正如你在上面的示例中所看到的，传递给 extend 方法的回调应该返回一个实现 IlluminateContractsAuthGuard 接口的实例。这个接口包含了一些你需要在自定义的看守器中实现的方法。当你的自定义看守器定义完成之后，你可以在 auth.php 配置文件的 guards 配置中使用这个看守器：

    rrreee

    请求闭包看守器

    实现基于 HTTP 请求的自定义身份验证系统的最简单方法，是使用 Auth::viaRequest 方法。此方法允许您使用单个闭包来快速定义身份验证过程。

    首先，在 AuthServiceProvider 的 boot 方法中调用 Auth::viaRequest 方法。viaRequest 方法接受一个看守器名称作为其第一个参数。此名称可以是描述你自定义看守器的任何字符串。传递给该方法的第二个参数应该是一个闭包函数，它接收传入的 HTTP 请求并返回一个用户实例，或者，如果验证失败，则为 null：

    rrreee

    当你完成了自定义看守器后，就可以在 auth.php 配置文件的 guards 配置中使用这个看守器：

    rrreee

    添加自定义用户提供器

    如果不使用传统的关系数据库存储用户，就需要使用自己的身份验证用户提供器扩展 Lavarel。可以使用 Auth facade 的 provider 方法自定义用户提供器：

    rrreee

    一旦使用 provider 方法注册完毕，就可以在 auth.php 配置文件中切换到新的用户提供器。先定义一个使用新驱动的 provider ：

    rrreee

    随后就可以在 guardsrrreee

    Comme vous pouvez le voir dans l'exemple ci-dessus, passez à extend Le rappel de la méthode devrait renvoyer une instance qui implémente l'interface IlluminateContractsAuthGuard. Cette interface contient certaines méthodes que vous devez implémenter dans votre observateur personnalisé. Une fois votre garde personnalisée définie, vous pouvez utiliser cette garde dans la configuration guards du fichier de configuration auth.php :

    rrreee

    Demandes de fermeture de gardes

    La meilleure façon d'implémenter un système d'authentification personnalisé basé sur des requêtes HTTP Le moyen le plus simple est de utilisez la méthode Auth::viaRequest. Cette méthode permet de définir rapidement le processus d'authentification à l'aide d'une seule fermeture. 🎜🎜Tout d'abord, appelez la méthode Auth::viaRequest dans la méthode boot de AuthServiceProvider. La méthode viaRequest accepte un nom d'observateur comme premier paramètre. Ce nom peut être n’importe quelle chaîne décrivant votre observateur personnalisé. Le deuxième paramètre passé à cette méthode doit être une fonction de fermeture qui reçoit la requête HTTP entrante et renvoie une instance utilisateur, ou null si la validation échoue : 🎜rrreee🎜Quand Une fois que vous avez fini de personnaliser la garde, vous peut l'utiliser dans la configuration guards du fichier de configuration auth.php : 🎜rrreee🎜🎜🎜

    🎜🎜Ajouter des fournisseurs d'utilisateurs personnalisés🎜🎜Si vous n'utilisez pas de base de données relationnelle traditionnelle pour stocker les utilisateurs, vous devrez utiliser votre propre extension de fournisseur d'utilisateurs d'authentification d'identité Lavarel. Les fournisseurs d'utilisateurs peuvent être personnalisés à l'aide de la méthode provider de la façade Auth : 🎜rrreee🎜Une fois inscrit à l'aide de la méthode provider, vous pouvez utiliser le < code> auth.php fichier de configuration pour passer au nouveau fournisseur d'utilisateurs. Définissez d'abord un provider qui utilise le nouveau pilote : 🎜rrreee🎜 Ensuite, vous pouvez utiliser ce fournisseur dans la configuration guards : 🎜rrreee🎜🎜🎜🎜🎜🎜

    Contrat de fournisseur d'utilisateur

    L'implémentation IlluminateContractsAuthUserProvider est uniquement responsable de l'extraction de l'implémentation IlluminateContractsAuthAuthenticatable des systèmes de stockage persistants tels que MySQL, Riak, etc. Les deux interfaces permettent au mécanisme d'authentification de Laravel de continuer à fonctionner quelle que soit la manière dont l'utilisateur est stocké et le type de classe utilisé pour le représenter : IlluminateContractsAuthUserProvider 实现仅负责从 MySQL、Riak 等持久化存储系统中提取 IlluminateContractsAuthAuthenticatable 实现。无论用户如何存储及用于表示它的类是什么类型，这两个接口都允许 Laravel 身份验证机制继续运行：

    我们来看看 IlluminateContractsAuthUserProvider 契约：

    rrreee

    retrieveById 函数通常接受用于表示类的 key（如 MySQL 数据库中自动递增的 ID）作为参数，并获取和返回与这个 ID 匹配的 Authenticatable 实现。

    retrieveByToken 函数通过用户的唯一 $identifier 和存储在 remember_token 列的 「记住我」 令牌获取用户。与前一方法相同，它返回 Authenticatable 实现。

    updateRememberToken 方法用新  $token 更新  $user 的 remember_token 列。在「记住我」登录校验成功或者用户登出时分配「刷新令牌」。

    在尝试登录到应用时，retrieveByCredentials 方法接受凭证数组传递给 Auth::attempt 方法。此方法在底层持久化存储中「查询」与这些凭证匹配的用户。通常，此方法运行一个基于 $credentials['username'] 的 「where」 条件，它应该返回一个 Authenticatable 实现。此方法不就尝试进行任何密码校验或身份验证。

    validateCredentials 方法应该比较给定的 $user 与 $credentials 来验证用户身份。例如，此方法或许应该使用 Hash::check 来比较 $user->getAuthPassword() 的值与 $credentials['password'] 的值。它应该返回 true 或 false

    Jetons un coup d'œil au contrat IlluminateContractsAuthUserProvider :

    rrreee La fonction retrieveById accepte généralement la clé utilisée pour représenter la classe (comme l'ID auto-incrémenté dans la base de données MySQL) en tant que paramètre, et obtient et renvoie l'implémentation Authenticatable qui correspond à celle-ci. IDENTIFIANT.

    La fonction retrieveByToken récupère l'utilisateur via son $identifiant unique et le jeton "se souvenir de moi" stocké dans la colonne remember_token. Comme la méthode précédente, elle renvoie une implémentation Authenticatable.

    La méthode updateRememberToken met à jour la colonne remember_token de $user avec le nouveau $token. Un « jeton d'actualisation » est attribué lorsque la vérification de connexion « Remember Me » réussit ou lorsque l'utilisateur se déconnecte. 🎜🎜La méthode retrieveByCredentials accepte un tableau d'informations d'identification transmises à la méthode Auth::attempt lors de la tentative de connexion à l'application. Cette méthode « interroge » le magasin de persistance sous-jacent pour les utilisateurs correspondant à ces informations d'identification. Généralement, cette méthode exécute une condition "where" basée sur $credentials['username'], qui doit renvoyer une implémentation Authenticatable. Cette méthode ne tente aucune vérification ou authentification du mot de passe. 🎜🎜La méthode validateCredentials doit comparer le $user donné avec $credentials pour vérifier l'identité de l'utilisateur. Par exemple, cette méthode devrait probablement utiliser Hash::check pour comparer la valeur de $user->getAuthPassword() avec $credentials['password'] valeur. Il doit renvoyer true ou false pour indiquer si le mot de passe de l'utilisateur est valide. 🎜🎜🎜🎜🎜🎜🎜

    Contrat d'authentification

    Nous avons disséqué chaque méthode de UserProvider. Jetons un coup d'œil au contrat Authenticable. N'oubliez pas que les méthodes retrieveById, retrieveByToken et retrieveByCredentials du fournisseur d'utilisateurs renverront une instance de cette interface : UserProvider 的每个方法。下面再来看看 Authenticatable 契约。切记，用户提供器的 retrieveById、 retrieveByToken 和 retrieveByCredentials 方法将返回此接口的实例：

    rrreee

    这个接口很简单。 getAuthIdentifierName 方法应该返回用户 「主键」 列的名字， getAuthIdentifier 方法则返回用户 「主键」。在 MySQL 后台，它会是自增主键。 getAuthPassword 方法应该返回用户的哈希密码。此接口允许身份验证系统与任一 User 类一直工作，不管使用的是哪种 ORM 或抽象存储层。默认情况下，Laravel 的 app 目录会包含一个实现了此接口的 User 类，你可以以这个实现示例作为参考。

    事件

    在身份验证处理过程中 Laravel 引发了多种 事件 。 可以在  EventServiceProviderrrreee

    Cette interface est simple. La méthode getAuthIdentifierName doit renvoyer le nom de la colonne "clé primaire" de l'utilisateur, et la méthode getAuthIdentifier doit renvoyer la "clé primaire" de l'utilisateur. Dans le backend MySQL, il s'agira d'une clé primaire à incrémentation automatique. La méthode getAuthPassword doit renvoyer le mot de passe haché de l'utilisateur. Cette interface permet au système d'authentification de toujours fonctionner avec n'importe quelle classe d'utilisateur, quel que soit l'ORM ou la couche de stockage d'abstraction utilisée. Par défaut, le répertoire app de Laravel contiendra une classe User qui implémente cette interface. Vous pouvez utiliser cet exemple d'implémentation comme référence.

    Événements

    🎜Laravel déclenche divers événements pendant le processus d'authentification. Les auditeurs de ces événements peuvent être attachés dans EventServiceProvider : 🎜rrreee🎜Cet article a été publié pour la première fois sur le site Web 🎜LearnKu.com🎜. 🎜🎜

    Certification API →

    soumettre

    Site Web PHP chinois

    MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger