Comment définir un jeton en php

Comment définir le jeton en PHP : définissez d'abord le chemin de routage pour obtenir le jeton ; puis établissez la couche Service ; puis créez la classe Utilisateur dans la couche Modèle, et créez les méthodes de vérification et la gestion des exceptions correspondantes dans le validateur. classe et classe d'exception ; Terminez enfin l'écriture du jeton Token.

Recommandé : "Tutoriel vidéo PHP"

L'interface API back-end que nous avons développée aura des exigences d'autorisation , comme certaines interfaces contenant des informations privées, exigent que le visiteur transmette un jeton qui lui a été délivré à l'avance lors de la demande de l'interface.

C'est comme un jeton, nous le "passerons" seulement si le visiteur le montre.

Ce qui suit est un enregistrement des idées d'écriture de code pour les jetons d'autorisation.

1. Aperçu du processus

Définir le chemin de routage pour obtenir le Token et accepter le paramètre de code (source du code : serveur WeChat, le système de connexion est basé sur le système WeChat)

Établir la couche Service, dans Créer la classe de base Token et la classe UserToken dans cette couche

La classe UserToken gère toute la logique : Génération et retour du Token

Créer la classe User dans le Modèle couche, qui est responsable de la lecture et de l'écriture des tables de données utilisateur pour le service. L'appel UserToken de la couche

Créer les méthodes de vérification correspondantes et la gestion des exceptions dans la classe de validation et la classe d'exception

Controller-> Couche de service->La couche modèle renvoie la valeur à la couche de service-> ;La couche de service renvoie la valeur au contrôleur et l'ensemble du processus termine l'écriture du jeton

2. Instructions spécifiques

Définissez d'abord le chemin de routage :

Route::post(    'api/:version/token/user',    'api/:version.Token/getToken');

Ensuite créez le Token control Device, définissez la méthode getToken correspondant au chemin de routage :

public function getToken($code='') {
        (new TokenGet())->goCheck($code); // 验证器        $token = (new UserToken($code))->get();        return [            'token' => $token
        ];
    }

Avant d'appeler la couche Service, vous devez vérifier le paramètres passés, définissez donc le validateur TokenGet :

class TokenGet extends BaseValidate
{
    protected $rule = [      'code' => 'require|isNotEmpty'
    ];
 
    protected $message = [        'code' => '需要code才能获得Token！'
    ];
 }

Retour au contrôle Token Une fois la vérification réussie, nous appelons la classe UserToken définie par la couche Service :

$token = (new UserToken($code))->get();

Nous discutons ici de la couche Service et Couche modèle. Notre compréhension générale est que la couche Service est une encapsulation abstraite basée sur la couche Modèle.

La couche Modèle est uniquement chargée d'exploiter la base de données et de la renvoyer à la couche Service

Ensuite, la couche Service traite la logique métier et enfin la renvoie à la couche Contrôleur

Mais je pense que pour les petits projets, Service est en fait au même niveau que Modèle, car certaines interfaces simples peuvent être directement connectées au Contrôleur via la couche Modèle. Seules les interfaces relativement complexes, telles que les autorisations utilisateur, peuvent séparer les codes pour différentes fonctions. via la couche Service.

Ce type de traitement est plus flexible. Il existe un grand nombre d'interfaces très simples et il n'est pas nécessaire de passer par la couche Service une seule fois. Cela ressemble plus à des mouvements et n'a aucun sens.

Retour à l'écriture du code de la couche Service. Puisqu'il existe différents types de Token, nous créons d'abord une classe de base Token, qui contient quelques méthodes courantes. Il y a ensuite la préparation de la classe UserToken qui renvoie le token au visiteur.

Comme il est basé sur WeChat, nous avons besoin de trois informations : code, appid, appsecret, puis attribuons une valeur initiale à la classe UserToken via le constructeur :

