Comment utiliser le framework Hyperf pour le contrôle des autorisations

Comment utiliser le framework Hyperf pour le contrôle des autorisations

Introduction :
Lors du développement d'une application, il est souvent nécessaire d'implémenter des fonctions de contrôle des autorisations pour donner aux utilisateurs différentes autorisations dans différents rôles. Le framework Hyperf est un framework de microservices PHP hautes performances qui fournit de nombreuses fonctionnalités et extensions puissantes, notamment un contrôle flexible des autorisations. Dans cet article, nous explorerons comment utiliser le framework Hyperf pour implémenter le contrôle des autorisations et fournirons des exemples de code spécifiques.

1. Créer une table d'autorisations
Tout d'abord, nous devons créer une table d'autorisations pour stocker diverses informations d'autorisation. Les tables de base de données peuvent être créées via la fonction de migration de données d'Hyperf. Exécutez la commande suivante dans le terminal pour générer le fichier de migration :

php bin/hyperf.php gen:migration create_permissions_table

Ajoutez ensuite le contenu suivant dans le fichier de migration généré :

<?php

use HyperfDatabaseSchemaSchema;
use HyperfDatabaseSchemaBlueprint;
use HyperfDatabaseMigrationsMigration;
use HyperfDbConnectionDb;

class CreatetPermissionsTable extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        $tableName = 'permissions';
        $exists = Db::table('information_schema.TABLES')
            ->where('TABLE_SCHEMA', config('databases.default.dbname'))
            ->where('TABLE_NAME', $tableName)
            ->first();

        if (!$exists) {
            Schema::create($tableName, function (Blueprint $table) {
                $table->bigIncrements('id');
                $table->string('name')->unique()->comment('权限名称');
                $table->string('guard_name')->default('web')->comment('守卫名称');
                $table->timestamps();
            });
        }
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('permissions');
    }
}

Ensuite, nous devons ajouter le fichier de configuration principal du projet config/autoload/ permissions.php< /code> Ajoutez le contenu suivant : <code>config/autoload/permissions.php中添加以下内容：

<?php

return [
    'default' => [
        'guard_name' => 'web',
        'permissions' => [
            // 在这里添加你的权限
            'create_post',
            'edit_post',
            'delete_post',
            // ...
        ],
    ],
];

然后在命令行中运行以下命令执行数据库迁移：

php bin/hyperf.php migrate

二、定义用户角色模型
在Hyperf框架中，我们需要定义一个用户模型，该模型用于管理用户的角色和权限。我们可以通过继承HyperfDatabaseModelModel类来创建一个用户模型。在终端中执行以下命令来生成用户模型：

php bin/hyperf.php gen:model User

然后在生成的用户模型文件中添加以下代码：

namespace AppModel;

use HyperfDbConnectionModelModel;
use HyperfUtilsApplicationContext;

class User extends Model
{
    protected $guarded = [];

    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }

    public function hasPermission($permission)
    {
        foreach ($this->roles as $role) {
            if ($role->hasPermission($permission)) {
                return true;
            }
        }
        return false;
    }

    public function givePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->sync($permissionModel, false);
    }

    public function revokePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->detach($permissionModel);
    }

    public function permissions()
    {
        return $this->belongsToMany(Permission::class, 'user_permissions');
    }
}

三、定义角色模型
在Hyperf框架中，我们也需要定义一个角色模型，该模型用于管理角色和权限。同样，我们可以通过继承HyperfDatabaseModelModel类来创建一个角色模型。在终端中执行以下命令来生成角色模型：

php bin/hyperf.php gen:model Role

然后在生成的角色模型文件中添加以下代码：

namespace AppModel;

use HyperfDbConnectionModelModel;

class Role extends Model
{
    protected $guarded = [];

    public function users()
    {
        return $this->belongsToMany(User::class);
    }

    public function permissions()
    {
        return $this->belongsToMany(Permission::class);
    }

    public function hasPermission($permission)
    {
        return $this->permissions->contains('name', $permission);
    }

    public function givePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->sync($permissionModel, false);
    }

    public function revokePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->detach($permissionModel);
    }
}

四、定义权限模型
在Hyperf框架中，我们还需要定义一个权限模型，该模型用于管理权限信息。同样地，我们可以通过继承HyperfDatabaseModelModel类来创建一个权限模型。在终端中执行以下命令来生成权限模型：

php bin/hyperf.php gen:model Permission

然后在生成的权限模型文件中添加以下代码：

namespace AppModel;

use HyperfDbConnectionModelModel;

class Permission extends Model
{
    protected $guarded = [];

    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

五、定义权限中间件
接下来，我们需要创建一个权限中间件，用于检查用户是否有足够的权限访问某个路由。在终端中执行以下命令来生成中间件：

php bin/hyperf.php gen:middleware PermissionMiddleware

然后在生成的中间件文件中添加以下代码：

namespace AppMiddleware;

use HyperfHttpMessageStreamSwooleStream;
use HyperfHttpServerContractRequestInterface;
use HyperfUtilsContext;
use PsrContainerContainerInterface;
use PsrHttpMessageResponseInterface;
use PsrHttpServerMiddlewareInterface;
use PsrHttpServerRequestHandlerInterface;

class PermissionMiddleware implements MiddlewareInterface
{
    protected $container;

