Comment implémenter un système de gestion des autorisations dans Laravel

Comment implémenter un système de gestion des autorisations dans Laravel

Introduction :
Avec le développement continu des applications Web, le système de gestion des autorisations est devenu l'une des fonctions de base de nombreuses applications. Laravel, en tant que framework PHP populaire, fournit une multitude d'outils et de fonctions pour mettre en œuvre des systèmes de gestion des autorisations. Cet article présentera comment implémenter un système de gestion des autorisations simple et puissant dans Laravel et fournira des exemples de code spécifiques.

1. Idées de conception d'un système de gestion des autorisations
Lors de la conception d'un système de gestion des autorisations, vous devez prendre en compte les points clés suivants :

1. Définition des rôles et des autorisations : le rôle fait référence à la fonction ou à l'identité de l'utilisateur, et les autorisations font référence à l'utilisateur. Contrôle de l'utilisateur sur le système Accès aux fonctionnalités ou aux ressources.
2. La relation entre les utilisateurs et les rôles : un utilisateur peut avoir plusieurs rôles, et un rôle peut appartenir à plusieurs utilisateurs.
3. La relation entre les autorisations et les rôles : un rôle peut avoir plusieurs autorisations, et une autorisation peut appartenir à plusieurs rôles.
4. La relation entre le routage et les autorisations : le routage détermine l'entrée permettant aux utilisateurs d'accéder aux fonctions du système. Différents itinéraires peuvent nécessiter différentes autorisations pour restreindre l'accès.

Sur la base des idées de conception ci-dessus, nous pouvons commencer à implémenter le système de gestion des autorisations dans Laravel.

2. Conception et migration de bases de données
Dans Laravel, nous pouvons utiliser la migration de bases de données pour créer et modifier des tables de base de données. Ce qui suit est une conception de base de données simple :

1. Table des utilisateurs (utilisateurs) : stocke les informations de base des utilisateurs, telles que le nom d'utilisateur, le mot de passe, etc.
2. Table des rôles (rôles) : stocke les informations de base sur les rôles, telles que le nom du rôle, la description, etc.
3. Tableau des autorisations : stocke des informations de base sur les autorisations, telles que les noms des autorisations, les descriptions, etc.
4. Table d'association rôle-permission (role_permission) : enregistre la relation correspondante entre les rôles et les autorisations.
5. Table d'association utilisateur-rôle (user_role) : enregistre la relation correspondante entre les utilisateurs et les rôles.

Tout d'abord, créez le fichier de migration :

php artisan make:migration create_users_table
php artisan make:migration create_roles_table
php artisan make:migration create_permissions_table
php artisan make:migration create_role_permission_table
php artisan make:migration create_user_role_table

Ensuite, écrivez la structure de la table dans le fichier de migration correspondant (le code est omis), et exécutez la commande de migration :

php artisan migrate

Définissez la relation du modèle
Dans Laravel, nous Vous pouvez utiliser des modèles Eloquent pour définir des relations entre les tables de base de données. Tout d’abord, nous devons définir trois modèles : utilisateur, rôle et autorisation.

1. Modèle utilisateur (Utilisateur)

   namespace App;
   
   use IlluminateDatabaseEloquentModel;
   
   class User extends Model
   {
    // 用户与角色的多对多关系
    public function roles()
    {
        return $this->belongsToMany('AppRole')->withTimestamps();
    }
   
    // 判断用户是否拥有某个角色
    public function hasRole($role)
    {
        if (is_string($role)) {
            return $this->roles->contains('name', $role);
        }
   
        return !! $role->intersect($this->roles)->count();
    }
   
    // 判断用户是否拥有某个权限
    public function hasPermission($permission)
    {
        return $this->hasRole($permission->roles);
    }
   }

