Laravel学习笔记之Middleware源码解析

野性酷女 2022-01-29 04:31 342阅读 0赞

![wKiom1fgnGrSU-zzAABryjtX9CI667.jpg-wh_651x-s_1910087785.jpg-wh_651x-s_1782518267.jpg][]

说明：本文主要学习Laravel的Middleware的源码设计思想，并将学习心得分享出来，希望对别人有所帮助。Laravel学习笔记之Decorator Pattern已经聊过Laravel使用了Decorator Pattern来设计Middleware，看Laravel源码发现其巧妙用了Closure和PHP的一些数组函数来设计Middleware。

开发环境：Laravel5.3 + PHP7 + OS X 10.11

**PHP内置函数array\_reverse、array\_reduce、call\_user\_func和call\_user\_func\_array**

看Laravel源码之前，先看下这几个PHP内置函数的使用。首先array\_reverse()函数比较简单，倒置数组，看测试代码：

1.  $pipes = \[
2.  'Pipe1',
3.  'Pipe2',
4.  'Pipe3',
5.  'Pipe4',
6.  'Pipe5',
7.  'Pipe6',
8.  \];
9.  
10. $pipes = array\_reverse($pipes);
11. 
12. var\_dump($pipes);
13. 
14. // output
15. array(6) \{
16. \[0\] =>
17. string(5) "Pipe6"
18. \[1\] =>
19. string(5) "Pipe5"
20. \[2\] =>
21. string(5) "Pipe4"
22. \[3\] =>
23. string(5) "Pipe3"
24. \[4\] =>
25. string(5) "Pipe2"
26. \[5\] =>
27. string(5) "Pipe1"
28. \}

array\_reduce内置函数主要是用回调函数去迭代数组中每一个值，并且每一次回调得到的结果值作为下一次回调的初始值，最后返回最终迭代的值：

1.  /\*\*
2.  \* @link http://php.net/manual/zh/function.array-reduce.php
3.  \* @param int $v
4.  \* @param int $w
5.  \*
6.  \* @return int
7.  \*/
8.  function rsum($v, $w)
9.  \{
10. $v += $w;
11. return $v;
12. \}
13. 
14. $a = \[1, 2, 3, 4, 5\];
15. // 10为初始值
16. $b = array\_reduce($a, "rsum", 10);
17. // 最后输出 (((((10 + 1) + 2) + 3) + 4) + 5) = 25
18. echo $b . PHP\_EOL;

call\_user\_func()是执行回调函数，并可输入参数作为回调函数的参数，看测试代码：

1.  class TestCallUserFunc
2.  \{
3.  public function index($request)
4.  \{
5.  echo $request . PHP\_EOL;
6.  \}
7.  \}
8.  
9.  /\*\*
10. \* @param $test
11. \*/
12. function testCallUserFunc($test)
13. \{
14. echo $test . PHP\_EOL;
15. \}
16. 
17. // \[$class, $method\]
18. call\_user\_func(\['TestCallUserFunc', 'index'\], 'pipes'); // 输出'pipes'
19. 
20. // Closure
21. call\_user\_func(function ($passable) \{
22. echo $passable . PHP\_EOL;
23. \}, 'pipes'); // 输出'pipes'
24. 
25. // function
26. call\_user\_func('testCallUserFunc' , 'pipes'); // 输出'pipes'

call\_user\_func\_array与call\_user\_func基本一样，只不过传入的参数是数组：

1.  class TestCallUserFuncArray
2.  \{
3.  public function index($request)
4.  \{
5.  echo $request . PHP\_EOL;
6.  \}
7.  \}
8.  
9.  /\*\*
10. \* @param $test
11. \*/
12. function testCallUserFuncArray($test)
13. \{
14. echo $test . PHP\_EOL;
15. \}
16. 
17. // \[$class, $method\]
18. call\_user\_func\_array(\['TestCallUserFuncArray', 'index'\], \['pipes'\]); // 输出'pipes'
19. 
20. // Closure
21. call\_user\_func\_array(function ($passable) \{
22. echo $passable . PHP\_EOL;
23. \}, \['pipes'\]); // 输出'pipes'
24. 
25. // function
26. call\_user\_func\_array('testCallUserFuncArray' , \['pipes'\]); // 输出'pipes'

**Middleware源码解析**

