Analyse des idées pour créer un middleware Laravel

Il existe de nombreux principes de mise en œuvre pour analyser le middleware Laravel sur Internet, mais je me demande si des lecteurs ne comprennent pas en le lisant. Comment l'auteur a-t-il pensé à utiliser la fonction array_reduce ?

Recommandé : tutoriel Laravel

Cet article part de mon propre point de vue et simule comment j'implémenterais cette fonction middleware si j'étais l'auteur, et comment trouver et utiliser la fonction correspondante.

Qu'est-ce que le middleware Laravel

Le middleware Laravel fournit un mécanisme pour interrompre le flux du programme d'origine sans modifier le code logique et le gérer via le middleware Certains événements ou étendre certaines fonctions . Par exemple, un middleware de journalisation peut facilement enregistrer les journaux de requêtes et de réponses sans modifier le code logique.

Alors simplifions le processus d'exécution du logiciel. Il existe maintenant un noyau de classe de base, et voici son code Laravel

#捕获请求
$request = Illuminate\Http\Request::capture()
#处理请求
$response = $kernel->handle($request);

La fonction du code est de capturer une requête et de renvoyer une réponse. . Voici le segment de code qui est ensuite distribué à la logique d'exécution spécifique et renvoie les résultats.

Donc, si vous souhaitez ajouter un élément de logique avant ou après l'exécution de la méthode $kernel->handle(), comment l'écririez-vous ? C'est à peu près le suivant :

$request = Illuminate\Http\Request::capture()
function midware(){
    before()#在之前执行的语句集合
    #####    
    $response = $kernel->handle($request);
    #####
    after()#在之后执行的语句集合
}

Évidemment, il n'y a aucun problème à écrire de cette façon, mais elle n'a aucune évolutivité. Vous devez modifier cette méthode pour exécuter quoi que ce soit. Il est impossible de l'encapsuler dans le contenu principal. du cadre. Comment l'améliorer

Définissez une classe middleware à exécuter appelée middleware La classe implémente deux méthodes, before() et after(), et le code est le suivant.

#配置项中有一项配置中间件：
middleware = '';
$request = Illuminate\Http\Request::capture()
function midware(){
    middleware.before()
    #####    
    $response = $kernel->handle($request);
    #####
    middleware.after()
}

Est-ce que cela résout le problème ? Cela résout le problème sans le changer. Mais que se passe-t-il si nous avons besoin de plusieurs middlewares ? La chose la plus simple à laquelle penser est : définir un tableau de middleware middleware_arr, chaque classe de middleware contient avant et méthodes after. Le code est le suivant :

#配置项中有middleware_arr
middleware_arr=array();
$request = Illuminate\Http\Request::capture()
function midware(){
    foreach(middleware_arr as middleware){
       middleware.before()
    }
    #####    
    $response = $kernel->handle($request);
    #####
    foreach(middleware_arr as middleware){
        middleware.after()
    }
}

Bien qu'il soit un peu démodé, il résout le problème. Mais il y a toujours un problème avec cela, c'est-à-dire comment transmettre les paramètres au middleware ? Est-ce que ça va comme suit :

$request = Illuminate\Http\Request::capture()
function midware(){
    foreach(middleware_arr as middleware){
       middleware.before($request)
    }
    #####    
    $response = $kernel->handle($request);
    #####
    foreach(middleware_arr as middleware){
        middleware.after($response)
    }
}

Cela semble résoudre le problème, mais si vous l'analysez attentivement, vous le ferez. constatez qu'à chaque fois qu'il est donné, le middleware est entièrement la requête $ d'origine, ce qui ne fonctionne évidemment pas comme suit :

$request = Illuminate\Http\Request::capture()
function midware(){
    foreach(middleware_arr as middleware){
       $request = middleware.before($request)
    }
    #####    
    $response = $kernel->handle($request);
    #####
    foreach(middleware_arr as middleware){
        $response = middleware.after($response)
    }
}

Une autre question est, en supposant qu'il y ait deux middlewares A et B, que devrait-il faire. être l'ordre d'exécution :

$request = Illuminate\Http\Request::capture()
$request = A.before($request);
$request = B.before($request);
$response = $kernel->handle($request);
$response = A.after();
$response = B.after();

Est-ce raisonnable ? Ce n'est pas facile à dire. Supposons qu'il existe un middleware qui enregistre les journaux de requêtes et de réponses à ce stade, peu importe où vous le placez, il ne peut pas parfaitement. enregistrer la demande initiale et le journal de la demande finale. Est-il nécessaire d'écrire deux classes pour une situation similaire, une pour enregistrer la requête et la placer en premier dans le tableau middleware, et une pour traiter la réponse et la placer à la dernière place du tableau ? Il est préférable d'inverser le tableau middleware_arr avant d'exécuter le foreach suivant, afin qu'il réponde aux exigences :

$request = Illuminate\Http\Request::capture()
$request = A.before($request);
$request = B.before($request);
$response = $kernel->handle($request);
$response = B.after();
$response = A.after();

