Detailed explanation of Laravel middleware implementation principle

The examples in this article describe Laravel’s middleware implementation principles. Share it with everyone for your reference, the details are as follows:

#1 What is middleware?

For a web application, before a request is actually processed, we may make various judgments on the request before it can be passed to a deeper level. And if we use if else like this, once more and more conditions need to be judged, it will make the code more difficult to maintain, and the coupling between systems will increase, and middleware can solve this problem. We can separate these judgments into middleware, which can easily filter requests.

#2 Middleware in Laravel

In Laravel, the implementation of middleware actually relies on the implementation of the IlluminatePipelinePipeline class. Let's first take a look at the code that triggers the middleware. It's very simple, just transfer the request to a closure after processing and then continue passing it on.

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

#3 Internal implementation of middleware

As mentioned above, middleware is implemented by Pipeline, and its call is in IlluminateRoutingRouter

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

You can see that the middleware execution process is called Three methods. Let’s take a look at the code of these three methods:

send method

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

In fact, the send method doesn’t do anything, it just sets the object that needs to be pipelined in the middleware, here it is the HTTP request instance.

through method

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

through method is also very simple, which is to set the middleware processing that needs to be processed.

then method

Here comes the real difficulty. The then method code is very concise, but it is not easy to understand.

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

Then there is no more, this way all the middleware is passed, isn't it very elegant?

Since the second parameter of aray_reduce requires a function, let’s focus here on the source code of the getSlice() method

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

You may feel dizzy when you see that a closure returns a closure. To simplify it, getSlice() returns a function A, and function A returns function B. Why return two functions? Because we use $next($request) to pass the object during the transfer process, and $next($request) means that the closure is executed. This closure is function A, and then returns function B. , which can be passed to the next middleware.

Let’s simplify the code again:

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

Let’s look at this code again:

//判断是否为闭包，这里就是判断中间件形式是不是闭包，是的话直接执行并且传入$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)); 
}

Look at another picture:

Each iteration passes in the previous close The package and the middleware that need to be executed, because the array is reversed and based on the first-in-last-out feature of the stack, middleware 3 is packaged first, and middleware 1 is in the outermost layer. Remember, array_reduce does not execute middleware code, but wraps middleware.

You should understand after seeing this, array_reduce will eventually return func3, then call_user_func(func3,$this->passable) is actually

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

And the handle code in our middleware is:

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

This is equivalent to return func2($request), the $request here is processed by the previous middleware. So the process of Zhengguo middleware is over, and it will be a bit confusing to understand. Just remember that the outermost call_user_func executes the middleware code in the end. I hope this article will be helpful to everyone's PHP program design based on the Laravel framework.

For more detailed explanations of Laravel middleware implementation principles and related articles, please pay attention to the PHP Chinese website!