了解了几个PHP内置函数后再去看下Middleware源码就比较简单了。Laravel学习笔记之IoC Container实例化源码解析已经聊过Application的实例化，得到index.php中的$app变量，即\\Illuminate\\Foundation\\Application的实例化对象。然后继续看下index.php的源码：

1.  /\*\*
2.  \* @var \\App\\Http\\Kernel $kernel
3.  \*/
4.  $kernel = $app->make(Illuminate\\Contracts\\Http\\Kernel::class);
5.  
6.  $response = $kernel->handle(
7.  $request = Illuminate\\Http\\Request::capture()
8.  );
9.  
10. $response->send();
11. 
12. $kernel->terminate($request, $response);

首先从容器中解析出Kernel对象，对于\\App\\Http\\Kernel对象的依赖:\\Illuminate\\Foundation\\Application和\\Illuminate\\Routing\\Router，容器会自动解析。看下Kernel的构造函数：

1.  /\*\*
2.  \* Create a new HTTP kernel instance.
3.  \*
4.  \* @param \\Illuminate\\Contracts\\Foundation\\Application $app
5.  \* @param \\Illuminate\\Routing\\Router $router
6.  \*/
7.  public function \_\_construct(Application $app, Router $router)
8.  \{
9.  $this->app = $app;
10. $this->router = $router;
11. 
12. foreach ($this->middlewareGroups as $key => $middleware) \{
13. $router->middlewareGroup($key, $middleware);
14. \}
15. 
16. foreach ($this->routeMiddleware as $key => $middleware) \{
17. $router->middleware($key, $middleware);
18. \}
19. \}
20. 
21. // \\Illuminate\\Routing\\Router内的方法
22. public function middlewareGroup($name, array $middleware)
23. \{
24. $this->middlewareGroups\[$name\] = $middleware;
25. 
26. return $this;
27. \}
28. 
29. public function middleware($name, $class)
30. \{
31. $this->middleware\[$name\] = $class;
32. 
33. return $this;
34. \}

构造函数初始化了几个中间件数组，$middleware\[ \], $middlewareGroups\[ \]和$routeMiddleware\[ \]，Laravel5.0的时候记得中间件数组还没有分的这么细。然后就是Request的实例化：

1.  $request = Illuminate\\Http\\Request::capture()

这个过程以后再聊吧，不管咋样，得到了Illuminate\\Http\\Request对象，然后传入Kernel中：

1.  /\*\*
2.  \* Handle an incoming HTTP request.
3.  \*
4.  \* @param \\Illuminate\\Http\\Request $request
5.  \* @return \\Illuminate\\Http\\Response
6.  \*/
7.  public function handle($request)
8.  \{
9.  try \{
10. $request->enableHttpMethodParameterOverride();
11. 
12. $response = $this->sendRequestThroughRouter($request);
13. \} catch (Exception $e) \{
14. $this->reportException($e);
15. 
16. $response = $this->renderException($request, $e);
17. \} catch (Throwable $e) \{
18. $this->reportException($e = new FatalThrowableError($e));
19. 
20. $response = $this->renderException($request, $e);
21. \}
22. 
23. $this->app\['events'\]->fire('kernel.handled', \[$request, $response\]);
24. 
25. return $response;
26. \}

主要是sendRequestThroughRouter($request)函数执行了转换操作：把\\Illuminate\\Http\\Request对象转换成了\\Illuminate\\Http\\Response，然后通过Kernel的send()方法发送给客户端。同时，顺便触发了kernel.handled内核已处理请求事件。OK，重点关注下sendRequestThroughRouter($request)方法：