Mais j'ai aussi commencé à me demander s'il existe une meilleure solution à cette solution démodée et inflexible. en observant cette séquence d'exécution, nous avons constaté qu'il s'agit d'un style wrapper (style oignon). Pouvons-nous trouver une solution plus flexible et plus élégante au problème suivant ? En regardant la structure ci-dessus, cela semble toujours un peu familier. C'est comme si la fonction de A enveloppait la fonction de B, et que la fonction de B incluait l'initiale. code d'exécution. Il est facile d'appeler des fonctions au sein d'une fonction, mais chaque middleware ici ne connaît pas l'existence de l'autre, donc les fonctions à exécuter par un autre middleware doivent être passées au niveau supérieur. Ici, une fonction de fermeture et une fonction php sont. utilisé. array_reduce(),

array_reduce définition de la fonction : Mixed array_reduce ( array $input , callable $function [, Mixed $initial = NULL ] )

<?php
 function  rsum ( $v ,  $w )
{
     $v  +=  $w ;
    return  $v ;
}
function  rmul ( $v ,  $w )
{
     $v  *=  $w ;
    return  $v ;
}
 $a  = array( 1 ,  2 ,  3 ,  4 ,  5 );
 $x  = array();
 $b  =  array_reduce ( $a ,  "rsum" );
 $c  =  array_reduce ( $a ,  "rmul" ,  10 );
 ?>   
 #输出：
这将使 $b  的值为 15， $c  的值为 1200（= 10*1*2*3*4*5）

array_reduce() agira sur le rappel. fonctionner de manière itérative sur chaque cellule du tableau d’entrée, réduisant ainsi le tableau à une valeur unique. Nous regroupons plusieurs fonctions en une seule fonction qui est finalement appelée.

#我们先假设只有一个middleware,叫log来简化情况,这里的类应该是一个类全路径，我这里就简单的写一下，要不然太长了。
    $middleware_arr = ['log'];
#最终要执行的代码先封装成一个闭包，要不然没有办法传递到内层,如果用函数名传递函数的话，是没有办法传递参数的。
    $default = function() use($request){
        return $kernel->handle($request);
    }
    $callback = array_reduce($middleware_arr,function($stack,$pipe) {
        return function() use($stack,$pipe){
          return $pipe::handle($stack);
        };
    },$default);
    
    
# 这里 callback最终是 这样一个函数：
    function() use($default,$log){
          return $log::handle($default);
        };
        
#所以每一个中间件都需要有一个方法handle方法,方法中要对传输的函数进行运行，类似如下，这里我类名就不大写了
    class log implements Milldeware {
        public static function handle(Closure $func)
        {
            $func();
        }
    }
    
#这里不难看出可以加入中间件自身逻辑如下：
 class log implements Milldeware {
        public static function handle(Closure $func)
        {
            #这里可以运行逻辑块before()
            $func();
            #这里可以运行逻辑块after()
        }
    }

De cette façon, lors de l'exécution de la fonction de rappel, la séquence d'exécution est la suivante :

exécute d'abord la méthode log::haddle(), et

exécute la Méthode log::before()

Exécutez la méthode par défaut, exécutez $kernel->handle($request)

Exécutez la méthode log::after()

puis simulez plusieurs situations comme suit :

    $middleware_arr = ['csrf','log'];
#最终要执行的代码先封装成一个闭包，要不然没有办法传递到内层,如果用函数名传递函数的话，是没有办法传递参数的。
    $default = function() use($request){
        return $kernel->handle($request);
    }
    $callback = array_reduce($middleware_arr,function($stack,$pipe) {
        return function() use($stack,$pipe){
          return $pipe::handle($stack);
        };
    },$default);
    
    
# 这里 callback最终是 执行这样：
    $log::handle(function() use($default,$csrf){
                    return $csrf::handle($default);
                });

La séquence d'exécution est la suivante :

1. Exécutez d'abord la méthode log::haddle (y compris la fonction de fermeture csrf::handle),

2. Exécuter la méthode log::before ()

3 Exécuter la fermeture signifie exécuter $csrf::handle($default)

4. ()

5. Exécutez la méthode par défaut et exécutez $kernel->handle($request)

6. Exécutez la méthode csrf::after()

7. Exécutez la méthode log::after()

Notez qu'un autre problème ici est que les résultats générés par le middleware ne sont pas transmis. Le même objectif peut être atteint en modifiant les ressources partagées. nécessaire de transmettre réellement la valeur au prochain middleware.

C'est la fin de ce document. En fait, de nombreuses articulations n'étaient comprises que lorsque j'ai écrit cet article. En particulier, j'ai une compréhension plus approfondie de l'utilisation et de la compréhension des fonctions de fermeture. Les fonctions de fermeture peuvent retarder l'utilisation des ressources. Par exemple, les instructions qui ne sont pas adaptées à l'exécution pour le moment doivent être transmises plus tard. pour les encapsuler et les distribuer. C'est quelque chose que les fonctions traditionnelles ne peuvent pas faire.

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!