Intergiciel (MiddleWare)

Comment générer rapidement un middleware ?

Par la ligne de commande : Générez un middleware Check dans le répertoire app/middleware

php think make:middleware Check

Code du middleware :

<?php

namespace app\middleware;

class Check
{
    public function handle($request, \Closure $next)
    {
        if ($request->param('name') == 'think') {
            return redirect('index/think');
        }

        return $next($request);
    }
}

La méthode d'exécution d'entrée du middleware doit être Il s'agit de 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 paramètre.

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

<?php

namespace app\middleware;

class Check
{
    public function handle($request, \Closure $next, $name)
    {
        if ($name == 'think') {
            return redirect('index/think');
        }

        return $next($request);
    }
}

End scheduling

Le middleware prend en charge la définition d'un mécanisme de rappel avant la fin de la requête. Il vous suffit d'ajouter la méthode end dans la classe middleware.

    public function end(\think\Response $response)
    {
        // 回调行为
    }

Notez qu'il ne peut y avoir de réponse dans la méthode end . Parce que la sortie de réponse à la demande est terminée lorsque le rappel est émis.

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\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\middleware;

class After
{
    public function handle($request, \Closure $next)
    {
		$response = $next($request);

        // 添加中间件执行代码

        return $response;
    }
}

Les méthodes middleware peuvent également prendre en charge l'injection de dépendances.

Prenons un exemple plus pratique. Nous devons déterminer si l'environnement de navigateur actuel est WeChat ou Alipay

namespace app\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 à votre version mobile de l'application
Par exemple : /path/app/mobile/. middleware .php

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

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

Définissez l'alias du middleware

Vous pouvez le prédéfinir directement dans middleware.php dans la configuration de l'application répertoire Définir le middleware (en ajoutant en fait un identifiant d'alias), par exemple :

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

peut prendre en charge l'utilisation d'alias pour définir un ensemble de middleware, par exemple :

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

Enregistrer le middleware

La nouvelle version du middleware est divisée en middleware global, Il existe quatre groupes : middleware applicatif (valable en mode multi-application), middleware de routage et middleware contrôleur.

L'ordre d'exécution est : middleware global -> middleware d'application -> middleware de routage -> middleware de contrôleur

middleware global

le middleware global est dans le fichier middleware.php sous le répertoire app Définition, utilisez la méthode suivante :

<?php

return [
	\app\middleware\Auth::class,
    'check',
    'Hello',
];

L'enregistrement du middleware doit utiliser le nom complet de la classe. Si l'alias (ou le groupe) du middleware a été défini, il peut être utilisé directement.

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, 'admin'],
    'Check',
    ['hello','thinkphp'],
];

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

Middleware applicatif

Si vous utilisez le mode multi-application, la définition du middleware d'application est prise en charge. Vous pouvez ajouter le fichier middleware.php directement sous le répertoire de l'application. La méthode de définition est la même que la définition globale du middleware, mais elle ne prendra effet que sous l'application. .

Middleware de routage

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

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

Prend en charge l'enregistrement de plusieurs middlewares

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

Vous pouvez directement prédéfinir le middleware dans middleware.php dans le répertoire de configuration de l'application (en fait en ajoutant un identifiant d'alias), par exemple :

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

Utilisez ensuite directement l'alias du middleware pour vous inscrire dans la route

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

peut prendre en charge l'utilisation d'alias pour définir un ensemble de middleware, par exemple :

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

Ensuite, inscrivez-vous directement en utilisant ce qui suit méthode Middleware

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

prend en charge l'enregistrement du middleware pour les groupes de routage

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

prend en charge l'enregistrement du middleware pour un certain nom de domaine

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

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

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

Si vous devez définir plusieurs middleware, utilisez La méthode array

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

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

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

ou l'appeler plusieurs fois séparément, en spécifiant différents paramètres

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

Si vous souhaitez qu'un middleware de routage soit exécuté globalement (que la route corresponde ou non non), vous n'avez pas besoin de Défini dans le routage, il est pris en charge pour être défini directement dans le fichier de configuration de routage. Par exemple, ajoutez :

'middleware'    =>    [
    app\middleware\Auth::class,
    app\middleware\Check::class,
],

au fichier de configuration config/route.php De cette façon, tout. les requêtes sous l’application exécuteront le middleware Auth and Check.

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 fonction de fermeture 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 de contrôleur

prend en charge la définition de middleware pour les contrôleurs. Il vous suffit de définir l'attribut middleware dans le contrôleur, par exemple :

<?php
namespace app\controller;

class Index
{
    protected $middleware = ['auth'];

    public function index()
    {
        return 'index';
    }

    public function hello()
    {
        return 'hello';
    }
}

Le middleware d'authentification sera appelé lorsque le contrôleur d'index sera exécuté, et l'utilisation de définitions complètes d'espace de noms est également prise en charge.

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

<?php
namespace app\controller;


class Index
{
    protected $middleware = [ 
    	'auth' 	=> ['except' 	=> ['hello'] ],
        'check' => ['only' 		=> ['hello'] ],
    ];

    public function index()
    {
        return 'index';
    }

    public function hello()
    {
        return 'hello';
    }
}

Le middleware transmet les paramètres au contrôleur

Vous pouvez transmettre les paramètres au contrôleur (ou à d'autres endroits) en attribuant des valeurs à l'objet de requête, par exemple

<?php

namespace app\middleware;

class Hello
{
    public function handle($request, \Closure $next)
    {
        $request->hello = 'ThinkPHP';
        
        return $next($request);
    }
}

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

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

Priorité d'exécution

Si vous avez des exigences strictes sur l'ordre d'exécution du middleware, vous pouvez définir le priorité d'exécution du middleware. Ajouter

return [
    'alias'    => [
        'check' => [
            app\middleware\Auth::class,
            app\middleware\Check::class,
        ],
    ],
    'priority' => [
        think\middleware\SessionInit::class,
        app\middleware\Auth::class,
        app\middleware\Check::class,
    ],
];