1.  /\*\*
2.  \* Send the given request through the middleware / router.
3.  \*
4.  \* @param \\Illuminate\\Http\\Request $request
5.  \* @return \\Illuminate\\Http\\Response
6.  \*/
7.  protected function sendRequestThroughRouter($request)
8.  \{
9.  $this->app->instance('request', $request);
10. 
11. Facade::clearResolvedInstance('request');
12. 
13. /\* 依次执行$bootstrappers中每一个bootstrapper的bootstrap()函数,做了几件准备事情:
14. 1. 环境检测
15. 2. 配置加载
16. 3. 日志配置
17. 4. 异常处理
18. 5. 注册Facades
19. 6. 注册Providers
20. 7. 启动服务
21. protected $bootstrappers = \[
22. 'Illuminate\\Foundation\\Bootstrap\\DetectEnvironment',
23. 'Illuminate\\Foundation\\Bootstrap\\LoadConfiguration',
24. 'Illuminate\\Foundation\\Bootstrap\\ConfigureLogging',
25. 'Illuminate\\Foundation\\Bootstrap\\HandleExceptions',
26. 'Illuminate\\Foundation\\Bootstrap\\RegisterFacades',
27. 'Illuminate\\Foundation\\Bootstrap\\RegisterProviders',
28. 'Illuminate\\Foundation\\Bootstrap\\BootProviders',
29. \];\*/
30. $this->bootstrap();
31. 
32. return (new Pipeline($this->app))
33. \->send($request)
34. \->through($this->app->shouldSkipMiddleware() ? \[\] : $this->middleware)
35. \->then($this->dispatchToRouter());
36. \}

$this->bootstrap()主要是做了程序初始化工作，以后再聊具体细节。然后是Pipeline来传输Request，Laravel中把Pipeline管道单独拿出来作为一个service(可看Illuminate/Pipeline文件夹)，说明Pipeline做的事情还是很重要的：主要就是作为Request的传输管道，依次通过$middlewares\[ \], 或middlewareGroups\[ \], 或$routeMiddleware\[ \]这些中间件的前置操作，和控制器的某个action或者直接闭包处理得到Response，然后又带着Reponse依次通过$middlewares\[ \], 或middlewareGroups\[ \], 或$routeMiddleware\[ \]这些中间件的后置操作得到准备就绪的Response，然后通过send()发送给客户端。

这个过程有点像汽车工厂的生产一样，Pipeline是传送带，起初Request可能就是个汽车空壳子，经过传送带旁边的一个个机械手middleware@before的过滤和操作(如检查零件刚度是不是合格，壳子尺寸是不是符合要求，给壳子喷个漆或抹个油啥的)，然后进入中央控制区加个发动机(Controller@action，或Closure)，然后又继续经过检查和附加操作middleware@after(如添加个挡风镜啥的)，然后通过门外等着的火车直接运送到消费者手里send()。在每一步装配过程中，都需要Service来支持，Service是通过Container来解析\{make()\}提供的，并且Service是通过ServiceProvider注册绑定\{bind(),singleton(),instance()\}到Container中的。

看下Pipeline的send()和through()源码：

1.  public function send($passable)
2.  \{
3.  $this->passable = $passable;
4.  
5.  return $this;
6.  \}
7.  
8.  public function through($pipes)
9.  \{
10. $this->pipes = is\_array($pipes) ? $pipes : func\_get\_args();
11. 
12. return $this;
13. \}

send()传送的对象是Request，through()所要通过的对象是$middleware\[ \]，OK，再看下dispatchToRouter()的源码直接返回一个Closure：

1.  protected function dispatchToRouter()
2.  \{
3.  return function ($request) \{
4.  $this->app->instance('request', $request);
5.  
6.  return $this->router->dispatch($request);
7.  \};
8.  \}

然后重点看下then()函数源码：

1.  public function then(Closure $destination)
2.  \{
3.  $firstSlice = $this->getInitialSlice($destination);
4.  
5.  $pipes = array\_reverse($this->pipes);
6.  
7.  // $this->passable = Request对象
8.  return call\_user\_func(
9.  array\_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
10. );
11. \}
12. 
13. protected function getInitialSlice(Closure $destination)
14. \{
15. return function ($passable) use ($destination) \{
16. return call\_user\_func($destination, $passable);
17. \};
18. \}

这里假设$middlewares为(尽管源码中$middlewares只有一个CheckForMaintenanceMode::class)：

1.  $middlewares = \[
2.  CheckForMaintenanceMode::class,
3.  AddQueuedCookiesToResponse::class,
4.  StartSession::class,
5.  ShareErrorsFromSession::class,
6.  VerifyCsrfToken::class,
7.  \];

先获得第一个slice(这里作者是比作'洋葱'，一层层的穿过，从一侧穿过到另一侧，比喻倒也形象)并作为array\_reduce()的初始值，就像上文中array\_reduce()测试例子中的10这个初始值，这个初始值现在是个闭包：

1.  $destination = function ($request) \{
2.  $this->app->instance('request', $request);
3.  return $this->router->dispatch($request);
4.  \};
5.  
6.  $firstSlice = function ($passable) use ($destination) \{
7.  return call\_user\_func($destination, $passable);
8.  \};