function __construct($code) {    $this->code = $code;    $this->wxAppID = config('wx.app_id');    $this->wxAppSecret = config('wx.app_secret');    $this->wxLoginUrl = sprintf(
        config('wx.login_url'),        $this->wxAppID, $this->wxAppSecret, $this->code
    );
    }

Ensuite, mettez-les Trois dans La position du paramètre de l'interface fournie par WeChat est d'obtenir une URL complète côté serveur WeChat et de demander l'openid dont nous avons besoin.

Ensuite, l'étape d'envoi d'une requête réseau est ignorée ici. Le serveur WeChat renverra un objet contenant openid. Après avoir jugé que la valeur de cet objet est OK, nous commençons l'étape de génération du token. Créez la fonction grantToken() :

private function grantToken($openidObj) {
 
        // 取出openid        $openid = $openidObj['openid'];
         
        // 通过Model层调用数据库，检查openid是否已经存在        $user = UserModel::getByOpenID($openid);
         
        // 如果存在，不处理，反之则新增一条user记录        if ($user) {            $uid = $user->id;
        } else {
            // 不存在，生成一条数据，具体方法略过            $uid = $this->newUser($openid); 
        }
         
        // 生成令牌，写入缓存（具体方法见下面的定义）        $cachedValue = $this->prepareCacheValue($openidObj, $uid);        $token = $this->saveToCache($cachedValue);
         
        // 令牌返回到调用者端        return $token;
}
 
private function prepareCacheValue($openidObj, $uid) {    $cachedValue = $openidObj;    $cachedValue['uid'] = $uid;    $cachedValue['scope'] = 16; // 权限值，自己定义    return $cachedValue;
}
     
private function saveToCache($cachedValue) {    $key = self::generateToken(); // 生成令牌的方法    $value = json_encode($cachedValue);    $tokenExpire = config('setting.token_expire'); // 设定的过期时间    $request = cache($key, $value, $tokenExpire);        if (!$request) {
            throw new TokenException([            'msg' => '服务器缓存异常',            'errorCode' => 10005
        ]);
    }    return $key; // 返回令牌:token
}

Comme vous pouvez le voir, le Le processus principal est :

Obtenir l'openid

Vérifiez la base de données et vérifiez si l'openid existe déjà

S'il existe, ne le traitez pas, sinon ajoutez un nouvel enregistrement utilisateur

Générer le token, préparer les données du cache, écrire dans le cache

Renvoyer le token au client

La méthode generateToken() est définie en détail comme suit :

public static function generateToken() {    $randomChars = getRandomChars(32); // 32个字符组成一组随机字符串    $timestamp = $_SERVER['REQUEST_TIME_FLOAT'];  
    $salt = config('security.token_salt'); // salt 盐
    // 拼接三组字符串，进行MD5加密，然后返回    return md5($randomChars.$timestamp.$salt);
}    
function getRandomChars($length) {    $str = null;    $strPoll = &#39;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789&#39;;    $max = strlen($strPoll) - 1;    for ($i = 0; $i < $length; $i++) {        $str .= $strPoll[rand(0, $max)];
    }    return $str;
}

Sa fonction principale n'est pas claire. Il ne fait aucun doute qu'il s'agit de générer le jeton dont nous avons besoin - Chaîne de jeton. Il convient de mentionner que, comme generateToken() est également utilisé dans d'autres types de Token, il est placé dans la classe de base Token.

À ce stade, il vous suffit de renvoyer le jeton généré au contrôleur.

3. Résumé

L'écriture de jetons implique de nombreux processus. Afin d'éviter toute confusion, veillez à définir les codes responsables des différentes tâches selon différentes méthodes. Comme le reflète la méthode grantToken() dans l'exemple ci-dessus, il s'agit d'une méthode de base qui inclut tous les processus, mais différents processus spécifiques sont définis dans d'autres méthodes puis fournis à l'appel de la méthode grantToken().

Après cela, la méthode grantToken() est toujours facile à lire même si elle contient tous les processus.

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!