Comment utiliser le framework Hyperf pour l'authentification

Comment utiliser le framework Hyperf pour l'authentification

Dans les applications Web modernes, l'authentification des utilisateurs est une fonctionnalité très importante. Pour protéger les informations sensibles et garantir la sécurité des applications, l'authentification garantit que seuls les utilisateurs authentifiés peuvent accéder aux ressources restreintes.

Hyperf est un framework PHP hautes performances basé sur Swoole, qui fournit de nombreuses fonctions et outils modernes et efficaces. Dans le framework Hyperf, nous pouvons utiliser plusieurs méthodes pour implémenter l'authentification d'identité. Deux des méthodes couramment utilisées seront présentées ci-dessous.

1. Utilisation de JWT (JSON Web Token)

JWT est un standard ouvert (RFC 7519) qui définit une méthode concise et autonome pour transmettre en toute sécurité des informations entre les parties communicantes. Dans le framework Hyperf, nous pouvons utiliser la bibliothèque d'extensions lcobucci/jwt pour réaliser la génération et la vérification JWT. lcobucci/jwt扩展库来实现JWT的生成和验证。

首先，我们需要在composer.json文件中添加lcobucci/jwt库的依赖项：

"require": {
    "lcobucci/jwt": "^3.4"
}

然后执行composer update命令安装依赖项。

接下来，我们可以创建一个JwtAuthenticator类，用于生成和验证JWT：

<?php

declare(strict_types=1);

namespace AppAuth;

use HyperfExtAuthAuthenticatable;
use HyperfExtAuthContractsAuthenticatorInterface;
use LcobucciJWTConfiguration;
use LcobucciJWTToken;

class JwtAuthenticator implements AuthenticatorInterface
{
    private Configuration $configuration;

    public function __construct(Configuration $configuration)
    {
        $this->configuration = $configuration;
    }

    public function validateToken(string $token): bool
    {
        $parsedToken = $this->configuration->parser()->parse($token);
        $isVerified = $this->configuration->validator()->validate($parsedToken, ...$this->configuration->validationConstraints());
        
        return $isVerified;
    }

    public function generateToken(Authenticatable $user): string
    {
        $builder = $this->configuration->createBuilder();
        $builder->issuedBy('your_issuer')
            ->issuedAt(new DateTimeImmutable())
            ->expiresAt((new DateTimeImmutable())->modify('+1 hour'))
            ->withClaim('sub', (string) $user->getAuthIdentifier());
        
        $token = $builder->getToken($this->configuration->signer(), $this->configuration->signingKey());
        
        return $token->toString();
    }
}

然后，我们需要在Hyperf框架的容器中注册JwtAuthenticator类：

HyperfUtilsApplicationContext::getContainer()->define(AppAuthJwtAuthenticator::class, function (PsrContainerContainerInterface $container) {
    $configuration = LcobucciJWTConfiguration::forAsymmetricSigner(
        new LcobucciJWTSignerRsaSha256(),
        LcobucciJWTSignerKeyLocalFileReference::file('path/to/private/key.pem')
    );

    return new AppAuthJwtAuthenticator($configuration);
});

最后，在需要认证的路由或控制器方法中，我们可以使用JwtAuthenticator类来验证用户的JWT：

<?php

declare(strict_types=1);

namespace AppController;

use AppAuthJwtAuthenticator;
use HyperfHttpServerAnnotationController;
use HyperfHttpServerAnnotationRequestMapping;

/**
 * @Controller(prefix="/api")
 */
class ApiController
{
    private JwtAuthenticator $authenticator;

    public function __construct(JwtAuthenticator $authenticator)
    {
        $this->authenticator = $authenticator;
    }

    /**
     * @RequestMapping(path="profile", methods="GET")
     */
    public function profile()
    {
        $token = $this->request->getHeader('Authorization')[0] ?? '';
        $token = str_replace('Bearer ', '', $token);
        
        if (!$this->authenticator->validateToken($token)) {
            // Token验证失败，返回错误响应
            return 'Unauthorized';
        }

        // Token验证成功，返回用户信息
        return $this->authenticator->getUserByToken($token);
    }
}

2. 使用Session

除了JWT认证，Hyperf框架也支持使用Session进行身份认证。我们可以通过配置文件来启用Session认证功能。

首先，我们需要在配置文件config/autoload/session.php中进行相应的配置，例如：

return [
    'handler' => [
        'class' => HyperfRedisSessionHandler::class,
        'options' => [
            'pool' => 'default',
        ],
    ],
];

然后，在需要认证的路由或控制器方法中，我们可以使用Hyperf框架提供的AuthManager类来验证用户的Session：

<?php

declare(strict_types=1);

namespace AppController;

use HyperfHttpServerAnnotationController;
use HyperfHttpServerAnnotationRequestMapping;
use HyperfExtAuthContractsAuthManagerInterface;

/**
 * @Controller(prefix="/api")
 */
class ApiController
{
    private AuthManagerInterface $authManager;

    public function __construct(AuthManagerInterface $authManager)
    {
        $this->authManager = $authManager;
    }

    /**
     * @RequestMapping(path="profile", methods="GET")
     */
    public function profile()
    {
        if (!$this->authManager->check()) {
            // 用户未登录，返回错误响应
            return 'Unauthorized';
        }

        // 用户已登录，返回用户信息
        return $this->authManager->user();
    }
}

在上述代码中，AuthManagerInterface

Tout d'abord, il faut ajouter les dépendances de la bibliothèque lcobucci/jwt dans le fichier composer.json :

rrreee

Ensuite, exécutez la commande composer update pour installer les dépendances . 🎜🎜Ensuite, nous pouvons créer une classe JwtAuthenticator pour générer et valider JWT : 🎜rrreee🎜Ensuite, nous devons enregistrer la classe JwtAuthenticator dans le conteneur du framework Hyperf : 🎜rrreee🎜Enfin, dans une méthode de route ou de contrôleur qui nécessite une authentification, nous pouvons utiliser la classe JwtAuthenticator pour vérifier le JWT de l'utilisateur : 🎜rrreee

🎜Use Session🎜🎜🎜 En plus de l'authentification JWT, le framework Hyperf prend également en charge l'utilisation de Session pour l'authentification d'identité. Nous pouvons activer la fonction d'authentification de session via le fichier de configuration. 🎜🎜Tout d'abord, nous devons faire la configuration correspondante dans le fichier de configuration config/autoload/session.php, par exemple : 🎜rrreee🎜Ensuite, dans la méthode de route ou de contrôleur qui nécessite une authentification, nous pouvons utilisation La classe AuthManager fournie par le framework Hyperf est utilisée pour vérifier la session de l'utilisateur : 🎜rrreee🎜Dans le code ci-dessus, l'interface AuthManagerInterface fournit de nombreuses méthodes d'authentification et d'opérations utilisateur , qui peut être Passer des appels en fonction des besoins réels. 🎜🎜Ci-dessus sont deux méthodes courantes d'authentification d'identité à l'aide du framework Hyperf, en utilisant JWT ou Session pour implémenter l'authentification des utilisateurs. En fonction des besoins réels et des caractéristiques du projet, sélectionnez les méthodes appropriées pour garantir la sécurité des applications et l'expérience utilisateur. Dans le cadre du développement réel, vous pouvez en savoir plus sur l'utilisation avancée et les meilleures pratiques en vous basant sur la documentation et les exemples de code fournis par le framework. 🎜

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!