    protected $request;

    public function __construct(ContainerInterface $container, RequestInterface $request)
    {
        $this->container = $container;
        $this->request = $request;
    }

    public function process($request, RequestHandlerInterface $handler): ResponseInterface
    {
        $user = $this->request->getAttribute('user');
        $permissions = $this->request->route->permission;

        if ($user && $user->hasPermission($permissions)) {
            return $handler->handle($request);
        }

        return $this->response(403, 'Forbidden');
    }

    protected function response($code, $message)
    {
        $data = [
            'code' => $code,
            'message' => $message,
        ];

        return Context::get(ResponseInterface::class)->withBody(new SwooleStream(json_encode($data)));
    }
}

六、使用权限中间件
在路由定义中，我们可以通过使用->middleware('permission:xxx')

php bin/hyperf.php gen:controller PermissionController

Ensuite, exécutez la commande suivante dans la ligne de commande pour effectuer la migration de la base de données :

namespace AppController;

use AppMiddlewarePermissionMiddleware;
use HyperfHttpServerAnnotationController;
use HyperfHttpServerAnnotationMiddleware;
use HyperfHttpServerAnnotationRequestMapping;

/**
 * @Controller
 * @Middleware(PermissionMiddleware::class)
 */
class PermissionController
{
    /**
     * @RequestMapping(path="/permission", methods="get")
     * @Middleware("permission:create_post")
     */
    public function createPost()
    {
        // 处理创建文章的逻辑
    }

    /**
     * @RequestMapping(path="/permission", methods="get")
     * @Middleware("permission:edit_post")
     */
    public function editPost()
    {
        // 处理编辑文章的逻辑
    }

    /**
     * @RequestMapping(path="/permission", methods="get")
     * @Middleware("permission:delete_post")
     */
    public function deletePost()
    {
        // 处理删除文章的逻辑
    }
}

2. Définissez le modèle de rôle de l'utilisateur

Dans le framework Hyperf, nous devons définir un modèle utilisateur, qui est utilisé pour la gestion des rôles et des autorisations des utilisateurs. Nous pouvons créer un modèle utilisateur en héritant de la classe HyperfDatabaseModelModel. Exécutez la commande suivante dans le terminal pour générer le modèle utilisateur :

$user = User::find(1);

if ($user->hasPermission('edit_post')) {
    // 给用户权限来编辑文章
} else {
    // 权限不足
}

Ajoutez ensuite le code suivant dans le fichier de modèle utilisateur généré :

rrreee
3. Définissez le modèle de rôle

Dans le framework Hyperf, nous devons également définir un rôle modèle Utilisé pour gérer les rôles et les autorisations. De même, nous pouvons créer un modèle de rôle en héritant de la classe HyperfDatabaseModelModel. Exécutez la commande suivante dans le terminal pour générer le modèle de rôle : 🎜rrreee🎜 Ajoutez ensuite le code suivant dans le fichier de modèle de rôle généré : 🎜rrreee🎜 4. Définissez le modèle d'autorisation 🎜 Dans le framework Hyperf, nous devons également définir une autorisation modèle Utilisé pour gérer les informations d’autorisation. De même, nous pouvons créer un modèle d'autorisation en héritant de la classe HyperfDatabaseModelModel. Exécutez la commande suivante dans le terminal pour générer le modèle d'autorisation : 🎜rrreee🎜 Ajoutez ensuite le code suivant dans le fichier de modèle d'autorisation généré : 🎜rrreee🎜 5. Définissez le middleware d'autorisation 🎜 Ensuite, nous devons créer un middleware d'autorisation pour vérifier si le l'utilisateur dispose d'autorisations suffisantes pour accéder à un certain itinéraire. Exécutez la commande suivante dans le terminal pour générer le middleware : 🎜rrreee🎜 Ajoutez ensuite le code suivant dans le fichier middleware généré : 🎜rrreee🎜 6. Utiliser le middleware d'autorisation 🎜 Dans la définition de la route, on peut utiliser -&gt ;middleware ("permission:xxx') pour définir le middleware d'autorisation correspondant pour le routage. Exécutez la commande suivante dans le terminal pour générer le fichier de routage : 🎜rrreee🎜 Ajoutez ensuite le code suivant dans le fichier de routage généré : 🎜rrreee🎜 7. Exemples d'utilisation 🎜 Lorsque le contrôle des autorisations est requis, nous pouvons vérifier si l'utilisateur est dans le de la manière suivante Avoir des autorisations suffisantes : 🎜rrreee🎜 8. Résumé🎜Cet article présente les étapes détaillées sur la façon d'utiliser le framework Hyperf pour le contrôle des autorisations et fournit des exemples de code spécifiques. En utilisant les fonctions de gestion des autorisations fournies par le framework Hyperf, nous pouvons facilement implémenter des fonctions flexibles de contrôle des autorisations pour nos applications. J'espère que cet article vous sera utile, merci d'avoir lu ! 🎜

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!