Explication détaillée du principe de mise en œuvre du middleware Laravel

Les exemples de cet article décrivent les principes d'implémentation du middleware de Laravel. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

#1 Qu'est-ce que le middleware ?

Pour une application Web, avant qu'une demande ne soit réellement traitée, nous pouvons porter divers jugements sur la demande avant qu'elle puisse être transmise à un niveau plus profond. Et si nous utilisons if else comme ça, une fois de plus en plus de conditions doivent être jugées, cela rendra le code plus difficile à maintenir, et le couplage entre les systèmes augmentera, et le middleware peut résoudre ce problème. Nous pouvons séparer ces jugements en middleware, qui peuvent facilement filtrer les requêtes.

#2 Middleware dans Laravel

Dans Laravel, l'implémentation du middleware repose en fait sur l'implémentation de la classe IlluminatePipelinePipeline. Jetons d'abord un coup d'œil au code qui déclenche le middleware. C'est très simple, il suffit de transférer la requête vers une clôture après traitement puis de continuer à la transmettre.

public function handle($request, Closure $next) {
  //do something for $request
  return $next($request);
}

#3 Implémentation interne du middleware

Comme mentionné ci-dessus, le middleware est implémenté par Pipeline, et son appel est dans IlluminateRoutingRouter In

return (new Pipeline($this->container))
            ->send($request)
            ->through($middleware)
            ->then(function ($request) use ($route) {
              return $this->prepareResponse(
                $request,
                $route->run($request)
              );
            });

vous pouvez voir que le processus d'exécution du middleware appelle trois méthodes. Jetons un coup d'oeil aux codes de ces trois méthodes :

méthode send

public function send($passable){
  $this->passable = $passable;
  return $this;
}

En fait, la méthode send ne fait rien, il définit simplement l'objet qui doit être pipeline dans le middleware est l'instance de requête HTTP dans ce cas.

à travers la méthode

public function through($pipes){
  $this->pipes = is_array($pipes) ? $pipes : func_get_args();
  return $this;
}

à travers la méthode est également très simple, qui consiste à définir quels processus middleware doivent être traités.

méthode then

Voici la partie vraiment difficile. Le code de la méthode then est très concis, mais il n'est pas facile à comprendre.

public function then(Closure $destination){
  //then方法接受一个闭包作为参数，然后经过getInitialSlice包装，而getInitialSlice返回的其实也是一个闭包，如果还不知道什么是闭包先去看PHP文档
  $firstSlice = $this->getInitialSlice($destination);
  //反转中间件数组，主要是利用了栈的特性，用处接下来再说
  $pipes = array_reverse($this->pipes);
  //这个call_user_func先不要看，它其实就是执行了一个array_reduce返回的闭包
  return call_user_func( 
    //接下来用array_reduce来用回调函数处理数组,建议先去PHP文档读懂array_reduce的执行原理。其实arrary_reduce什么事情都没干，就是包装闭包然后移交给call_user_func来执行
    array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
  );
}

Ensuite, il n'y a rien de plus. De cette façon, tout le middleware est passé. N'est-ce pas très élégant ?

Puisque le deuxième paramètre de aray_reduce nécessite une fonction, concentrons-nous sur le code source de la méthode getSlice()

protected function getSlice(){
    return function ($stack, $pipe) {  //这里$stack
      return function ($passable) use ($stack, $pipe) {
        if ($pipe instanceof Closure) {
          return call_user_func($pipe, $passable, $stack);
        } else {
          list($name, $parameters) = $this->parsePipeString($pipe);
          return call_user_func_array([$this->container->make($name), $this->method],
          array_merge([$passable, $stack], $parameters));
        }
      };
    };
}

Regardez Vous pouvez vous sentir étourdi, la fermeture revient à la fermeture. Pour simplifier, getSlice() renvoie une fonction A et la fonction A renvoie la fonction B. Pourquoi renvoyer deux fonctions ? Parce que nous utilisons $next($request) pour transmettre l'objet pendant le processus de transfert, et $next($request) signifie que la fermeture est exécutée. Cette fermeture est la fonction A, puis renvoie la fonction B. , qui peut être transmise. le prochain middleware.

Simplifions encore le code :

//这里的$stack其实就是闭包，第一次遍历的时候会传入$firstSlice这个闭包，以后每次都会传入下面的那个function; 而$pipe就是每一个中间件
array_reduce($pipes, function ($stack, $pipe) { 
  return function ($passable) use ($stack, $pipe) {
  };
}, $firstSlice);

Regardons à nouveau ce code :

//判断是否为闭包，这里就是判断中间件形式是不是闭包，是的话直接执行并且传入$passable[请求实例]和$stack[传递给下一个中间件的闭包],并且返回
if ($pipe instanceof Closure) { 
  return call_user_func($pipe, $passable, $stack);
//不是闭包的时候就是形如这样Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode执行
} else { 
  //解析，把名称返回,这个$parameters看了许久源码还是看不懂，应该是和参数相关，不过不影响我们的分析
  list($name, $parameters) = $this->parsePipeString($pipe);
  //从容器中解析出中间件实例并且执行handle方法
  return call_user_func_array([$this->container->make($name), $this->method],
  //$passable就是请求实例，而$stack就是传递的闭包
  array_merge([$passable, $stack], $parameters)); 
}

Regardez une autre image :

Chaque itération passe dans la fermeture précédente et le middleware qui doit être exécuté en raison de la. reverse Le tableau est transféré, en fonction de la fonctionnalité premier entré, dernier sorti de la pile, de sorte que le middleware 3 est empaqueté en premier et le middleware 1 est la couche la plus externe. N'oubliez pas que array_reduce n'exécute pas le code du middleware, mais encapsule le middleware.

Vous devriez comprendre après avoir vu cela, array_reduce finira par renvoyer func3, puis call_user_func(func3,$this->passable) est en fait

return call_user_func($middleware[0]->handle, $this->passable, func2);

et le handle dans notre middleware Le code est :

public function handle($request, Closure $next) {
  return $next($request);
}

Cela équivaut à return func2($request). La $request ici est traitée par le middleware précédent. Le processus du middleware Zhengguo est donc terminé, et c'est un peu déroutant à comprendre. N'oubliez pas qu'en fin de compte, le call_user_func le plus externe exécute le code du middleware

J'espère que cet article sera utile à la conception de programmes PHP de chacun. sur le framework Laravel aidé.

Pour des explications plus détaillées sur les principes de mise en œuvre du middleware Laravel et les articles connexes, veuillez prêter attention au site Web PHP chinois !