Découvrez le middleware de ThinkPHP6.0 dans un article

Le middleware ThinkPHP6.0 est divisé en middleware système et middleware d'application. Le middleware système est le middleware intégré au framework principal, et le middleware d'application est le middleware créé dans l'application.

Les principaux scénarios d'application du middleware peuvent inclure le filtrage des données, la détection des autorisations, l'interception des requêtes et d'autres comportements pour les requêtes HTTP. L'utilisation d'un middleware peut simplifier la définition du contrôleur et gérer de nombreux processus métier supplémentaires non essentiels. peut être transmis au middleware pour exécution.

Du point de vue de la portée d'utilisation du middleware, il peut être divisé en middleware global, middleware d'application, middleware de contrôleur et middleware de routage.

Middleware global

Le middleware global est le middleware défini dans appmiddleware.php Aucun middleware n'est activé par défaut, mais il le fait pour les middlewares système pris en charge. vous devez décommenter pour utiliser le middleware système correspondant. Le contenu par défaut est le suivant :

return [
    // 全局请求缓存
    // 'think\middleware\CheckRequestCache',
    // 多语言加载
    // 'think\middleware\LoadLangPack',
    // Session初始化
    // 'think\middleware\SessionInit',
    // 页面Trace调试
    // 'think\middleware\TraceDebug',
];

Certaines fonctions du système sont confiées au middleware pour une gestion unifiée, notamment la mise en cache globale des requêtes et la détection automatique multilingue. Et le chargement, l'initialisation de session et le débogage de trace de page, c'est-à-dire que l'application installée par défaut ne prend pas en charge Session. Vous devez activer le middleware d'initialisation de session globalement avant que Session puisse prendre effet. Pour les applications API, la prise en charge de la fonction Session n'est pas requise.

Vous pouvez ajouter votre middleware d'application dans le fichier de définition global du middleware, mais essayez de vous assurer que le middleware système est exécuté en premier. La définition du middleware doit utiliser le nom de classe complet, qui peut être rapidement créé via la ligne de commande. instructions. Un middleware d'application :

php think make:middleware Test

générera automatiquement une classe middleware appmiddlewareTest avec le contenu suivant :

<?php
namespace app\middleware;
class Test
{
    public function handle($request, \Closure $next)
    {
    }
}

prend également en charge la création de classes middleware en spécifiant l'espace de noms complet

php think make:middleware app\middleware\Hello

Nous ajoutons une sortie de test

<?php
namespace app\middleware;
class Test
{
    public function handle($request, \Closure $next)
    {
    echo &#39;Before Middleware<br/>&#39;;
    $response = $next($request);
    echo &#39;After Middleware<br/>&#39;;
    return $response;
    }
}

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

Ajoutez ensuite

return [
\app\middleware\Test::class,
];

dans la définition globale du middleware. Supposons que la méthode de contrôleur à laquelle nous voulons accéder soit

<?php
namespace app\controller;
class Index
{
    public function hello()
    {
    return &#39;Hello,ThinkPHP!<br/>&#39;;
    }
}

Le résultat de l'accès à la méthode d'action est

Before Middleware
Hello,ThinkPHP!
After Middleware

<.>Vous pouvez voir le processus d'exécution du middleware. À partir du processus d'exécution, il peut être divisé en pré-middleware et post-middleware. Bien entendu, un middleware peut avoir à la fois des comportements pré- et post-. ci - dessus Test middleware . Le code avant $next($request) appartient à la catégorie pré-middleware, et le code qui le suit appartient à la catégorie post-middleware.

Middleware d'application

S'il s'agit d'un mode multi-application, le middleware d'application est le middleware défini dans le nom de l'application middleware.php, et ne sera utilisé que dans cette application Valable ci-dessous, le format de définition est cohérent avec le middleware global.

Middleware de routage

Le middleware de routage signifie qu'un certain middleware ne sera exécuté qu'après la correspondance de la route. Il est défini à l'aide de la méthode middleware dans la définition de la route, par exemple. exemple :

