Comment le middleware TP5.1 est-il utilisé dans le contrôleur ? (Explication détaillée du processus)

La colonne tutoriellethinkphp framework suivante vous présentera le processus d'utilisation du middleware ThinkPHP5.1 dans le contrôleur. J'espère qu'elle sera utile aux amis dans le besoin !

Le processus d'utilisation du middleware ThinkPHP5.1 dans le contrôleur

Le début de l'utilisation du middleware et la description de mes étapes J'espère que cela pourra vous aider si vous apprenez simplement PHP ou si vous apprenez simplement le framework think. Je peux communiquer avec vous et me laisser progresser.

Je comprends déjà le rôle du middleware dans le framework Thinkphp. Avant que la requête n'atteigne la couche application, lorsque l'utilisateur accède aux ressources, l'en-tête généré ou les paramètres de la requête de l'utilisateur sont saisis dans post ou get ou d'autres requêtes. chemin URL à utiliser, y compris avant ou après l'opération ou l'ordre d'exécution et d'autres solutions. Après l'avoir compris, je pense que cette chose est très utile pour traiter les données des demandes des utilisateurs, ce qui est bien mieux que de les traiter directement dans le contrôleur ou dans le comportement. (J'ai donc lu le manuel de documentation 5.1 avec beaucoup d'enthousiasme).

Après avoir lu le document, suivez la méthode manuelle officielle et tapez le code suivant sur la ligne de commande :
php think make:middleware Check
Il n'y a aucun problème avec la signification de ce code, qui est de produire un répertoire middleware et de créer un nouveau Le nom est Vérifier le fichier middleware
Le contenu est complété normalement sans aucun problème

Le code du document 5.1 est collé selon le plan d'exigences du document

Il est copié entièrement selon le manuel Il n'y a aucun problème. . Confirmez qu'il a été enregistré et qu'il n'y a aucune erreur.

Je confirme par la présente qu'un fichier nommé middleware.php est placé dans le répertoire racine de mon module d'administration comme indiqué dans l'image ci-dessous

Faites simplement une inscription comme celle-ci si vous souhaitez utiliser un middleware sous ce module. , juste prêt à l'emploi.

Ensuite, j'ai ajouté le code comme indiqué dans l'image dans le contrôleur selon le contenu du manuel de documentation et la description du contenu du middleware du contrôleur

,

Il s'est avéré que le code n'a pas été exécuté, je l'ai touché. dans la confusion. Head, d'après ma compréhension, si vous faites cela, vous devriez pouvoir l'appliquer directement, mais l'objet résultat est vide. En désespoir de cause, selon ma propre compréhension, j'ai arrêté le code dans le middleware

Après avoir vu ce que je voulais voir, j'ai testé à nouveau ma $request. Voyant ce que j'attendais depuis longtemps, mon middleware est prêt

À ce stade, les étapes ci-dessus m'indiquent que la première étape est terminée et que je peux maintenant utiliser un middleware pour faire ce que je veux faire

La première étape consiste à changer le nom comme je veux qu'il soit. Il y a trois changements ici.

Après un nouveau rafraîchissement, j'ai découvert qu'il pouvait toujours être utilisé et qu'il fonctionnait parfaitement. Dans cette étape, j'ai également confirmé certaines de mes idées d'utilisation, telles que la création de plusieurs middlewares. Chaque contrôleur doit avoir un correspondant. Je peux effectuer certains de mes propres traitements ici. Vous pouvez également l'utiliser après avoir lu le manuel. les méthodes, y compris les changements dans l’ordre d’exécution, me font réfléchir. A partir de maintenant, le code peut redevenir un peu plus grand.

La deuxième étape consiste à établir des règles fonctionnelles et à coopérer avec les fichiers auto-construits dans la configuration Config pour contrôler l'accès

