Comment utiliser le framework Hyperf pour la gestion des autorisations

Comment utiliser le framework Hyperf pour la gestion des autorisations

À l'ère d'Internet d'aujourd'hui, la gestion des autorisations est un sujet important. Lorsque nous développons une application, nous devons parfois contrôler l'accès des utilisateurs aux ressources système en fonction de leur identité et de leur rôle. À cet égard, le framework Hyperf nous fournit des outils et méthodes puissants. Cet article explique comment utiliser le framework Hyperf pour la gestion des autorisations et fournit des exemples de code spécifiques.

1. Installez le framework Hyperf

Tout d'abord, nous devons installer le framework Hyperf. Vous pouvez utiliser composer pour terminer l'installation et exécuter la commande suivante :

$ composer create-project hyperf/hyperf-skeleton

Une fois l'installation terminée, entrez dans le répertoire du projet et exécutez la commande suivante pour démarrer le serveur Hyperf :

$ php bin/hyperf.php start

2. Définissez les règles d'autorisation

Dans le Framework Hyperf, nous pouvons le définir via des annotations Règles d'autorisation. Tout d'abord, nous devons définir des règles d'autorisation dans le fichier config/autoload/permissions.php, par exemple :

<?php

use HyperfPermissionModelPermission;

Permission::create([
    'name' => 'user-manage',
    'display_name' => '用户管理',
]);

Permission::create([
    'name' => 'article-manage',
    'display_name' => '文章管理',
]);

Dans le code ci-dessus, nous définissons deux règles d'autorisation, à savoir la gestion des utilisateurs et la gestion des articles.

3. Créer un middleware

Ensuite, nous devons créer un middleware pour vérifier si l'utilisateur est autorisé à accéder à un certain itinéraire. Le middleware peut être créé via la commande suivante :

$ php bin/hyperf.php gen:middleware CheckPermission

Ensuite, modifiez le fichier app/Middleware/CheckPermissionMiddleware.php pour implémenter la logique de vérification des autorisations. Voici un exemple :

<?php

declare(strict_types=1);

namespace AppMiddleware;

use HyperfHttpServerContractResponseInterface as HttpResponse;
use HyperfUtilsApplicationContext;
use PsrContainerContainerInterface;
use PsrHttpMessageResponseInterface;
use PsrHttpMessageServerRequestInterface;
use PsrHttpServerMiddlewareInterface;
use PsrHttpServerRequestHandlerInterface;

class CheckPermissionMiddleware implements MiddlewareInterface
{
    /**
     * @var HttpResponse
     */
    protected $response;

    public function __construct(ContainerInterface $container)
    {
        $this->response = ApplicationContext::getContainer()->get(HttpResponse::class);
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        // 在这里实现权限检查逻辑
        $permissions = $request->getAttribute('permissions', []);

        foreach ($permissions as $permission) {
            if (! $this->hasPermission($permission)) {
                return $this->response->json([
                    'code' => 403,
                    'message' => '没有权限访问该资源',
                ]);
            }
        }

        return $handler->handle($request);
    }

    protected function hasPermission($permission)
    {
        // 在这里实现检查用户是否拥有该权限的逻辑
        // 返回true表示有权限，返回false表示没有权限
    }
}

Dans le code ci-dessus, nous spécifions les autorisations à vérifier en passant un paramètre d'autorisations dans la requête. Dans la méthode de processus, nous parcourons le paramètre d'autorisations entrantes et appelons la méthode hasPermission pour vérifier si l'utilisateur dispose de l'autorisation. S'il n'y a aucune autorisation, nous renvoyons une erreur 403.

4. Effectuer une vérification des autorisations

Dans les itinéraires qui nécessitent une vérification des autorisations, nous pouvons utiliser un middleware pour vérifier les autorisations de l'utilisateur. Voici un exemple :

<?php

use AppMiddlewareCheckPermissionMiddleware;

Router::get('/users', 'UserController@index')
    ->middleware([
        new CheckPermissionMiddleware([
            'user-manage',
        ]),
    ]);

Dans le code ci-dessus, nous spécifions le middleware à utiliser via la méthode middleware. Dans cet exemple, nous utilisons CheckPermissionMiddleware et transmettons une autorisation de gestion utilisateur.

Grâce aux étapes ci-dessus, nous pouvons implémenter une gestion simple des autorisations dans le framework Hyperf. En définissant des règles d'autorisation, en créant un middleware et en utilisant un middleware pour effectuer des vérifications d'autorisation, nous sommes en mesure de contrôler l'accès des utilisateurs aux ressources système en fonction de leur identité et de leur rôle.

Résumé :

Le framework Hyperf fournit des outils et des méthodes pratiques pour la gestion des autorisations. Dans cet article, nous avons appris à définir des règles d'autorisation, à créer un middleware et à utiliser un middleware pour la vérification des autorisations. Grâce à ces étapes, nous pouvons facilement mettre en œuvre des fonctions de gestion des autorisations et contrôler l'accès des utilisateurs aux ressources système en fonction de leurs identités et de leurs rôles. J'espère que cet article pourra vous aider à utiliser le framework Hyperf pour la gestion des autorisations.

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!