Comment utiliser le framework Hyperf pour l'authentification d'interface

Comment utiliser le framework Hyperf pour l'authentification d'interface

L'authentification est un problème de sécurité important dans le développement d'applications Web, elle peut protéger nos interfaces contre l'accès par des utilisateurs non autorisés. Lorsque nous utilisons le framework Hyperf pour développer des interfaces, nous pouvons utiliser le mécanisme d'authentification fourni par Hyperf pour implémenter l'authentification d'interface. Cet article explique comment utiliser le framework Hyperf pour l'authentification d'interface et fournit des exemples de code spécifiques.

1. Comprendre l'authentification de l'interface

L'authentification de l'interface est le processus de vérification des informations d'identité de l'utilisateur pour déterminer si l'utilisateur a le droit d'accéder à l'interface. Les méthodes d'authentification courantes incluent l'authentification basée sur les jetons et l'authentification basée sur les rôles.

L'authentification basée sur un jeton est émise par un jeton après la connexion de l'utilisateur. Chaque fois que l'utilisateur demande l'interface, l'utilisateur doit porter le jeton dans l'en-tête de la demande. Le serveur vérifie la validité du jeton et détermine si. l'identité de l'utilisateur est légitime.

L'authentification basée sur les rôles consiste à attribuer différents rôles et autorisations aux utilisateurs Lorsque l'utilisateur demande une interface, le serveur vérifie si l'utilisateur a le droit d'accéder à l'interface en fonction de son rôle.

2. Configurer l'authentification de l'interface du framework Hyperf

1. Installer le composant jwt

Le framework Hyperf fournit un composant Hyperf/Jwt pour prendre en charge l'authentification de l'interface. Exécutez la commande suivante dans le répertoire racine du projet :

composer require hyperf/jwt

2. Configure middleware

Le middleware Hyperf Framework peut effectuer un certain traitement avant ou après que la requête atteigne le contrôleur. Nous pouvons implémenter l'authentification d'interface en configurant un middleware.

Ajoutez le code suivant dans le fichier config/autoload/middleware.php :

return [
    'http' => [
        AppMiddlewareJwtAuthMiddleware::class,
    ],
];

3. Write middleware

Créez le fichier JwtAuthMiddleware.php dans le répertoire app/Middleware et écrivez le code suivant :

<?php

declare(strict_types=1);

namespace AppMiddleware;

use HyperfDiAnnotationInject;
use HyperfHttpServerContractRequestInterface;
use HyperfHttpServerContractResponseInterface;
use HyperfUtilsContext;
use HyperfUtilsExceptionParallelExecutionException;
use Phper666JwtAuthJwt;

class JwtAuthMiddleware implements MiddlewareInterface
{
    /**
     * @Inject
     * @var Jwt
     */
    protected $jwt;

    /**
     * @Inject
     * @var RequestInterface
     */
    protected $request;

    /**
     * @Inject
     * @var ResponseInterface
     */
    protected $response;

    /**
     * 接口鉴权逻辑处理
     */
    public function process(RequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        if (!$this->jwt->checkToken()) {
            return $this->response->json([
                'code' => 401,
                'message' => 'Unauthorized',
            ]);
        }
        
        // 鉴权通过，将用户信息保存在Context中，后续控制器可通过Context获取用户信息
        Context::set('user', $this->jwt->getParserData());

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

3. Utilisez Authentification de l'interface Hyperf

1. La connexion génère un jeton

Dans l'interface de connexion, une fois l'utilisateur authentifié, utilisez le composant Hyperf/Jwt pour générer un jeton et le renvoyer au front-end. fois qu'il demande l'interface. Un exemple est le suivant :

<?php

declare(strict_types=1);

namespace AppController;

use HyperfHttpServerAnnotationAutoController;
use HyperfDiAnnotationInject;
use Phper666JwtAuthJwt;

/**
 * @AutoController
 */
class AuthController
{
    /**
     * @Inject
     * @var Jwt
     */
    protected $jwt;

    public function login()
    {
        // 获取用户信息
        $userInfo = [
            'user_id' => 1,
            'username' => 'admin',
        ];

        // 生成Token
        $token = $this->jwt->getToken($userInfo);

        // 返回Token给前端
        return [
            'code' => 200,
            'message' => 'success',
            'data' => [
                'token' => $token,
            ],
        ];
    }
}

2. Authentification de l'interface

Dans l'interface qui nécessite une authentification, nous pouvons obtenir des informations sur l'utilisateur via Context et déterminer si l'utilisateur a le droit d'accéder à l'interface. Un exemple est le suivant :

<?php

declare(strict_types=1);

namespace AppController;

use HyperfHttpServerAnnotationAutoController;
use HyperfDiAnnotationInject;
use HyperfUtilsContext;

/**
 * @AutoController
 */
class UserController
{
    public function getUserInfo()
    {
        // 从Context中获取用户信息
        $userInfo = Context::get('user');

        // 根据用户信息查询用户
        // ...

        // 返回用户信息给前端
        return [
            'code' => 200,
            'message' => 'success',
            'data' => $userInfo,
        ];
    }
}

Grâce aux étapes ci-dessus, nous pouvons implémenter l'authentification d'interface dans le framework Hyperf. Dans les interfaces qui nécessitent une authentification, utilisez un middleware pour authentifier et vérifier les demandes, puis effectuez le traitement correspondant en fonction des résultats de l'authentification. Cela peut garantir efficacement la sécurité de l'interface et garantir que seuls les utilisateurs autorisés peuvent accéder à l'interface.

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!