要想了解Laravel的整个运行流程，那么就需要从入口文件下手，再一步步的往下探索，剥开神秘的面纱。在Laravel框架中入口文件就是public文件夹下的index.php文件。Laravel的生命周期也就是从这里开始的，从这里结束。如此优雅的代码却清晰的展示请求到相应的整个生命周期。不妨先看看index.php的源码吧：

<?php
// 第一块
require __DIR__.'/../bootstrap/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);

为了分析上面的代码，将代码分为四块：

第一块

主要用来实现类的自动加载，注册加载composer自动生成的class loader。
第二块

主要来实例化服务容器，Laravel的一些基本服务的注册，核心组件注册等等，当然了也包括容器本身的注册。在注册的过程中服务容器会在对应的属性中记录注册的内容，方便于在程序运行期间提供对应的服务。这部分内容可以称为程序启动准备阶段。
第三块

处理请求，用户发送的请求入口文件是index.php，从生成Illuminate\Http\Request实例，交给handle()进行处理。将该$request实例绑定到第二步生成的$app容器上。并发送相应
第四块

请求的后期清理处理工作，请求结束并进行回调。

服务容器的实例化（详谈第二块代码）

先看看bootstrap\app.php源码：里面有注释

<?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;

关于Illuminate\Foundation\Application.php文件查看源码

应用的基础路径`setBasePath()`

设置注册应用的基础路径，并在容器中绑定这些基础基础路径。

注册基础绑定`registerBaseBindings()`

// 向容器注册基础绑定
 protected function registerBaseBindings()
 {
     static::setInstance($this);
     // 向服务共享实例数组中注册量单例服务，
     // 服务名称分别为`app`和`Illuminate\Container\Container`
     // 对应的实例对象即为服务容器本身
     $this->instance('app', $this);
     $this->instance(Container::class, $this);
 }

主要绑定容器实例本身，服务容器中设置了一个静态变量$instance，该变量是在Illuminate\Container\Container.php中定义,Application类继承了Container类，在Container类中可以通过public static function getInstance()获取服务容器实例。服务容器实例还绑定不同的服务容器别名，记录在$instances共享实例数组（在Container类中）

// 在容器中注册一个已经存在的实例作为共享实例
public function instance($abstract, $instance)
{
    $this->removeAbstractAlias($abstract);
    unset($this->aliases[$abstract]);
    // 检查该类有没有本绑定
    // 如果已经绑定，将触发向容器注册的反弹回调
    $this->instances[$abstract] = $instance;
    if ($this->bound($abstract)) {
        $this->rebound($abstract);
    }
}

注册基础服务提供者`registerBaseServiceProviders()`

服务提供者的注册是非常重要的，因为它给服务容器添加各种服务。这里只是注册了最基本的三个服务：

protected function registerBaseServiceProviders()
{
    $this->register(new EventServiceProvider($this));
    $this->register(new LogServiceProvider($this));
    $this->register(new RoutingServiceProvider($this));
}

在容器里注册一个服务提供者的方法：
public function register($provider, $options = [], $force = false)

源码阅读分析：

首先getProvider($provider)进行判断，如果服务提供者存在则获取这个实例对象。
第二，如果给定$provider是一个string，则通过类名resolveProvider($provider)进行实例对象。
然后，对实例化完成的$provider进行标记为已经注册，markAsRegistered($provider)。
最后，启动规定的服务提供者bootProvider($provider)。

注册核心类别名`registerCoreContainerAliases()`

$aliases数组变量中定义了整个框架的核心服务别名，在解析的过程中需要根据实例化的类或者接口名查找服务别名，然后通过服务别名获取具体的服务。

这里放一张图进行小小的总结：
程序启动准备阶段

核心类实例化(Kernel类)

为什么要服务容器？服务容器实例化后，就可以通过服务容器自动实例化对象了，可以参考上一篇的服务容器。
index.php中Kernel类就是通过服务容器自动创建完成的。

在bootstrap\app.php文件中就注册了三个服务，其中包括了这个核心类接口，在注册服务时，服务名一般是接口。注册的服务是具体的类名，这一般是通过反射基础来实例化的，并通过反射机制解决构造函数的依赖关系，参考上篇的服务容器有讲解。

