Comment implémenter le contrôle d'accès basé sur les rôles dans Laravel

Comment implémenter un contrôle d'accès basé sur les rôles dans Laravel

Citation :
Dans les applications Web, le contrôle d'accès est un élément important de la protection des données et des opérations sensibles. Le contrôle d'accès basé sur les rôles est une stratégie de contrôle d'accès courante qui nous permet de limiter les actions qu'un utilisateur peut effectuer en fonction de son rôle.

Laravel est un framework PHP populaire qui fournit des fonctionnalités simples mais puissantes pour implémenter un contrôle d'accès basé sur les rôles. Dans cet article, nous expliquerons comment implémenter un contrôle d'accès basé sur les rôles à l'aide de Laravel et fournirons quelques exemples de code concrets.

Étape 1 : Préparez la base de données
Tout d'abord, nous devons créer une base de données pour stocker les informations sur les utilisateurs, les rôles et les autorisations. Nous pouvons utiliser la fonctionnalité de migration de Laravel pour créer des tables de base de données. Voici un exemple de fichier de migration d'utilisateurs, de rôles et d'autorisations :

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

class CreateRolesAndPermissionsTables extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        // 创建角色表
        Schema::create('roles', function (Blueprint $table) {
            $table->id();
            $table->string('name')->unique();
            $table->timestamps();
        });

        // 创建权限表
        Schema::create('permissions', function (Blueprint $table) {
            $table->id();
            $table->string('name')->unique();
            $table->timestamps();
        });

        // 创建用户表
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            $table->timestamps();
        });

        // 创建用户角色表
        Schema::create('role_user', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->unsignedBigInteger('role_id');
            $table->timestamps();
        });

        // 创建角色权限表
        Schema::create('permission_role', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('permission_id');
            $table->unsignedBigInteger('role_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        // 删除表格
        Schema::dropIfExists('permission_role');
        Schema::dropIfExists('role_user');
        Schema::dropIfExists('users');
        Schema::dropIfExists('permissions');
        Schema::dropIfExists('roles');
    }
}

Exécutez la commande de migration pour créer la table de base de données :

php artisan migrate

Étape 2 : Définir des modèles et des relations
Dans Laravel, nous pouvons utiliser des modèles et des relations pour gérer les utilisateurs. , Données telles que les rôles et les autorisations. Voici un exemple de modèle et de définition de relation :

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;

class User extends Authenticatable
{
    use HasFactory;

    /**
     * 获取用户的角色
     */
    public function roles()
    {
        return $this->belongsToMany(Role::class, 'role_user');
    }

    /**
     * 检查用户是否具有指定角色
     */
    public function hasRole($role)
    {
        return $this->roles->contains('name', $role);
    }
}

class Role extends Model
{
    use HasFactory;

    /**
     * 获取角色的权限
     */
    public function permissions()
    {
        return $this->belongsToMany(Permission::class, 'permission_role');
    }
}

class Permission extends Model
{
    use HasFactory;
}

Étape 3 : Définir la politique
Dans Laravel, les politiques sont utilisées pour définir les autorisations d'un utilisateur vérifié sur une ressource spécifique. Nous pouvons utiliser des politiques pour mettre en œuvre un contrôle d’accès basé sur les rôles. Voici un exemple de définition de politique :

<?php

namespace AppPolicies;

use AppModelsUser;
use IlluminateAuthAccessHandlesAuthorization;

class PostPolicy
{
    use HandlesAuthorization;

    /**
     * 确定用户是否有权限更新一个帖子
     */
    public function update(User $user, Post $post)
    {
        return $user->hasRole('admin') || $user->hasRole('editor');
    }
}

Quatrième étape : enregistrer la politique
Pour utiliser la politique, nous devons l'enregistrer auprès du fournisseur de politique de Laravel. Ouvrez le fichier app/Providers/AuthServiceProvider.php et ajoutez le code suivant :

<?php

namespace AppProviders;

use IlluminateSupportFacadesGate;
use IlluminateFoundationSupportProvidersAuthServiceProvider as ServiceProvider;
use AppPoliciesPostPolicy;

class AuthServiceProvider extends ServiceProvider
{
    protected $policies = [
        'AppModelsPost' => 'AppPoliciesPostPolicy',
    ];

    public function boot()
    {
        $this->registerPolicies();
    }
}

Étape cinq : utiliser le middleware
Pour implémenter le contrôle d'accès basé sur les rôles, nous pouvons utiliser le middleware de Laravel dans les routes et les contrôleurs pour vérifier le rôle de l'utilisateur. Voici un exemple de définition de middleware :

<?php

namespace AppHttpMiddleware;

use Closure;

class RoleMiddleware
{
    public function handle($request, Closure $next, ...$roles)
    {
        if (!$request->user()->hasAnyRole($roles)) {
            abort(403, 'Unauthorized action.');
        }

        return $next($request);
    }
}

Étape 6 : Utiliser un middleware pour restreindre l'accès aux routes
Enfin, nous pouvons appliquer un middleware à des routes ou à des groupes de routes spécifiés pour restreindre l'accès des utilisateurs. Voici le code d'un exemple d'itinéraire :

<?php

use AppHttpMiddlewareRoleMiddleware;

Route::get('/admin/dashboard', function () {
    // 管理员和编辑者才能访问
})->middleware(RoleMiddleware::class . ':admin,editor');

Résumé :
Grâce aux fonctions de base de données, de modèle, de relation, de stratégie et de middleware de Laravel, nous pouvons facilement mettre en œuvre un contrôle d'accès basé sur les rôles. Vous trouverez ci-dessus les étapes détaillées et des exemples de code sur la façon de mettre en œuvre le contrôle d'accès basé sur les rôles dans Laravel. J'espère que cet article pourra vous aider à mieux comprendre et utiliser la fonction de contrôle d'accès de Laravel.

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!