深度挖掘 Laravel 生命周期

本文首发于个人博客深度挖掘 Laravel 生命周期，转载请注明出处。

这篇文章我们来聊聊「Laravel 生命周期」这个主题。虽然网络上已经有很多关于这个主题的探讨，但这个主题依然值得我们去研究和学习。

我想说的是当我们在决定使用某项技术的时候，除了需要了解它能「做什么」，其实还应当研究它是「怎么做的」。

Laravel 框架或者说任何一个 Web 项目，我们都需要理解它究竟是如何接收到用户发起的 HTTP 请求的；又是如何响应结果给用户的；在处理请求和响应的过程中都存在哪些处理值得深入学习。

所有这些内容其实都包含在「Laravel 生命周期」这个主题里面。

本文较长建议使用合适的 IDE 进行代码查阅；或者通过文中的链接，或是代码注释的「@see」部分直接在 Github 畅读代码。

目录结构

一摘要
二生命周期之始末
- 2.1 加载项目依赖
- 2.2 创建 Laravel 应用实例
  - 2.2.1 创建应用实例
  - 2.2.2 内核绑定
  - 2.2.3 注册异常处理
  - 2.2.4 小结
- 2.3 接收请求并响应
  - 2.3.1 解析内核实例
  - 2.3.2 处理 HTTP 请求
    - 2.3.2.1 创建请求实例
    - 2.3.2.2 处理请求
      - 2.3.2.2.1 启动「引导程序」
      - 2.3.2.2.2 发送请求至路由
- 2.4 发送响应
- 2.5 终止程序
三总结
四生命周期流程图
参考资料

一摘要

Laravel 生命周期（或者说请求生命周期）概括起来主要分为 3 个主要阶段：

加载项目依赖
创建 Laravel 应用实例
接收请求并响应

而这 3 个阶段的处理都发生在入口文件 public/index.php 文件内（public/index.php 是一个新安装的 Laravel 项目默认入口文件）。

然而 index.php 文件仅包含极少的代码，但却出色的完成了一个 HTTP 请求从接收到响应的全部过程，逻辑组织的几近完美。

我们来看下入口文件实现的代码：

<?php
// 阶段一
require __DIR__.'/../vendor/autoload.php';// 阶段二
$app = require_once __DIR__.'/../bootstrap/app.php';// 阶段三
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);$response = $kernel->handle($request = Illuminate\Http\Request::capture()
);$response->send();// 其它
$kernel->terminate($request, $response);

二生命周期之始末

2.1 加载项目依赖

现代 PHP 依赖于 Composer 包管理器，入口文件通过引入由 Composer 包管理器自动生成的类加载程序，可以轻松注册并加载项目所依赖的第三方组件库。

所有组件的加载工作，仅需一行代码即可完成：

require __DIR__.'/../vendor/autoload.php';

2.2 创建 Laravel 应用实例

创建应用实例（或称服务容器），由位于 bootstrap/app.php 文件里的引导程序完成，创建服务容器的过程即为应用初始化的过程，项目初始化时将完成包括：注册项目基础服务、注册项目服务提供者别名、注册目录路径等在内的一些列注册工作。

下面是 bootstrap/app.php 的代码，包含两个主要部分「创建应用实例」和「绑定内核至 APP 服务容器」：

<?php
// 第一部分： 创建应用实例
$app = new Illuminate\Foundation\Application(realpath(__DIR__.'/../')
);// 第二部分： 完成内核绑定
$app->singleton(Illuminate\Contracts\Http\Kernel::class,App\Http\Kernel::class
);$app->singleton(Illuminate\Contracts\Console\Kernel::class,App\Console\Kernel::class
);$app->singleton(Illuminate\Contracts\Debug\ExceptionHandler::class,App\Exceptions\Handler::class
);return $app;

2.2.1 创建应用实例

创建应用实例即实例化 Illuminate\Foundation\Application 这个服务容器，后续我们称其为 APP 容器。在创建 APP 容器主要会完成：注册应用的基础路径并将路径绑定到 APP 容器 、注册基础服务提供者至 APP 容器 、注册核心容器别名至 APP 容器 等基础服务的注册工作。

    /*** Create a new Illuminate application instance.** @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Application.php#L162:27* @param  string|null  $basePath* @return void*/public function __construct($basePath = null){if ($basePath) {$this->setBasePath($basePath);}$this->registerBaseBindings();$this->registerBaseServiceProviders();$this->registerCoreContainerAliases();}

2.2.2 内核绑定