这里说的核心类是指App\Http\Kernel类，这个类只是定义了$middleware ，$middlewareGroups 和 $routeMiddleware是哪个数组属性。这个类是继承Illuminate\Foundation\Http\Kernel类的，不妨看看这个类中的构造函数，不难看出这个构造函数是存在依赖关系，一个是Illuminate\Contracts\Foundation\Application，还有一个是Illuminate\Routing\Router。他们在服务容器初始化的时候都进行了实例化。

请求实例化`capture()`

在程序启动准备工作完成了之后，就开始请求的实例化。对于请求就是客户端的发送的一个请求报文。这个对应着Illuminate\Http\Request类的实例对象。请求实例的创建是通过Illuminate\Http\Request类中的capture()函数完成的。

// 创建HTTP请求实例
public static function capture()
{
    static::enableHttpMethodParameterOverride();
    // 通过Symfony实例创建一个请求实例
    // 而Symfony请求实例是通过createFromGlobals()静态函数实现的
    return static::createFromBase(SymfonyRequest::createFromGlobals());
}
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;
}

// 通过PHP全局变量创建一个新的请求实例
public static function createFromGlobals()
{
    $server = $_SERVER;
    if ('cli-server' === PHP_SAPI) {
        if (array_key_exists('HTTP_CONTENT_LENGTH', $_SERVER)) {
            $server['CONTENT_LENGTH'] = $_SERVER['HTTP_CONTENT_LENGTH'];
        }
        if (array_key_exists('HTTP_CONTENT_TYPE', $_SERVER)) {
            $server['CONTENT_TYPE'] = $_SERVER['HTTP_CONTENT_TYPE'];
        }
    }
    $request = self::createRequestFromFactory($_GET, $_POST, array(), $_COOKIE, $_FILES, $server);
    if (0 === strpos($request->headers->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded')
        && in_array(strtoupper($request->server->get('REQUEST_METHOD', 'GET')), array('PUT', 'DELETE', 'PATCH'))
    ) {
        parse_str($request->getContent(), $data);
        $request->request = new ParameterBag($data);
    }
    return $request;
}
private static function createRequestFromFactory(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
{
    // 如果定义了请求工厂方法，则可以将自定义的工厂方法赋值给属性$requestFactory
    // 否则通过new static来完成请求的实例。
    // new static语法是后期静态绑定
    // 参照http://php.net/manual/zh/language.oop5.late-static-bindings.php
    if (self::$requestFactory) {
        $request = call_user_func(self::$requestFactory, $query, $request, $attributes, $cookies, $files, $server, $content);
        if (!$request instanceof self) {
            throw new \LogicException('The Request factory must return an instance of Symfony\Component\HttpFoundation\Request.');
        }
        return $request;
    }
    return new static($query, $request, $attributes, $cookies, $files, $server, $content);
}

处理请求`handle()`

完成了请求实例化自然需要对请求实例进行处理，最终返回响应。请求处理是通过Illuminate\Foundation\Http\Kernel.php中handle()进行的，处理是handle中的sendRequestThroughRouter()方法实现的，通过路由请求实例。而enableHttpMethodParameterOverride()方法会是使能请求拒绝，被使能后在请求过程中添加CSRF保护，服务端发送一个CSRF令牌给客户端，也就是一个cookie,在客户端发送POST请求需要将该令牌发送给服务端，否则拒绝处理该请求。

请求前是不是也要准备一下？

直接看源码：
有6个步骤：环境检测、配置加载、异常处理、Facade注册、服务提供者注册、启动服务，通过bootstrap()方法完成准备工作，会调用服务容器$app实例中bootstrapWith()函数,进而通过$this->make($bootstrapper)->bootstrap($this)make方法完成每个准备类的初始化工作，然后调用准备类的bootstrap方法实现准备工作。

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,
];
// 请求通过中间件和路由转发
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());
}
/**
 * Bootstrap the application for HTTP requests.
 */
public function bootstrap()
{
    if (! $this->app->hasBeenBootstrapped()) {
        $this->app->bootstrapWith($this->bootstrappers());
    }
}
// Illuminate\Foundation\Application.php
// 执行bootstrap类的数组
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]);
    }
}