OK,然后要对$middlewares\[ \]进行翻转，为啥要翻转呢?

看过这篇Laravel学习笔记之Decorator Pattern文章就会发现，在Client类利用Decorator Pattern进行依次装饰的时候，是按照$middlewares\[ \]数组中值倒着new的：

1.  public function wrapDecorator(IMiddleware $decorator)
2.  \{
3.  $decorator = new VerifyCsrfToken($decorator);
4.  $decorator = new ShareErrorsFromSession($decorator);
5.  $decorator = new StartSession($decorator);
6.  $decorator = new AddQueuedCookiesToResponse($decorator);
7.  $response = new CheckForMaintenanceMode($decorator);
8.  
9.  return $response;
10. \}

这样才能得到一个符合$middlewares\[ \]顺序的$response对象：

1.  $response = new CheckForMaintenanceMode(
2.  new AddQueuedCookiesToResponse(
3.  new StartSession(
4.  new ShareErrorsFromSession(
5.  new VerifyCsrfToken(
6.  new Request()
7.  )
8.  )
9.  )
10. )
11. );

看下array\_reduce()中的迭代回调函数getSlice()\{这个迭代回调函数比作剥洋葱时获取每一层洋葱slice，初始值是$firstSlice\}：

1.  protected function getSlice()
2.  \{
3.  return function ($stack, $pipe) \{
4.  return function ($passable) use ($stack, $pipe) \{
5.  if ($pipe instanceof Closure) \{
6.  return call\_user\_func($pipe, $passable, $stack);
7.  \} elseif (! is\_object($pipe)) \{
8.  list($name, $parameters) = $this->parsePipeString($pipe);
9.  $pipe = $this->container->make($name);
10. $parameters = array\_merge(\[$passable, $stack\], $parameters);
11. \} else\{
12. $parameters = \[$passable, $stack\];
13. \}
14. 
15. return call\_user\_func\_array(\[$pipe, $this->method\], $parameters);
16. \};
17. \};
18. \}

返回的是个闭包，仔细看下第二层闭包里的逻辑，这里$middlewares\[ \]传入的是每一个中间件的名字，然后通过容器解析出每一个中间件对象：

1.  $pipe = $this->container->make($name);

并最后用call\_user\_func\_array(\[$class, $method\], array $parameters)来调用这个$class里的$method方法，参数是$parameters。

**Demo**

接下来写个demo看下整个流程。先简化下getSlice()函数，这里就默认$pipe传入的是类名称(整个demo中所有class都在同一个文件内)：

1.  // PipelineTest.php
2.  
3.  // Get the slice in every step.
4.  function getSlice()
5.  \{
6.  return function ($stack, $pipe) \{
7.  return function ($passable) use ($stack, $pipe) \{
8.  /\*\*
9.  \* @var Middleware $pipe
10. \*/
11. return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
12. \};
13. \};
14. \}

再把$middlewares\[ \]中五个中间件类写上，对于前置操作和后置操作做个简化，直接echo字符串：

1.  // PipelineTest.php 
2.  <?php
3.  
4.  interface Middleware
5.  \{
6.  public static function handle($request, Closure $closure);
7.  \}
8.  
9.  class CheckForMaintenanceMode implements Middleware
10. \{
11. public static function handle($request, Closure $next)
12. \{
13. echo $request . ': Check if the application is in the maintenance status.' . PHP\_EOL;
14. $next($request);
15. \}
16. \}
17. 
18. class AddQueuedCookiesToResponse implements Middleware
19. \{
20. public static function handle($request, Closure $next)
21. \{
22. $next($request);
23. echo $request . ': Add queued cookies to the response.' . PHP\_EOL;
24. \}
25. \}
26. 
27. class StartSession implements Middleware
28. \{
29. public static function handle($request, Closure $next)
30. \{
31. echo $request . ': Start session of this request.' . PHP\_EOL;
32. $next($request);
33. echo $request . ': Close session of this response.' . PHP\_EOL;
34. \}
35. \}
36. 
37. class ShareErrorsFromSession implements Middleware
38. \{
39. public static function handle($request, Closure $next)
40. \{
41. $next($request);
42. echo $request . ': Share the errors variable from response to the views.' . PHP\_EOL;
43. \}
44. \}
45. 
46. class VerifyCsrfToken implements Middleware
47. \{
48. public static function handle($request, Closure $next)
49. \{
50. echo $request . ': Verify csrf token when post request.' . PHP\_EOL;
51. $next($request);
52. \}
53. \}