接着将关注的焦点转移到绑定内核部分。

Laravel 会依据 HTTP 请求的运行环境的不同，将请求发送至相应的内核： HTTP 内核或 Console 内核。无论 HTTP 内核还是 Console 内核，它们的作用都是是接收一个 HTTP 请求，随后返回一个响应，就是这么简单。

这篇文章主要研究 HTTP 内核，HTTP 内核继承自 Illuminate\Foundation\Http\Kernel 类.

在「HTTP 内核」内它定义了中间件相关数组；在「Illuminate\Foundation\Http\Kernel」类内部定义了属性名为「bootstrappers」的引导程序数组。

中间件提供了一种方便的机制来过滤进入应用的 HTTP 请求。
「引导程序」包括完成环境检测、配置加载、异常处理、Facades 注册、服务提供者注册、启动服务这六个引导程序。

至于「中间件」和「引导程序」如何被使用的，会在后面的章节讲解。

2.2.3 注册异常处理

项目的异常处理由 App\Exceptions\Handler::class 类完成，这边也不做深入的讲解。

2.2.4 本节小结

通过上面的分析我们可以发现在「创建 Laravel 应用实例」这个阶段它做了很多的基础工作，包括但不限于：创建 APP 容器、注册应用路径、注册基础服务提供者、配置中间件和引导程序等。

2.3 接收请求并响应

在完成创建 APP 容器后即进入了第三个阶段「接收请求并响应」。

「接收请求并响应」有关代码如下：

$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);$response = $kernel->handle($request = Illuminate\Http\Request::capture()
);$response->send();

我们需要逐行分析上面的代码，才能窥探其中的原貌。

2.3.1 解析内核实例

在第二阶段我们已经将 HTTP 内核 和 Console 内核 绑定到了 APP 容器，使用时通过 APP 容器 的 make() 方法将内核解析出来，解析的过程就是内核实例化的过程。

$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);

内核实例化时它的内部究竟又做了哪些操作呢？

进一步挖掘 Illuminate\Foundation\Http\Kernel 内核的 __construct(IlluminateContractsFoundationApplication $app, \Illuminate\Routing\Router $router) 构造方法，它接收 APP 容器 和 路由器 两个参数。

在实例化内核时，构造函数内将在 HTTP 内核定义的「中间件组」注册到路由器，注册完后就可以在实际处理 HTTP 请求前调用这些「中间件」实现过滤请求的目的。

.../*** Create a new HTTP kernel instance. 创建 HTTP 内核实例* * @class Illuminate\Foundation\Http\Kernel* @param  \Illuminate\Contracts\Foundation\Application  $app* @param  \Illuminate\Routing\Router  $router* @return void*/public function __construct(Application $app, Router $router){$this->app = $app;$this->router = $router;$router->middlewarePriority = $this->middlewarePriority;foreach ($this->middlewareGroups as $key => $middleware) {$router->middlewareGroup($key, $middleware);}foreach ($this->routeMiddleware as $key => $middleware) {$router->aliasMiddleware($key, $middleware);}}
...

.../*** Register a group of middleware. 注册中间件组** @class \Illuminate\Routing\Router* @param  string  $name* @param  array  $middleware* @return $this*/public function middlewareGroup($name, array $middleware){$this->middlewareGroups[$name] = $middleware;return $this;}/*** Register a short-hand name for a middleware. 注册中间件别名** @class \Illuminate\Routing\Router* @param  string  $name* @param  string  $class* @return $this*/public function aliasMiddleware($name, $class){$this->middleware[$name] = $class;return $this;}
...

2.3.2 处理 HTTP 请求

之前的所有处理，基本都是围绕在配置变量、注册服务等运行环境的构建上，构建完成后才是真刀真枪的来处理一个「HTTP 请求」。

处理请求实际包含两个阶段：

创建请求实例
处理请求

// 处理请求
$response = $kernel->handle(// 创建请求实例$request = Illuminate\Http\Request::capture()
);

2.3.2.1 创建请求实例