环境检测和配置加载（这部分略过了）
Facade注册
这个怎么理解呢，就是为了美观方便而起的别名，通过别名调用对应实例的属性和方法。这个在很多地方都用到了，比如路由，Route::get()以为是一个Route类，其实不然，只是通过别名实现的。
看源码是最好的老师：

// Illuminate\Foundation\Bootstrap\RegisterFacades.php
public function bootstrap(Application $app)
{
    Facade::clearResolvedInstances();
    Facade::setFacadeApplication($app);
    // Illuminate\Foundation\AliasLoader.php（外观自动加载类）
    // 注意与composer的自动加载类不同
    AliasLoader::getInstance($app->make('config')->get('app.aliases', []))->register();
}
// Illuminate\Foundation\AliasLoader.php
// 创建别名加载的实例对象
public static function getInstance(array $aliases = [])
{
    if (is_null(static::$instance)) {
        return static::$instance = new static($aliases);
    }
    $aliases = array_merge(static::$instance->getAliases(), $aliases);
    static::$instance->setAliases($aliases);
    return static::$instance;
}
// 在自动加载栈中注册一个自动加载函数
public function register()
{
    if (! $this->registered) {
        $this->prependToLoaderStack();
        $this->registered = true;
    }
}

主要分要两个步骤：完成外观自动加载类的实例化并将外观别名数组添加到实例中，然后完成外观自动加载类中自动加载函数的添加。

在laravel中有两个别名，一个是容器核心别名，定义在Application类中，而存储在中Application实例的$aliases属性中，另一个是外观别名，定义在app.php配置文件中，程序运行后存储在AliasLoader类实例中的$aliases属性中。

那像Route::get()是怎么调用的呢？程序首先需要加载类Route，注册了外观别名，那么自动加载栈的第一个函数是AliasLoader类的load()函数，此函数会查找外观别名对应的类名，也就是Illuminate\Support\Facades\Route类，加载这个类，执行get()方法，但是这个类中并没有此静态方法。这个类继承Illuminate\Support\Facades\Facade，也没有get()方法，但是有一个__callStatic()魔术方法，然后调用一个getFacadeAccessor()静态方法，每一个具体的外观类都需要这个静态方法，该方法就是返回别名类所对应的在服务容器中的名称，对于Illuminate\Support\Facades\Route返回的就是“router”，接着通过服务容器获取对应的实例对象，这里对应的Illuminate\Routing\Router类的实例，通过static::$app[$name]实现，最终调用这个类中的get()方法。

服务提供者注册
服务提供注册这位应用程序提供服务支持，在启动的准备阶段进行了基础服务提供者的加载，但这些服务职能应对前期的启动阶段，对于后期请求处理需要用到的数据库服务、认证服务、session服务还不够。

// 服务提供者注册
public function bootstrap(Application $app)
{
    $app->registerConfiguredProviders();
}
// Illuminate\Foundation\Application.php
public function registerConfiguredProviders()
{
    (new ProviderRepository($this, new Filesystem, $this->getCachedServicesPath()))
                ->load($this->config['app.providers']);
}

启动服务
服务提供者必须要实现register()函数，还有一个boot()函数根据需求实现，主要用于启动服务，不是必须的，不实现会在父类中统一处理。对于实现boot()函数的服务提供者，会通过BootProviders类进行统一管理调用。要实现boot()也比较简短，只需要调用服务容器中的boot()函数即可。

// Illuminate\Foundation\Bootstrap.php
public function bootstrap(Application $app)
{
    $app->boot();
}

中间件

在Laravel程序中有中间件的概念，就是对请求的处理，首先是经过中间的处理，然后经过路由的处理，最终到控制器生成响应。这个过程中基本是以装饰者模式的思想进行的。
看看app/Http/Kernel.php源码：

