Que signifie le middleware thinkphp ?

À partir de la version 5.1.6+, la prise en charge du middleware est officiellement introduite.

Le middleware est principalement utilisé pour intercepter ou filtrer les requêtes HTTP des applications et effectuer les traitements métier nécessaires.

Définir le middleware

Vous pouvez générer rapidement un middleware via des instructions de ligne de commande

php think make:middleware Check

Cette commande générera une vérification sous le répertoire application/http/middleware middleware.

<?php
namespace app\http\middleware;
class Check
{
    public function handle($request, \Closure $next)
    {
        if ($request->param(&#39;name&#39;) == &#39;think&#39;) {
            return redirect(&#39;index/think&#39;);
        }
        return $next($request);
    }
}

La méthode d'exécution d'entrée du middleware doit être la méthode handle, et le premier paramètre est l'objet Request, et le deuxième paramètre est une fermeture.

La valeur de retour de la méthode handle du middleware doit être un objet Response.

Dans ce middleware, nous effectuons un traitement de redirection lorsque nous jugeons que le paramètre name de la requête en cours est égal à think. Dans le cas contraire, la demande sera transmise à la suite de la candidature. Pour continuer à transmettre la requête à l'application, appelez simplement la fonction de rappel $next avec $request comme argument.

Sous certaines conditions, vous pouvez utiliser le troisième paramètre pour transmettre des paramètres supplémentaires.

<?php
namespace app\http\middleware;
class Check
{
    public function handle($request, \Closure $next, $name)
    {
        if ($name == &#39;think&#39;) {
            return redirect(&#39;index/think&#39;);
        }
        return $next($request);
    }
}

Middleware pré/post

Le fait que le middleware soit exécuté avant ou après que l'opération spécifique soit demandée dépend entièrement de la définition du middleware lui-même.

Ce qui suit est un middleware pour le pré-comportement

<?php
namespace app\http\middleware;
class Before
{
    public function handle($request, \Closure $next)
    {
        // 添加中间件执行代码
        return $next($request);
    }
}

Ce qui suit est un middleware pour le post-comportement

<?php
namespace app\http\middleware;
class After
{
    public function handle($request, \Closure $next)
    {
$response = $next($request);
        // 添加中间件执行代码
        return $response;
    }
}

Un exemple plus pratique, nous devons déterminer la navigation actuelle L'environnement du serveur est WeChat ou Alipay

namespace app\http\middleware;
/**
 * 访问环境检查，是否是微信或支付宝等
 */
class InAppCheck
{
    public function handle($request, \Closure $next)
    {
        if (preg_match('~micromessenger~i', $request->header('user-agent'))) {
            $request->InApp = 'WeChat';
        } else if (preg_match('~alipay~i', $request->header('user-agent'))) {
            $request->InApp = 'Alipay';
        }
        return $next($request);
    }
}

Ajoutez ensuite un fichier middleware.php dans votre module version mobile

Par exemple : /path/application/mobile/middleware.php

return [
    app\http\middleware\InAppCheck::class,
];

Ensuite, dans votre contrôleur, vous pouvez obtenir la valeur pertinente via $this->request->InApp

Enregistrer le middleware

Middleware de routage

La méthode d'enregistrement middleware la plus couramment utilisée consiste à enregistrer le middleware de routage

Route::rule('hello/:name','hello')
->middleware('Auth');

ou à utiliser le nom complet de la classe middleware

Route::rule('hello/:name','hello')
->middleware(app\http\middleware\Auth::class);

pour prendre en charge plusieurs enregistrements Middleware

Route::rule('hello/:name','hello')
->middleware(['Auth', 'Check']);

Version V5.1.7+, vous pouvez directement prédéfinir le middleware dans middleware.php dans le répertoire de configuration de l'application (en ajoutant effectivement un identifiant d'alias), par exemple :

return [
'auth'=>app\http\middleware\Auth::class,
    'check'=>app\http\middleware\Check::class
];

Utilisez ensuite l'alias du middleware pour vous inscrire

Route::rule('hello/:name','hello')
->middleware(['auth', 'check']);

directement dans la route. A partir de la version V5.1.8+, vous pouvez utiliser des alias pour définir un ensemble de middleware, par exemple :

return [
'check'=>[
    app\http\middleware\Auth::class,
   app\http\middleware\Check::class
    ],
];

Ensuite, utilisez directement la méthode suivante Middleware d'inscription<🎜. >

Route::rule('hello/:name','hello')
->middleware('check');

Prend en charge le middleware d'enregistrement pour les groupes de routage

Route::group('hello', function(){
Route::rule('hello/:name','hello');
})->middleware('Auth');

La version V5.1.8+ commence à prendre en charge le middleware d'enregistrement pour un certain nom de domaine

Route::domain('admin', function(){
// 注册域名下的路由规则
})->middleware('Auth');

Si vous devez transmettre des paramètres supplémentaires pour transmettre au middleware, vous pouvez utiliser

Route::rule('hello/:name','hello')
->middleware('Auth:admin');

Si vous utilisez une définition constante, vous pouvez transmettre les paramètres du middleware dans le deuxième paramètre.

Route::rule('hello/:name','hello')
->middleware(Auth::class, 'admin');

Si vous devez définir plusieurs middlewares, utilisez la méthode tableau

Route::rule('hello/:name','hello')
->middleware([Auth::class, 'Check']);

pour transmettre le même paramètre supplémentaire

Route::rule('hello/:name','hello')
->middleware([Auth::class, 'Check'], 'admin');

ou spécifiez les paramètres du middleware individuellement.

Route::rule('hello/:name','hello')
->middleware(['Auth:admin', 'Check:editor']);

Utilisez des fermetures pour définir un middleware

Vous n'êtes pas obligé d'utiliser des classes de middleware Dans certaines situations simples, vous pouvez utiliser des fermetures pour définir un middleware, mais la fermeture. La fonction doit renvoyer une instance d’objet Response.

Route::group('hello', function(){
Route::rule('hello/:name','hello');
})->middleware(function($request,\Closure $next){
    if ($request->param('name') == 'think') {
        return redirect('index/think');
    }
    
return $next($request);
});

Middleware global

Vous pouvez définir le fichier middleware.php sous le répertoire de l'application, en utilisant la méthode suivante :

<?php
return [
\app\http\middleware\Auth::class,
    &#39;Check&#39;,
    &#39;Hello&#39;,
];

Enregistrement du middleware le nom complet de la classe doit être utilisé, ou si aucun espace de noms n'est spécifié, alors apphttpmiddleware sera utilisé comme espace de noms.

L'ordre d'exécution du middleware global est l'ordre de définition. Les paramètres du middleware peuvent être transmis lors de la définition du middleware global, et deux méthodes sont prises en charge.

<?php
return [
[\app\http\middleware\Auth::class, &#39;admin&#39;],
    &#39;Check&#39;,
    &#39;Hello:thinkphp&#39;,
];

La définition ci-dessus signifie que le paramètre admin est transmis au middleware Auth et le paramètre thinkphp est transmis au middleware Hello.

Middleware de module

À partir de la version V5.1.8+, la définition du middleware de module est prise en charge. Vous pouvez ajouter le fichier middleware.php directement sous le répertoire du module. La méthode est la suivante. La définition du middleware d'application est la même, mais elle ne prendra effet que sous ce module.

Middleware de contrôleur

À partir de la version V5.1.17+, il est pris en charge pour définir un middleware pour les contrôleurs. Tout d'abord, votre contrôleur doit hériter de la classe thinkController du système, puis définir l'attribut middleware dans le contrôleur, par exemple :

<?php
namespace app\index\controller;
use think\Controller;
class Index extends Controller
{
    protected $middleware = [&#39;Auth&#39;];
    public function index()
    {
        return &#39;index&#39;;
    }
    public function hello()
    {
        return &#39;hello&#39;;
    }
}

Lorsque le contrôleur d'index est exécuté, le middleware Auth sera appelé. utilisation de la dénomination complète.

Si vous devez définir le fonctionnement effectif au milieu du contrôleur, vous pouvez le définir comme suit :

<?php
namespace app\index\controller;
use think\Controller;
class Index extends Controller
{
    protected $middleware = [ 
    &#39;Auth&#39; => [&#39;except&#39; => [&#39;hello&#39;] ],
        &#39;Hello&#39; => [&#39;only&#39; => [&#39;hello&#39;] ],
    ];
    public function index()
    {
        return &#39;index&#39;;
    }
    public function hello()
    {
        return &#39;hello&#39;;
    }
}

Le middleware transmet les paramètres au contrôleur

Vous pouvez transmettre les paramètres de la requête au contrôleur (ou à d'autres endroits) par affectation d'objet, tel que

<?php
namespace app\http\middleware;
class Hello
{
    public function handle($request, \Closure $next)
    {
        $request->hello = &#39;ThinkPHP&#39;;
        
        return $next($request);
    }
}

Notez que le nom de la variable transmis ne doit pas entrer en conflit avec la variable param.

Ensuite, vous pouvez l'utiliser directement dans la méthode du contrôleur

public function index(Request $request)
{
return $request->hello; // ThinkPHP
}

Cet article provient de la colonne d'articles techniques du framework ThinkPHP :

http://www.php.cn/phpkj/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!