2. Modèle de rôle (Rôle)

   namespace App;
   
   use IlluminateDatabaseEloquentModel;
   
   class Role extends Model
   {
    // 角色与用户的多对多关系
    public function users()
    {
        return $this->belongsToMany('AppUser')->withTimestamps();
    }
   
    // 角色与权限的多对多关系
    public function permissions()
    {
        return $this->belongsToMany('AppPermission')->withTimestamps();
    }
   
    // 判断角色是否拥有某个权限
    public function hasPermission($permission)
    {
        if (is_string($permission)) {
            return $this->permissions->contains('name', $permission);
        }
   
        return !! $permission->intersect($this->permissions)->count();
    }
   }

3. Modèle d'autorisation (Permission)

   namespace App;
   
   use IlluminateDatabaseEloquentModel;
   
   class Permission extends Model
   {
    // 权限与角色的多对多关系
    public function roles()
    {
        return $this->belongsToMany('AppRole');
    }
   }

4. Paramètres de middleware et de routage
Afin de mettre en œuvre le système de gestion des autorisations, nous pouvons utiliser un middleware pour intercepter et authentifier les demandes d'accès des utilisateurs. Tout d’abord, nous devons définir un middleware d’autorisation.

1. Définir le middleware d'autorisation :

   namespace AppHttpMiddleware;
   
   use Closure;
   use IlluminateSupportFacadesAuth;
   
   class CheckPermission
   {
    public function handle($request, Closure $next, $permission)
    {
        $user = Auth::user();
        
        if ($user && $user->hasPermission($permission)) {
            return $next($request);
        }
        
        return redirect()->route('403'); // 没有权限则跳转到403页面
    }
   }

2. Enregistrer le middleware d'autorisation :
   Enregistrer le middleware d'autorisation dans le tableau $routeMiddleware dans appHttpKernel.php : appHttpKernel.php中的$routeMiddleware数组中注册权限中间件：

   protected $routeMiddleware = [
    // ...
    'permission' => AppHttpMiddlewareCheckPermission::class,
   ];

3. 关联中间件与路由：
   在routesweb.php中定义需要权限控制的路由，并使用permission

   Route::get('/members', 'MemberController@index')->middleware('permission:member_view');

Associer middleware et routage :

Définissez les routes qui nécessitent un contrôle d'autorisation dans routesweb.php et utilisez le middleware permission :

namespace AppHttpControllers;

use IlluminateSupportFacadesAuth;

class MemberController extends Controller
{
 public function index()
 {
    if (Auth::user()->hasPermission('member_view')) {
         return view('members.index');
    }
    
    // 没有权限则跳转到403页面
    return redirect()->route('403');
 }
}

1. 5. vous pouvez utiliser l'exemple de code suivant pour authentifier l'identité de l'utilisateur et renvoyer la vue correspondante en fonction des autorisations.

2. Méthodes dans le contrôleur :

   @if(Auth::user()->hasPermission('member_view'))
    <!-- 具有查看成员的权限，显示相关内容 -->
    <table>
        ...
    </table>
   @else
    <!-- 没有权限，显示无权限提示 -->
    <div>您没有查看成员的权限</div>
   @endif

Code dans la vue :

rrreee

6. Résumé

Grâce aux étapes ci-dessus, nous avons implémenté avec succès un système de gestion des autorisations simple et puissant dans Laravel. En définissant les rôles, les autorisations et les relations correspondantes, en utilisant un middleware pour intercepter les routes et en évaluant les autorisations dans les contrôleurs et les vues, nous pouvons obtenir un contrôle précis des autorisations d'accès des utilisateurs. J'espère que cet article pourra vous aider à mieux comprendre et appliquer les fonctions de gestion des autorisations dans Laravel.

• Références :
• Documentation officielle de Laravel (https://laravel.com/docs/8.x/)

🎜Tutoriels de la série Laravel Beyond CRUD : Gestion des autorisations (https://laravelbestpractices.com/series/show/ laravel -au-delà de la crud/épisodes/9)🎜🎜

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!