给上完整的一个Pipeline类，这里的Pipeline对Laravel中的Pipeline做了稍微简化，只选了几个重要的函数：

1.  // PipelineTest.php
2.  
3.  class Pipeline
4.  \{
5.  /\*\*
6.  \* @var array
7.  \*/
8.  protected $middlewares = \[\];
9.  
10. /\*\*
11. \* @var int
12. \*/
13. protected $request;
14. 
15. // Get the initial slice
16. function getInitialSlice(Closure $destination)
17. \{
18. return function ($passable) use ($destination) \{
19. return call\_user\_func($destination, $passable);
20. \};
21. \}
22. 
23. // Get the slice in every step.
24. function getSlice()
25. \{
26. return function ($stack, $pipe) \{
27. return function ($passable) use ($stack, $pipe) \{
28. /\*\*
29. \* @var Middleware $pipe
30. \*/
31. return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
32. \};
33. \};
34. \}
35. 
36. // When process the Closure, send it as parameters. Here, input an int number.
37. function send(int $request)
38. \{
39. $this->request = $request;
40. return $this;
41. \}
42. 
43. // Get the middlewares array.
44. function through(array $middlewares)
45. \{
46. $this->middlewares = $middlewares;
47. return $this;
48. \}
49. 
50. // Run the Filters.
51. function then(Closure $destination)
52. \{
53. $firstSlice = $this->getInitialSlice($destination);
54. 
55. $pipes = array\_reverse($this->middlewares);
56. 
57. $run = array\_reduce($pipes, $this->getSlice(), $firstSlice);
58. 
59. return call\_user\_func($run, $this->request);
60. \}
61. \}

OK,现在开始传入Request,这里简化为一个整数而不是Request对象了：

1.  // PipelineTest.php
2.  
3.  /\*\*
4.  \* @return \\Closure
5.  \*/
6.  function dispatchToRouter()
7.  \{
8.  return function ($request) \{
9.  echo $request . ': Send Request to the Kernel, and Return Response.' . PHP\_EOL;
10. \};
11. \}
12. 
13. $request = 10;
14. 
15. $middlewares = \[
16. CheckForMaintenanceMode::class,
17. AddQueuedCookiesToResponse::class,
18. StartSession::class,
19. ShareErrorsFromSession::class,
20. VerifyCsrfToken::class,
21. \];
22. 
23. (new Pipeline())->send($request)->through($middlewares)->then(dispatchToRouter());

执行php PipelineTest.php得到Response：

1.  10: Check if the application is in the maintenance status.
2.  10: Start session of this request.
3.  10: Verify csrf token when post request.
4.  10: Send Request to the Kernel, and Return Response.
5.  10: Share the errors variable from response to the views.
6.  10: Close session of this response.
7.  10: Add queued cookies to the response.

一步一步分析下执行过程：

1.首先获取$firstSlice

1.  $destination = function ($request) \{
2.  echo $request . ': Send Request to the Kernel, and Return Response.' . PHP\_EOL;
3.  \};
4.  $firstSlice = function ($passable) use ($destination) \{
5.  return call\_user\_func($destination, $passable);
6.  \};

这时经过初始化后：

1.  $this->request = 10;
2.  $pipes = \[
3.  VerifyCsrfToken::class,
4.  ShareErrorsFromSession::class,
5.  StartSession::class,
6.  AddQueuedCookiesToResponse::class,
7.  CheckForMaintenanceMode::class,
8.  \];

2.执行第一次getSlice()后的结果作为新的$stack，其值为：

1.  $stack = $firstSlice;
2.  $pipe = VerifyCsrfToken::class;
3.  $stack\_1 = function ($passable) use ($stack, $pipe) \{
4.  /\*\*
5.  \* @var Middleware $pipe
6.  \*/
7.  return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
8.  \};

3.执行第二次getSlice()后的结果作为新的$stack，其值为：

1.  $stack = $stack\_1;
2.  $pipe = ShareErrorsFromSession::class;
3.  $stack\_2 = function ($passable) use ($stack, $pipe) \{
4.  /\*\*
5.  \* @var Middleware $pipe
6.  \*/
7.  return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
8.  \};

