Découvrez comment le middleware de Laravel est implémenté

Comment le middleware de Laravel est-il implémenté ? Cet article présente principalement le principe de mise en œuvre du middleware Laravel et analyse plus en détail les concepts, les principes, les méthodes associées et les compétences d'utilisation du middleware Laravel. Les amis dans le besoin peuvent s'y référer. J'espère que cela aide tout le monde.

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. Voyons d'abord comment déclencher le code du fichier 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

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

Comme vous pouvez le voir, 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, elle définit juste la nécessité de canaliser l'eau dans le middleware. L'objet traité, voici l'instance de requête HTTP.

méthode through

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

La méthode through est également très simple, qui consiste à définir le traitement middleware qui doit être traité.

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
  );
}

Alors il n'y a plus rien. 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 ici 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));
        }
      };
    };
}

Vous pourriez avoir le vertige lorsque vous le voyez Closure renvoie 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);

Regardez à 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 dans le middleware qui doit être exécuté. Étant donné que le tableau est inversé et basé sur la fonctionnalité premier entré, dernier sorti de la pile, le middleware 3 est empaqueté en premier et. le middleware 1 se trouve sur la couche la plus externe. N'oubliez pas que array_reduce n'exécute pas le code du middleware, mais encapsule le middleware.

Vous devez 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 code du handle dans notre middleware est :

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

Cela équivaut à return func2($request), ici Le $ la demande 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 que le call_user_func le plus externe exécute le code du middleware à la fin

Recommandations associées :

Fichier de routage fractionné optimisé Laravel

Laravel utilise le plug-in Pagination pour implémenter une pagination personnalisée

Laravel écrit une interface APP (API)

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!