请求实例 Illuminate\Http\Request 的 capture() 方法内部通过 Symfony 实例创建一个 Laravel 请求实例。这样我们就可以获取到用户请求报文的相关信息了。

    /*** Create a new Illuminate HTTP request from server variables.* * @class Illuminate\Http\Request* @return static*/public static function capture(){static::enableHttpMethodParameterOverride();return static::createFromBase(SymfonyRequest::createFromGlobals());}/*** Create an Illuminate request from a Symfony instance.** @see https://github.com/symfony/symfony/blob/master/src/Symfony/Component/HttpFoundation/Request.php* @param  \Symfony\Component\HttpFoundation\Request  $request* @return \Illuminate\Http\Request*/public static function createFromBase(SymfonyRequest $request){if ($request instanceof static) {return $request;}$content = $request->content;$request = (new static)->duplicate($request->query->all(), $request->request->all(), $request->attributes->all(),$request->cookies->all(), $request->files->all(), $request->server->all());$request->content = $content;$request->request = $request->getInputSource();return $request;}

2.3.2.2 处理请求

请求处理发生在 HTTP 内核的 handle() 方法内。

    /*** Handle an incoming HTTP request.** @class Illuminate\Foundation\Http\Kernel* @param  \Illuminate\Http\Request  $request* @return \Illuminate\Http\Response*/public function handle($request){try {$request->enableHttpMethodParameterOverride();$response = $this->sendRequestThroughRouter($request);} catch (Exception $e) {$this->reportException($e);$response = $this->renderException($request, $e);} catch (Throwable $e) {$this->reportException($e = new FatalThrowableError($e));$response = $this->renderException($request, $e);}$this->app['events']->dispatch(new Events\RequestHandled($request, $response));return $response;}

handle() 方法接收一个 HTTP 请求，并最终生成一个 HTTP 响应。

继续深入到处理 HTTP 请求的方法 $this->sendRequestThroughRouter($request) 内部。

    /*** Send the given request through the middleware / router.** @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Http/Kernel.php* @param  \Illuminate\Http\Request  $request* @return \Illuminate\Http\Response*/protected function sendRequestThroughRouter($request){$this->app->instance('request', $request);Facade::clearResolvedInstance('request');$this->bootstrap();return (new Pipeline($this->app))->send($request)->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)->then($this->dispatchToRouter());}

将发现这段代码没有一行废话，它完成了大量的逻辑处理：

首先，将 $request 实例注册到 APP 容器 供后续使用；
之后，清除之前 $request 实例缓存；
然后，启动「引导程序」；
最后，发送请求至路由。

2.3.2.2.1 启动「引导程序」

记得我们在之前「2.2.2 内核绑定」章节，有介绍在「HTTP 内核」中有把「引导程序(bootstrappers)」绑定到了 APP 容器，以及这些引导程序的具体功能。