<?php namespace apphttpmiddleware;
use thinkfacadeConfig;
use thinkfacadeRequest;
/**
登陆接口通用数据配置检测*/
class AdminLoginCheck
{
/**
 * handle  重写处理请求对象的操作函数
 * @param  object Request $request 请求对象
 * @param  object \Closure $next 响应对象
 * @return array 错误返回的信息
 *         code 返回码
 *         msg 返回信息
 *         data 返回数据
 * @return  object 响应对象
 */
public function handle($request, \Closure $next)
{
    // 检测配置，查看该接口服务是否被暂停使用
    if (true !== Config::get(Request::module().&#39;.&#39;.Request::action().&#39;.&#39;.Request::action().&#39;_api&#39;))
    // 如果结果不符合要求则返回错误信息
    exit(json_encode([&#39;code&#39;=>1,'msg'=>'Interface_Pause_service','data'=>'']));
    // 检测配置，是否执行请求验证类型
    if (false !== Config::get(Request::module().'.'.Request::action().'.'.Request::action().'_request'))
    {

        // 登陆请求规则，传入相应方法，查看该接口是否符合请求类需
        $res = self::loginRequestRole(Request::action());
        // 如果结果不符合要求则返回错误信息
        if (true !== $res) exit(json_encode(['code'=>1,'msg'=>'Request_Type_Not_Matching','data'=>'']));
    }
    // 检测配置，是否执行地址限制验证
    if (false !== Config::get(Request::module().'.'.Request::action().'.'.Request::action().'_address'))
    {
        // 客户端访问地址限制请求规则
        $res = self::loginAddressDispose(Request::ip());
        // 如果结果不符合要求则返回错误信息
        if (true !== $res) exit(json_encode(['code'=>1,'msg'=>'Address_Not_Access','data'=>'']));
    }
    // 格式化与处理前台参数
    $request = self::loginParamDispose(Request::action(),$request);
    
    // 继续执行进入到控制器
    return $next($request);
}

/**
 * loginRequestRole 请求类型验证
 * @param  string $scene 根据路径传入方法名称
 * @return bool 验证用户访问的接口是否符合预设的请求要求
 */
protected static function loginRequestRole($scene)
{
    switch ($scene)
    {
        // 登陆页面请求验证
        case 'index':
            if (Request::isGet()) return true;
            else return false;
            break;
        // 登陆接口请求验证
        case 'login':
            if (Request::isPost() || Request::isAjax() || Request::isPjax()) return true;
            else return false;
            break;
        // 登陆接口请求验证
        case 'resetPassword':
            if (Request::isPost() || Request::isAjax() || Request::isPjax()) return true;
            else return false;
            break;
        // 默认验证或者不存在的场景返回
        default:
            return false;
            break;
    }
}

/**
 * loginAddressDispose 地址是否允许访问
 * @param  string $address 需要传入一个address地址
 * @return string     返回错误信息
 * @return bool     检测正确返回真
 */
protected static function loginAddressDispose($address)
{
    // 读取配置内的设置参数
    $data = Config::get(Request::module().'.'.Request::action().'.'.Request::action().'_address_data');
    // 如果配置信息address列表为空则返回不能访问
    if (empty($data)) return false;
    // 循环地址列表信息解开连续address地址列表
    foreach ($data as $key => $val) { if ($val == $address) return true; }
    // 如果继续执行下去依然没有 返回不能访问
    return false;
}

/**
 * loginParamDispose post内容与格式处理
 * @param  string $scene 需要前往的接口名称
 * @param  object $request 请求的对象内容
 * @return object 返回处理过的请求对象
 */
protected static function loginParamDispose($scene,$request)
{
    switch ($scene)
    {
        // 登陆页面
        case 'index':
            break;
        // 登陆接口请求参数处理
        case 'login':
            // 前台用户传入的参数进行调整转换
            $request->username = $request->param('user');
            $request->password = $request->param('pass');
            $request->captcha = $request->param('code');
            // 对记住我进行处理
            $remember = $request->param('remember');
            if (null === $remember) $request->remember = 'shut';
            else $request->remember = 'open';
            break;
        // 重置密码接口参数处理
        case 'resetPassword':
            // 前台用户传入的参数进行调整转换
            $request->username = $request->param('user');
            $request->phone = $request->param('mobile');
            $request->phonecode = $request->param('code');
            $request->password = $request->param('pass');
            $request->repassword = $request->param('repass');
            break;
        // 默认接口或者不存在的场景返回
        default:
            break;
    }
    return $request;
}
}

Maintenant, un simple travail de détection de middleware est terminé. Bien entendu, cette méthode d'écriture est soumise à des exigences fixes, par exemple, dans les accès de contrôle multiples, l'interface doit être unifiée avec l'API et la requête doit être unifiée. sur demande. Quoi qu'il en soit, tout peut être utilisé normalement

Les deux problèmes dont je veux parler séparément sont que vous pouvez réellement continuer à utiliser le contenu qui doit être utilisé dans la configuration

Le premier problème est que le middleware ne l'est pas. omnipotent et ne peut effectuer qu'un certain traitement des demandes, et il est nécessaire d'apporter des paramètres. Ne faites jamais de vérification avancée qui ne répond pas aux exigences. La chose la plus importante ici est de faire une pré-vérification pour rendre les données sûres ou complètes. Le problème n'est pas d'essayer de faire des choses inappropriées dans le middleware. Actions, n'exécutez pas de code super complexe dans le middleware. Si vous utilisez un middleware pour faire du code super complexe ou des opérations longues, j'estime que cela trompera beaucoup de gens. dit ici implique d'utiliser le moins possible les fonctions définies par votre propre bibliothèque de fonctions. Certaines vérifications de code de fonction inévitables peuvent toujours être utilisées, comme le cryptage de mot de passe et des codes similaires

Apprentissage recommandé : "

Les 10 derniers didacticiels vidéo thinkphp.

"

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!