Route::get('hello/:name','index/hello')
    ->middleware(\app\middleware\Hello::class);

Vous pouvez définir un middleware pour les groupes de routage

Route::group(function(){
Route::get('hello/:name','index/hello');
//...
})->middleware(\app\middleware\Hello::class);

Si vous souhaitez exécuter plusieurs middleware, vous pouvez utiliser

Route::group(function(){
Route::get('hello/:name','index/hello');
//...
})->middleware([\app\middleware\Hello::class,\app\middleware\Check::class]);

Pour les middlewares fréquemment utilisés, nous pouvons en définir un Alias, dans le fichier de configuration configmiddleware.php, la définition de la route définie

return [
'hello'=>\app\middleware\Hello::class,
'check'=>\app\middleware\Check::class,
];

peut être modifiée en :

Route::group(function(){
Route::get('hello/:name','index/hello');
//...
})->middleware(['hello','check']);

prend en charge la définition d'alias pour un groupe de middlewares.

return [
'test'=>[\app\middleware\Hello::class,\app\middleware\Check::class],
];

la définition de la route peut être modifié Le middleware

Route::group(function(){
Route::get('hello/:name','index/hello');
//...
})->middleware('test');

prend en charge la transmission d'un paramètre. Le middleware est défini comme suit :

<?php
namespace app\middleware;
class Hello
{
    public function handle($request, \Closure $next, string $name = &#39;&#39;)
    {
    echo &#39;Hello&#39;. $name . &#39;<br/>&#39;;
    return $next($request);
    }
}

Vous pouvez passer le paramètre name dans le deuxième paramètre du middleware de routage sauf

Route::get('hello/:name','index/hello')
    ->middleware('hello', 'middleware');

.

En plus de prendre en charge les paramètres, vous pouvez utiliser l'injection de dépendances dans la méthode handle du middleware.

Middleware du contrôleur

Le middleware du contrôleur ne prend effet que lors de l'accès à un certain contrôleur

<?php
namespace app\controller;
class Hello
{
protected $middleware = [&#39;hello&#39;,&#39;check&#39;];
    public function index()
    {
    return &#39;Hello,ThinkPHP!<br/>&#39;;
    }
}

Puisque le middleware a été défini précédemment Alias, utilisez donc l'alias définition directement ici, sinon vous devez utiliser la définition complète de l'espace de noms.

Par défaut, toute méthode d'opération par laquelle le middleware défini dans le contrôleur accède au contrôleur sera exécutée. Parfois, vous ne souhaitez pas que toutes les opérations doivent exécuter le middleware. Il existe deux façons de définir le middleware du contrôleur. . Filtrage d'exécution des fichiers.

<?php
namespace app\controller;
class Index
{
protected $middleware = [
&#39;hello&#39; => [&#39;only&#39;  => [&#39;hello&#39;]],
&#39;check&#39; => [&#39;except&#39;=> [&#39;hello&#39;]],
];
    public function hello()
    {
    return &#39;Hello,ThinkPHP!<br/>&#39;;
    }
    public function check()
    {
    return &#39;this action require check!<br/>&#39;;
    }    
}

Le middleware hello ne sera exécuté que lorsque l'opération hello du contrôleur Index est exécutée, tandis que le middleware de vérification sera exécuté à l'exception de la méthode hello. Vous pouvez réellement tester l'effet spécifique.

Middleware transmettant les paramètres

Il existe de nombreuses façons de transmettre des paramètres entre le middleware et le contrôleur. Une méthode simple consiste à utiliser Request pour transmettre des paramètres.

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

Le middleware transmettant les paramètres au contrôleur doit être complété dans le middleware frontal. Le contrôleur ne peut pas recevoir les paramètres transmis par le post-middleware au contrôleur.

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

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

Il existe de nombreuses vidéos

Tutoriels ThinkPHP

, toutes sur le site Web PHP chinois, bienvenue pour apprendre en ligne ! Cet article est reproduit à partir de : https://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!