但是没有聊如何调用这些「引导程序」。

    /*** Send the given request through the middleware / router.** @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Http/Kernel.php* @param  \Illuminate\Http\Request  $request* @return \Illuminate\Http\Response*/protected function sendRequestThroughRouter($request){...// 启动 「引导程序」$this->bootstrap();...}

上面的代码块说明在 $this->bootstrap(); 方法内部有实际调用「引导程序」，而 bootstrap() 实际调用的是 APP 容器的 bootstrapWith(),来看看

... /*** The bootstrap classes for the application. 应用的引导程序** @var array*/protected $bootstrappers = [\Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,\Illuminate\Foundation\Bootstrap\LoadConfiguration::class,\Illuminate\Foundation\Bootstrap\HandleExceptions::class,\Illuminate\Foundation\Bootstrap\RegisterFacades::class,\Illuminate\Foundation\Bootstrap\RegisterProviders::class,\Illuminate\Foundation\Bootstrap\BootProviders::class,];/*** Bootstrap the application for HTTP requests.* * @class Illuminate\Foundation\Http\Kernel* @return void*/public function bootstrap(){if (! $this->app->hasBeenBootstrapped()) {$this->app->bootstrapWith($this->bootstrappers());}}protected function bootstrappers(){return $this->bootstrappers;}
...

最终还是要看 Illuminate\Foundation\Application 的 bootstrapWith() 方法究竟如何来启动这些引导程序的。

    /*** Run the given array of bootstrap classes.* * @class  Illuminate\Foundation\Application APP 容器* @param  array  $bootstrappers* @return void*/public function bootstrapWith(array $bootstrappers){$this->hasBeenBootstrapped = true;foreach ($bootstrappers as $bootstrapper) {$this['events']->fire('bootstrapping: '.$bootstrapper, [$this]);$this->make($bootstrapper)->bootstrap($this);$this['events']->fire('bootstrapped: '.$bootstrapper, [$this]);}}

我们看到在 APP 容器内，会先解析对应的「引导程序」（即实例化），随后调用「引导程序」的 bootstrap() 完成的「引导程序」的启动操作。

作为示例我们随便挑一个「引导程序」来看看其内部的启动原理。

这边我们选 Illuminate\Foundation\Bootstrap\LoadConfiguration::class，它的功能是加载配置文件。

还记得我们讲解「2.2 创建 Laravel 应用实例」章节的时候有「注册应用的基础路径并将路径绑定到 APP 容器」。此时，LoadConfiguration 类就是将 config 目录下的所有配置文件读取到一个集合中，这样我们就可以项目里通过 config() 辅助函数获取配置数据。

<?php
class LoadConfiguration
{/*** Bootstrap the given application.** @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Bootstrap/LoadConfiguration.php* @param  \Illuminate\Contracts\Foundation\Application  $app* @return void*/public function bootstrap(Application $app){$items = [];if (file_exists($cached = $app->getCachedConfigPath())) {$items = require $cached;$loadedFromCache = true;}$app->instance('config', $config = new Repository($items));if (! isset($loadedFromCache)) {$this->loadConfigurationFiles($app, $config);}$app->detectEnvironment(function () use ($config) {return $config->get('app.env', 'production');});date_default_timezone_set($config->get('app.timezone', 'UTC'));mb_internal_encoding('UTF-8');}/*** Load the configuration items from all of the files.** @param  \Illuminate\Contracts\Foundation\Application  $app* @param  \Illuminate\Contracts\Config\Repository  $repository* @return void* @throws \Exception*/protected function loadConfigurationFiles(Application $app, RepositoryContract $repository){$files = $this->getConfigurationFiles($app);if (! isset($files['app'])) {throw new Exception('Unable to load the "app" configuration file.');}foreach ($files as $key => $path) {$repository->set($key, require $path);}}...
}

所有「引导程序」列表功能如下：

IlluminateFoundationBootstrapLoadEnvironmentVariables : 环境检测，通过 DOTENV 组件将 .env 配置文件载入到 $_ENV 变量中；
IlluminateFoundationBootstrapLoadConfiguration : 加载配置文件，这个我们刚刚分析过；
IlluminateFoundationBootstrapHandleExceptions ：异常处理；
IlluminateFoundationBootstrapRegisterFacades ：注册 Facades，注册完成后可以以别名的方式访问具体的类；
IlluminateFoundationBootstrapRegisterProviders : 注册服务提供者，我们在「2.2.1 创建应用实例」已经将基础服务提供者注册到 APP 容器。在这里我们会将配置在 app.php 文件夹下 providers 节点的服务器提供者注册到 APP 容器，供请求处理阶段使用；
IlluminateFoundationBootstrapBootProviders : 启动服务

2.3.2.2.2 发送请求至路由

完成「引导程序」启动操作后，随机进入到请求处理阶段。

    /*** Send the given request through the middleware / router.** @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Http/Kernel.php* @param  \Illuminate\Http\Request  $request* @return \Illuminate\Http\Response*/protected function sendRequestThroughRouter($request){...// 发送请求至路由return (new Pipeline($this->app))->send($request)->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)->then($this->dispatchToRouter());}

在「发送请求至路由」这行代码中，完成了：管道（pipeline）创建、将 $request 传入管道、对 $request 执行「中间件」处理和实际的请求处理四个不同的操作。

在开始前我们需要知道在 Laravel 中有个「中间件」的概念，即使你还不知道，也没关系，仅需知道它的功能是在处理请求操作之前，对请求进行过滤处理即可，仅当请求符合「中间件」的验证规则时才会继续执行后续处理。

有关「管道」的相关知识不在本文讲解范围内。

那么，究竟一个请求是如何被处理的呢？

我们来看看 $this->dispatchToRouter() 这句代码，它的方法声明如下：

/*** Get the route dispatcher callback. 获取一个路由分发器匿名函数** @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Http/Kernel.php* @return \Closure*/protected function dispatchToRouter(){return function ($request) {$this->app->instance('request', $request);return $this->router->dispatch($request);};}

回顾下「2.3.1 解析内核实例」章节，可知我们已经将 Illuminate\Routing\Router 对象赋值给 $this->router 属性。

通过 router 实例的 disptach() 方法去执行 HTTP 请求，在它的内部会完成如下处理：

查找对应的路由实例
通过一个实例栈运行给定的路由
运行在 routes/web.php 配置的匹配到的控制器或匿名函数
返回响应结果

<?php...//  @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Routing/Router.php
class Router implements RegistrarContract, BindingRegistrar
{    /*** Dispatch the request to the application.** @param  \Illuminate\Http\Request  $request* @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse*/public function dispatch(Request $request){$this->currentRequest = $request;return $this->dispatchToRoute($request);}/*** Dispatch the request to a route and return the response.** @param  \Illuminate\Http\Request  $request* @return mixed*/public function dispatchToRoute(Request $request){return $this->runRoute($request, $this->findRoute($request));}/*** Find the route matching a given request. 1. 查找对应的路由实例** @param  \Illuminate\Http\Request  $request* @return \Illuminate\Routing\Route*/protected function findRoute($request){$this->current = $route = $this->routes->match($request);$this->container->instance(Route::class, $route);return $route;}/*** Return the response for the given route. 2. 通过一个实例栈运行给定的路由** @param  Route  $route* @param  Request  $request* @return mixed*/protected function runRoute(Request $request, Route $route){$request->setRouteResolver(function () use ($route) {return $route;});$this->events->dispatch(new Events\RouteMatched($route, $request));return $this->prepareResponse($request,$this->runRouteWithinStack($route, $request));}/*** Run the given route within a Stack "onion" instance. 通过一个实例栈运行给定的路由** @param  \Illuminate\Routing\Route  $route* @param  \Illuminate\Http\Request  $request* @return mixed*/protected function runRouteWithinStack(Route $route, Request $request){$shouldSkipMiddleware = $this->container->bound('middleware.disable') &&$this->container->make('middleware.disable') === true;$middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);// 4. 返回响应结果return (new Pipeline($this->container))->send($request)->through($middleware)->then(function ($request) use ($route) {return $this->prepareResponse(// 3. 运行在 routes/web.php 配置的匹配到的控制器或匿名函数$request, $route->run());});}

执行 $route->run() 的方法定义在 Illuminate\Routing\Route 类中，最终执行「在 routes/web.php 配置的匹配到的控制器或匿名函数」：

    /*** Run the route action and return the response.* * @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Routing/Route.php* @return mixed*/public function run(){$this->container = $this->container ?: new Container;try {if ($this->isControllerAction()) {return $this->runController();}return $this->runCallable();} catch (HttpResponseException $e) {return $e->getResponse();}}

这部分如果路由的实现是一个控制器，会完成控制器实例化并执行指定方法；如果是一个匿名函数则直接调用这个匿名函数。

其执行结果会通过 Illuminate\Routing\Router::prepareResponse($request, $response) 生一个响应实例并返回。

至此，Laravel 就完成了一个 HTTP 请求的请求处理。

2.4 发送响应

经过一系列漫长的操作，HTTP 请求进入的最终章 - 发送响应值客户端 $response->send()。

<?php
// @see https://github.com/laravel/laravel/blob/master/public/index.php// 阶段一
require __DIR__.'/../vendor/autoload.php';// 阶段二
$app = require_once __DIR__.'/../bootstrap/app.php';// 阶段三
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);$response = $kernel->handle($request = Illuminate\Http\Request::capture()
);// 发送响应
$response->send();// 其它
$kernel->terminate($request, $response);

发送响应由 Illuminate\Http\Response 父类 Symfony\Component\HttpFoundation\Response 中的 send() 方法完成。

    /*** Sends HTTP headers and content.* * @see https://github.com/symfony/symfony/blob/master/src/Symfony/Component/HttpFoundation/Response.php* @return $this*/public function send(){$this->sendHeaders();// 发送响应头部信息$this->sendContent();// 发送报文主题if (function_exists('fastcgi_finish_request')) {fastcgi_finish_request();} elseif (!\in_array(PHP_SAPI, array('cli', 'phpdbg'), true)) {static::closeOutputBuffers(0, true);}return $this;}

2.5 终止程序

程序终止，完成终止中间件的调用

// @see https://github.com/laravel/framework/blob/5.6/src/Illuminate/Foundation/Http/Kernel.phppublic function terminate($request, $response)
{$this->terminateMiddleware($request, $response);$this->app->terminate();
}// 终止中间件
protected function terminateMiddleware($request, $response)
{$middlewares = $this->app->shouldSkipMiddleware() ? [] : array_merge($this->gatherRouteMiddleware($request),$this->middleware);foreach ($middlewares as $middleware) {if (! is_string($middleware)) {continue;}list($name, $parameters) = $this->parseMiddleware($middleware);$instance = $this->app->make($name);if (method_exists($instance, 'terminate')) {$instance->terminate($request, $response);}}
}

以上便是 Laravel 的请求生命周期的始末。