4.执行第三次getSlice()后的结果作为新的$stack，其值为：

1.  $stack = $stack\_2;
2.  $pipe = StartSession::class;
3.  $stack\_3 = function ($passable) use ($stack, $pipe) \{
4.  /\*\*
5.  \* @var Middleware $pipe
6.  \*/
7.  return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
8.  \};

5.执行第四次getSlice()后的结果作为新的$stack，其值为：

1.  $stack = $stack\_3;
2.  $pipe = AddQueuedCookiesToResponse::class;
3.  $stack\_4 = function ($passable) use ($stack, $pipe) \{
4.  /\*\*
5.  \* @var Middleware $pipe
6.  \*/
7.  return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
8.  \};

6.执行第五次getSlice()后的结果作为新的$stack，其值为：

1.  $stack = $stack\_4;
2.  $pipe = CheckForMaintenanceMode::class;
3.  $stack\_5 = function ($passable) use ($stack, $pipe) \{
4.  /\*\*
5.  \* @var Middleware $pipe
6.  \*/
7.  return call\_user\_func\_array(\[$pipe, 'handle'\], \[$passable, $stack\]);
8.  \};

这时，$stack\_5也就是then()里的$run,然后执行call\_user\_func($run, 10),看执行过程:

1.$stack\_5(10) = CheckForMaintenanceMode::handle(10, $stack\_4)

1.  echo '10: Check if the application is in the maintenance status.' . PHP\_EOL;
2.  stack\_4(10);

2.$stack\_4(10) = AddQueuedCookiesToResponse::handle(10, $stack\_3)

1.  $stack\_3(10);
2.  
3.  echo '10: Add queued cookies to the response.' . PHP\_EOL;

3.$stack\_3(10) = StartSession::handle(10, $stack\_2)

1.  echo '10: Start session of this request.' . PHP\_EOL;
2.  
3.  $stack\_2(10);
4.  echo '10: Close session of this response.' . PHP\_EOL;

4.$stack\_2(10) = ShareErrorsFromSession::handle(10, $stack\_1)

1.  $stack\_1(10);
2.  
3.  echo '10: Share the errors variable from response to the views.' . PHP\_EOL;

5.$stack\_1(10) = VerifyCsrfToken::handle(10, $firstSlice)

1.  echo '10: Verify csrf token when post request.' . PHP\_EOL;
2.  
3.  $firstSlice(10);

6.$firstSlice(10) =

1.  $firstSlice(10) = call\_user\_func($destination, 10) = echo '10: Send Request to the Kernel, and Return Response.' . PHP\_EOL;

OK,再把上面执行顺序整理一下：

1.  1. echo '10: Check if the application is in the maintenance status.' . PHP\_EOL; // 第一个step
2.  
3.  3\_1. echo '10: Start session of this request.' . PHP\_EOL; // 第三个step
4.  
5.  5. echo '10: Verify csrf token when post request.' . PHP\_EOL; // 第五个step
6.  
7.  6.echo '10: Send Request to the Kernel, and Return Response.' . PHP\_EOL; //第六个step
8.  
9.  4. echo '10: Share the errors variable from response to the views.' . PHP\_EOL; // 第四个step
10. 
11. 3\_2. echo '10: Close session of this response.' . PHP\_EOL; // 第三个step
12. 
13. 2. echo '10: Add queued cookies to the response.' . PHP\_EOL; // 第二个step

经过上面的一步步分析，就能很清楚Laravel源码中Middleware的执行步骤了。再复杂的步骤只要一步步拆解，就很清晰每一步的逻辑，然后把步骤组装，就能知道全貌了。

总结：本文主要学习了Laravel的Middleware的源码，学习完后就知道没有什么神秘之处，只需要动手一步步拆解就行。后面再学习下Container的源码，到时见。

作者：lx1036

来源：51CTO

[wKiom1fgnGrSU-zzAABryjtX9CI667.jpg-wh_651x-s_1910087785.jpg-wh_651x-s_1782518267.jpg]: http://s3.51cto.com/wyfs02/M01/87/C0/wKiom1fgnGrSU-zzAABryjtX9CI667.jpg-wh_651x-s_1910087785.jpg-wh_651x-s_1782518267.jpg