protected $middleware = [
    \Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
    \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
    \App\Http\Middleware\TrimStrings::class,
    \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
];
// Illuminate\Foundation\Http\Kernel.php
// 将请求通过中间件和路由处理
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());
}
// 设置路由分发回调函数
protected function dispatchToRouter()
{
    return function ($request) {
        $this->app->instance('request', $request);
        return $this->router->dispatch($request);
    };
}
// Illuminate\Pipeline\Pipeline.php
public function __construct(Container $container = null)
{
    $this->container = $container;
}
// 设置被送入管道的对象
public function send($passable)
{
    $this->passable = $passable;
    return $this;
}
// 设置导管数组
public function through($pipes)
{
    $this->pipes = is_array($pipes) ? $pipes : func_get_args();
    return $this;
}
// 以一个回调函数为重点执行管道处理
public function then(Closure $destination)
{
    $pipeline = array_reduce(
        // 可以看看carry()
        array_reverse($this->pipes), $this->carry(), $this->prepareDestination($destination)
    );
    return $pipeline($this->passable);
}

路由处理生成响应

回到刚才看到的路由分发回调函数

protected function dispatchToRouter()
{
    return function ($request) {
        $this->app->instance('request', $request);
        // 将请求信息传递给路由信息存储实例
        return $this->router->dispatch($request);
    };
}
// Illuminate\Routing\Router.php
public function dispatch(Request $request)
{
    $this->currentRequest = $request;
    return $this->dispatchToRoute($request);
}
// 分发请求到路由上，并返回响应
public function dispatchToRoute(Request $request)
{
    // 查找对应的路由实例
    $route = $this->findRoute($request);
    $request->setRouteResolver(function () use ($route) {
        return $route;
    });
    $this->events->dispatch(new Events\RouteMatched($route, $request));
    $response = $this->runRouteWithinStack($route, $request);
    return $this->prepareResponse($request, $response);
}
// 通过一个实例栈运行给定的路由
protected function runRouteWithinStack(Route $route, Request $request)
{
    $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                            $this->container->make('middleware.disable') === true;
    $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
    return (new Pipeline($this->container))
                    ->send($request)
                    ->through($middleware)
                    ->then(function ($request) use ($route) {
                        return $this->prepareResponse(
                            $request, $route->run()
                        );
                    });
}

路由的信息都会保存在一个Illuminate\Routing\Router类实例中，而这个类实例存储在kernel类中。

查到请求对应的路由后，请求传递给对应的路由去处理

// Illuminate\Routing\Route.php
// 执行路由动作并返回相应
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();
    }
}

进而交给相应的controller去处理。这部分，首先根据控制器类名通过服务容器进行实例化，再通过调用控制的实例对应的方法来生成响应的主体部分（并非最终的响应）。经过一系列的处理之后生成响应。响应是封装在Illuminate\Http\Response实例中的。

响应的发送和请求生命周期的终止

响应发送`$response->send()`

// Symfony\Component\HttpFoundation\Response.php
// 发送 HTTP响应头和内容
public function send()
{
    // 发送HTTP头部
    $this->sendHeaders();
    // 发送Web响应的内容
    $this->sendContent();
    if (function_exists('fastcgi_finish_request')) {
        fastcgi_finish_request();
    } elseif ('cli' !== PHP_SAPI) {
        static::closeOutputBuffers(0, true);
    }
    return $this;
}

程序终止——生命周期的最后阶段`$kernel->terminate($request, $response)`

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

// Illuminate\Foundation\Http\Kernel.php
public 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);
        }
    }
}

什么东西都是有始有终的，至此请求生命周期结束。

总结

请求到响应整个执行过程，可以分为四个阶段：程序启动准备阶段，请求实例化阶段，请求处理阶段，响应发送和终止程序。
准备阶段：完成一些文件自动加载，服务容器实例化，基础服务提供者注册和Kernel类的实例化。
请求实例化阶段：将请求信息以对象的实行进行存储。
请求处理阶段：准备请求处理环境，完成环境和配置加载等6大东西。通过中间件处理通过路由和控制器处理，生成相应。
请求终止阶段：将响应发送给客户端并终止程序。

Laravel请求生命周期

服务容器的实例化（详谈第二块代码）

应用的基础路径setBasePath()

注册基础绑定registerBaseBindings()

注册基础服务提供者registerBaseServiceProviders()

注册核心类别名registerCoreContainerAliases()