Laravel的生命周期

亦凉 2023-10-06 17:39 1阅读 0赞

#### Laravel启动过程 ####

*  Laravel的生命周期 A
 *   *  PHP 的运行模式
     *  PHP 的生命周期
     *  作用
     *  Laravel 的生命周期
     *   *  请求过程
         *  Laravel 的请求步骤
 *  Laravel的生命周期 B
 *   *  laravel/public/index.php
     *  laravel/boostrap/app.php
     *  laravel\\vendor\\laravel\\framework\\src\\Illuminate\\Foundation\\Http\\Kernel.php
 *  Laravel 服务容器模块
 *   *  简介
     *  框架调用分析
     *  Application初始化
     *  单元测试Application的bootstrap启动分析
     *  Http访问Application的bootstrap启动分析
     *  重要的类变量数组
     *   *  aliases数组
         *  abstractAliases数组
         *  instances数组
         *  bindings数组
         *  resolved数组
         *  with 数组
         *  contextual数组
         *  tags数组
         *  extenders数组
         *  methodBindings数组
         *  buildStack数组
         *  reboundCallbacks数组
         *  serviceProviders数组
         *  alias
 *  laravel 的源代码生命周期

## Laravel的生命周期 A ##

世间万物皆有生命周期，当我们使用任何工具时都需要理解它的工作原理，那么用起来就会得心应手，应用开发也是如此。理解了它的原理，那么使用起来就会游刃有余。

在了解 Laravel 的生命周期前，我们先回顾一下PHP 的生命周期。

### PHP 的运行模式 ###

PHP两种运行模式是WEB模式、CLI模式。

当我们在终端敲入php这个命令的时候，使用的是CLI模式。

当使用Nginx或者别web服务器作为宿主处理一个到来的请求时,使用的是WEB模式。

### PHP 的生命周期 ###

当我们请求一个php文件时,PHP 为了完成这次请求，会发生5个阶段的生命周期切换:

*  1 模块初始化（MINIT），即调用 php.ini 中指明的扩展的初始化函数进行初始化工作，如 mysql 扩展。
 *  2 请求初始化（RINIT），即初始化为执行本次脚本所需要的变量名称和变量值内容的符号表，如 $\_SESSION变量。
 *  3 执行该PHP脚本。
 *  4 请求处理完成(Request Shutdown)，按顺序调用各个模块的 RSHUTDOWN 方法，对每个变量调用 unset 函数，如 unset $\_SESSION 变量。
 *  5 关闭模块(Module Shutdown) ， PHP调用每个扩展的 MSHUTDOWN 方法，这是各个模块最后一次释放内存的机会。这意味着没有下一个请求了。

WEB模式和CLI（命令行）模式很相似，区别是：

**CLI 模式会在每次脚本执行经历完整的5个周期，因为你脚本执行完不会有下一个请求；**

**WEB模式为了应对并发，可能采用多线程，因此生命周期1和5有可能只执行一次，下次请求到来时重复2-4的生命周期，这样就节省了系统模块初始化所带来的开销。**

可以看出PHP生命周期是很对称的。说了这么多，就是为了定位Laravel运行在哪里，没错，Laravel仅仅运行再 第三个阶段：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16]

### 作用 ###

理解这些，你就可以优化你的 Laravel 代码，可以更加深入的了解 Laravel 的singleton（单例）。

至少你知道了，每一次请求结束，PHP 的变量都会 unset，Laravel 的 singleton 只是在某一次请求过程中的singleton；

你在 Laravel 中的静态变量也不能在多个请求之间共享，因为每一次请求结束都会 unset。

理解这些概念，是写高质量代码的第一步，也是最关键的一步。因此记住，PHP是一种脚本语言，所有的变量只会在这一次请求中生效，下次请求之时已被重置，而不像Java静态变量拥有全局作用。

### Laravel 的生命周期 ###

概述

Laravel 的生命周期从public\\index.php开始，从public\\index.php结束。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16 1]

#### 请求过程 ####

下面是 public\\index.php的全部源码,更具体来说可以分为四步：

<?php
    define('LARAVEL_START', microtime(true));
    
    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);

以下是四步详细的解释是：composer自动加载需要的类

*  1 文件载入composer生成的自动加载设置，包括所有你 composer require的依赖。
 *  2 生成容器 Container，Application实例，并向容器注册核心组件（HttpKernel，ConsoleKernel ，ExceptionHandler）（对应代码2，容器很重要，后面详细讲解）。
 *  3 处理请求，生成并发送响应（对应代码3，毫不夸张的说，你99%的代码都运行在这个小小的handle 方法里面）。
 *  4 请求结束，进行回调（对应代码4，还记得可终止中间件吗？没错，就是在这里回调的）。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16 2]

#### Laravel 的请求步骤 ####

第一步：注册加载composer自动生成的class loader  
就是加载初始化第三方依赖。

第二步：生成容器 Container  
并向容器注册核心组件，是从 bootstrap/app.php 脚本获取 Laravel 应用实例，

第三步：这一步是重点，处理请求，并生成发送响应。  
请求被发送到 HTTP 内核或 Console 内核，这取决于进入应用的请求类型。

> 取决于是通过浏览器请求还是通过控制台请求。这里我们主要是通过浏览器请求。

**HTTP 内核继承自 Illuminate\\Foundation\\Http\\Kernel 类，该类定义了一个 bootstrappers 数组，这个数组中的类在请求被执行前运行，这些 bootstrappers 配置了错误处理、日志、检测应用环境以及其它在请求被处理前需要执行的任务。**

protected $bootstrappers = [
            //注册系统环境配置 （.env）
            'Illuminate\Foundation\Bootstrap\DetectEnvironment',
            //注册系统配置（config）
            'Illuminate\Foundation\Bootstrap\LoadConfiguration',
            //注册日志配置
            'Illuminate\Foundation\Bootstrap\ConfigureLogging',
            //注册异常处理
            'Illuminate\Foundation\Bootstrap\HandleExceptions',
            //注册服务容器的门面，Facade 是个提供从容器访问对象的类。
            'Illuminate\Foundation\Bootstrap\RegisterFacades',
            //注册服务提供者
            'Illuminate\Foundation\Bootstrap\RegisterProviders',
            //注册服务提供者 `boot`
            'Illuminate\Foundation\Bootstrap\BootProviders',
        ];

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16 3]

## Laravel的生命周期 B ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWd1YW5nMTAy_size_16_color_FFFFFF_t_70]

### laravel/public/index.php ###

/**
     * laravel的启动时间
     */
    define('LARAVEL_START', microtime(true));
    
    /**
     * 加载项目依赖。
     * 现代PHP依赖于Composer包管理器，入口文件通过引入由Composer包管理器。
     * 自动生成的类加载程序，可以轻松注册并加载所依赖的第三方组件库。
     */
    require __DIR__.'/../vendor/autoload.php';
    
    /**
     * 创建laravel应用实例。
     */
    $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);

### laravel/boostrap/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;

### laravel\\vendor\\laravel\\framework\\src\\Illuminate\\Foundation\\Http\\Kernel.php ###

class Kernel implements KernelContract
    {
        
        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,                    // 注册服务提供者boot
        ];
    
        // 处理请求
        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;
        }
    
        protected function sendRequestThroughRouter($request)
        {
        
            # 一、将$request实例注册到APP容器
            $this->app->instance('request', $request);
    
            # 二、清除之前的$request实例缓存
            Facade::clearResolvedInstance('request');
    
            # 三、启动引导程序
            $this->bootstrap();
    
            # 四、发送请求
            return (new Pipeline($this->app)) //创建管道
                        ->send($request)      //发送请求
                        ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)  //通过中间件
                        ->then($this->dispatchToRouter());  //分发到路由
        }
    
        # 启动引导程序
        public function bootstrap()
        {
        
            if (! $this->app->hasBeenBootstrapped()) {
        
                $this->app->bootstrapWith($this->bootstrappers());
            }
        }
        
        # 路由分发
        protected function dispatchToRouter()
        {
        
            return function ($request) {
        
                $this->app->instance('request', $request);
    
                return $this->router->dispatch($request);
            };
        }
    
        #  终止程序
        public function terminate($request, $response)
        {
        
            $this->terminateMiddleware($request, $response);
    
            $this->app->terminate();
        }

## Laravel 服务容器模块 ##

### 简介 ###

服务容器是一个用于管理类依赖和执行依赖注入的强大工具。是整个框架的核心；

几乎所有的服务容器绑定都是在服务提供者中完成。

### 框架调用分析 ###

在框架直接生成服务容器的只有一处，在`bootstrap/app.php`，通过`require`引用会返回服务容器实例。通过`require`引用有两处，一处是`public/index.php`，服务器访问的入口；另一处是`tests/CreatesApplication.php`，是单元测试的入口；

如果想在项目各处中调用，可以调用`$app = Illuminate\Container\Container::getInstance()`或者全局帮助函数`app()`获取服务容器实例（也就是`Illuminate\Foundation/Application`实例）；

`Illuminate\Foundation/Application`是对`Illuminate\Container\Container`的又一层封装；

### Application初始化 ###

那么实例化`Illuminate\Foundation/Application`时，做了什么呢？

**第一步**，设置应用的根目录，并同时注册核心目录到服务容器中；核心的目录有以下

*  `path`：目录`app`的位置
 *  `path.base`：项目根目录的位置
 *  `path.lang`：目录`resources/lang`的位置
 *  `path.config`：目录`config`的位置
 *  `path.public`：目录`public`的位置
 *  `path.storage`：目录`storage`的位置
 *  `path.database`：目录`database`的位置
 *  `path.resources`：目录`resources`的位置
 *  `path.bootstrap`：目录`bootstrap`的位置

**第二步**，将当前`Illuminate\Foundation/Application`实例保存到`$instance`类变量，并同时绑定到服务容器作单例绑定，绑定名为`app`或`Container::class`；

**第三步**，顺序分别执行注册`Illuminate\Events\EventServiceProvider`、`Illuminate\Log\LogServiceProvider`和`Illuminate\Routing\RoutingServiceProvider`三个服务提供者；

注册服务提供者的顺序如下：

*  如果类变量`$serviceProviders`已经存在该服务提供者并且不需要强制重新注册，则返回服务提供者实例`$provider`；
 *  未注册过当前服务提供者，则继续执行以下；
 *  如果存在`register`方法，执行服务提供者的`register`方法；
 *  将当前服务提供者`$provider`实例保存到类变量`$serviceProviders`数组中，同时标记类变量`$loadedProviders[get_class($provider)]`的值为`true`；
 *  判断类变量`$booted`是否为`true`，如果是`true`，则执行服务提供者的`boot`方法；（类变量`$booted`应该是标志是否所有服务提供者均注册，框架是否启动）

**第四步**，注册核心类别名；  
比如`\Illuminate\Foundation\Application::class`、`\Illuminate\Contracts\Container\Container::class`起别名为`app`；

### 单元测试Application的bootstrap启动分析 ###

启动代码很简洁，

Route::get('dev', 'Dev@index');
    
    public function index()
    {
        
         // require 初始化分析上面已经介绍了
        $app = require base_path('bootstrap/app.php');
        $kernel = $app->make('Illuminate\Contracts\Http\Kernel');
        
        dd($kernel);
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWd1YW5nMTAy_size_16_color_FFFFFF_t_70 1]

构造函数主要干了一件事，注册一个`booted`完成后的回调函数，函数执行的内容为“注册 `Schedule`实例到服务提供者，同时加载用户定义的`Schedule`任务清单”；

`bootstrap`方法的执行内容如下：

1.  加载`Illuminate/Foundation/Console/Kernel`中`$bootstrappers`变量数组中的类，执行它们的`bootstrap`方法；
    
        protected $bootstrappers = [
            // 加载 .env 文件
            \Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,
            // 加载 config 目录下的配置文件
            \Illuminate\Foundation\Bootstrap\LoadConfiguration::class,
            // 自定义错误报告，错误处理方法及呈现
            \Illuminate\Foundation\Bootstrap\HandleExceptions::class,
            // 为 config/app.php 中的 aliases 数组注册类别名
            \Illuminate\Foundation\Bootstrap\RegisterFacades::class,
            // 在服务容器中单例绑定一个 request 对象，控制台命令会用到
            \Illuminate\Foundation\Bootstrap\SetRequestForConsole::class,
            // 注册 config\app.php 中的 providers 服务提供者
            \Illuminate\Foundation\Bootstrap\RegisterProviders::class,
            // 项目启动，执行每个 ServiceProvider 的 boot 方法，
            \Illuminate\Foundation\Bootstrap\BootProviders::class,
        ];
2.  加载延迟的服务提供者；

### Http访问Application的bootstrap启动分析 ###

启动入口文件在`public\index.php`

$app = require_once __DIR__.'/../bootstrap/app.php';
    
    // 实例化 Illuminate/Foundation/Http/Kernel 对象
    $kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
    
    // 中间件处理、业务逻辑处理
    $response = $kernel->handle(
        // 根据 Symfony 的 request 对象封装出 Illuminate\Http\Request
        $request = Illuminate\Http\Request::capture() 
    );
    
    $response->send();
    
    // 执行所有中间件的 terminate 方法，执行 Application 中的 terminatingCallbacks 回调函数
    $kernel->terminate($request, $response);

### 重要的类变量数组 ###

#### aliases数组 ####

维护 类与别名 的数组；键名为 类的全限定类名，键值为 数组，每一个元素都是该类的别名；

> 判断指定类是否有别名：`app()->isAlias($name)`；

获取指定类的别名：`app()->getAlias($abstract)`；

#### abstractAliases数组 ####

维护 类与别名 的数组；键名为 别名，键值为 类的全限定类名；

#### instances数组 ####

维护 类与实例的数组；键名为 类的全限定类名，键值为该类的实例；

> 移除绑定类：`app()->forgetInstance($abstract);`

移除所有绑定类：`app()->forgetInstances();`

#### bindings数组 ####

通过 `bind` 方法实现 接口类与实现的绑定；

> 获取`bindings`数组中的内容：`app()->getBindings()`

#### resolved数组 ####

键名为 类的全限定类名，键值为布尔值类型（`true`表示已解析过，`false`表示未解析过）；

#### with 数组 ####

在`resolved`过程中，会有一些参数；`with`数组就是参数栈，开始解析时将参数入栈，结束解析时参数出栈；

#### contextual数组 ####

上下文绑定数组；第一维数组键名为 场合类（比如某个`Controller`类的类名），第二维数组键名为 抽象类（需要实现的接口类），键值为 `Closure` 或 某个具体类的类名；

#### tags数组 ####

维护 标签与类 的数组；键名是 标签名，键值是 对应要绑定的类的名称；

如果调用`tagged`方法，会将键值数组中的类都`make`出来，并以数组形式返回；

#### extenders数组 ####

在`make`或`resolve`出对象的时候，会执行

foreach ($this->getExtenders($abstract) as $extender) {
        $object = $extender($object, $this);
    }

能对解析出来的对象进行修饰；

#### methodBindings数组 ####

> 向容器绑定方法与及实现：`app()->bindMethod($method, $callback)`

判断容器内是否有指定方法的实现：`app()->hasMethodBinding($method)`  
执行方法的实现：`app()->callMethodBinding($method, $instance)`或者`app()->call($method)`

#### buildStack数组 ####

调用`build`方法时维护的栈，栈中存放的是当前要`new`的类名；

#### reboundCallbacks数组 ####

当调用`rebound`函数时，会触发`rebound`中为此`$abstract`设置的回调函数；

> 注册入口：`app()->rebinding($abstract, Closure $callback);`

#### serviceProviders数组 ####

已在系统注册的服务提供者`ServiceProvider`；

数组内存放的是`loadedProviders`键名对应类的实例；

### `loadedProviders`数组 ###

系统已加载的`ServiceProvider`的集合；键名为`ServiceProvider`的全限定类名，键值为布尔值（`true`表示已加载，`false`表示未加载）；

> 获取延迟加载对象：`app()->getLoadedProviders()`;

### `deferredServices`数组 ###

有些服务提供者是会延迟加载的；这时候会将这些服务提供者声明的服务登录在`deferredServices`数组，键名为延迟加载对象名 ，键值为该延迟加载对象所在的`ServiceProvider`；

> 获取延迟加载对象：`app()->getDeferredServices()`;

### `bootingCallbacks`数组 ###

项目启动前执行的回调函数；（项目启动是在执行`\Illuminate\Foundation\Bootstrap\BootProviders::class`的时候）

> 注册入口：`app()->booting($callback);`

### `bootedCallbacks`数组 ###

项目启动后执行的回调函数；（项目启动是在执行`\Illuminate\Foundation\Bootstrap\BootProviders::class`的时候）

> 注册入口：`app()->booted($callback);`

### `resolvingCallbacks`数组 ###

解析时回调函数集合；键名为 类名， 键值为 回调函数数组，每一个元素都是回调函数；

> 注册入口：`app()->resolving($abstract, $callback);`

### `afterResolvingCallbacks`数组 ###

解析后回调函数集合；键名为 类名， 键值为 回调函数数组，每一个元素都是回调函数；

> 注册入口：`app()->afterResolving($abstract, $callback);`

### `globalResolvingCallbacks`数组 ###

全局解析时回调函数集合；每一次`resolve`方法调用时都会执行的回调函数集合；

> 注册入口：`app()->resolving($callback);`

### `globalAfterResolvingCallbacks`数组 ###

全局解析后回调函数集合；每一次`resolve`方法调用后都会执行的回调函数集合；

> 注册入口：`app()->afterResolving($callback);`

### `terminatingCallbacks`数组 ###

系统在返回`response`之后，会执行`terminate`方法，来做应用结束前的扫尾处理；

这个数组就是执行`terminate`方法时会执行的回调函数集合；

> 注册入口：`app()->terminating(Closure $callback)`;

## 常用方法的解析 ##

### `bind`方法 ###

public function bind($abstract, $concrete = null, $shared = false)

第一个参数是要注册的类名或接口名，第二个参数是返回类的实例的闭包（或类的实例类名），第三个参数是否是单例；

方法内部流程：

1.  `unset` 掉 **`instances`** 和 **`aliases`** 数组中键值为 `$abstract` 的元素；
2.  如果 `$concrete` 值为 `null` ，将 `$abstract` 赋值给 `$concrete`；
3.  如果 `$concrete` 不是 `Closure` 对象，则封装成闭包；
4.  将 `$concrete` 和 `$shared` 通过 `compact`，添加进 **`bindings`** 数组，键名为 `$abstract`；
5.  判断 `$abstract` 在 **`resolved`** 和 **`instances`** 数组中是否存在，如果存在，则执行第 6 步；
6.  触发 `rebound`回调函数；如果 `reboundCallbacks` 数组中注册以 `$abstract` 为键名的回调函数，则执行这些回调函数；

> 涉及数组：`instances`和`aliases`（unset 操作）、`bindings`（add 操作）

### `singleton`方法 ###

单例绑定；

public function singleton($abstract, $concrete = null)
        $this->bind($abstract, $concrete, true);
    }

> 涉及数组：`instances`和`aliases`（unset 操作）、`bindings`（add 操作）

### `bindIf`方法 ###

单例绑定；

public function bindIf($abstract, $concrete = null, $shared = false) {
        if (! $this->bound($abstract)) {
            $this->bind($abstract, $concrete, $shared);
        }
    }

> 涉及数组：`instances`和`aliases`（unset 操作）、`bindings`（add 操作）

### `instance`方法 ###

绑定实例；

public function instance($abstract, $instance)

方法内部流程：

1.  如果`$abstract`在`aliases`数组中存在，则从`abstractAliases`中所有的值数组中移除该类；
2.  `unset` 掉 `aliases` 数组中键名为 `$abstract`的元素；
3.  赋值操作：`$this->instances[$abstract] = $instance;`
4.  判断 `$abstract` 在 **`resolved`** 和 **`instances`** 数组中是否存在，如果存在，则执行第 5 步；
5.  触发 `rebound`回调函数；如果 `reboundCallbacks` 数组中注册以 `$abstract` 为键名的回调函数，则执行这些回调函数；

> 涉及数组：`instances`（add 操作）、`aliases` 和 `abstractAliases`（unset 操作）

### `make`方法 ###

public function make($abstract) {
        return $this->resolve($abstract);
    }

#### alias ####

给类起别名；

public function alias($abstract, $alias) {
        
        $this->aliases[$alias] = $abstract;
        
        $this->abstractAliases[$abstract][] = $alias;
    }

> 涉及数组：`aliases`和`abstractAliases`（add 操作）

## laravel 的源代码生命周期 ##

第一步 Laravel 应用的所有请求入口都是 public/index.php 文件。打开 index.php 发现代码也就几行。

下面我们来讲一下每一句代码的作用是什么？

// 定义了laravel一个请求的开始时间
    define('LARAVEL_START', microtime(true));
    
    // composer自动加载机制
    require __DIR__.'/../vendor/autoload.php';
    
    // 这句话你就可以理解laravel,在最开始引入了一个ioc容器。
    $app = require_once __DIR__.'/../bootstrap/app.php';
    
    // 打开__DIR__.'/../bootstrap/app.php';你会发现这段代码，绑定了Illuminate\Contracts\Http\Kernel::class，
    // 这个你可以理解成之前我们所说的$ioc->bind();方法。
    // $app->singleton(
    //     Illuminate\Contracts\Http\Kernel::class,
    //    App\Http\Kernel::class
    // );
    
    // 这个相当于我们创建了Kernel::class的服务提供者
    $kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
    
    // 获取一个 Request ，返回一个 Response。以把该内核想象作一个代表整个应用的大黑盒子，输入 HTTP 请求，返回 HTTP 响应。
    $response = $kernel->handle(
        $request = Illuminate\Http\Request::capture()
    );
    
    // 就是把我们服务器的结果返回给浏览器。
    $response->send(); 
    
    // 这个就是执行我们比较耗时的请求，
    $kernel->terminate($request, $response);

走到这里你会发现，是不是在我们学会了 ioc，服务提供者理解起来就比较简单了。那 $middleware，服务提供者都是在哪个文件注册运行的呢？

打开 App\\Http\\Kernel::class 这个文件，你会发现定义了一堆需要加载的 $middleware。这个 kernel 的主要方法还是在他的父类里面 Illuminate\\Foundation\\Http\\Kernel 中。

打开 Illuminate\\Foundation\\Http\\Kernel，你会发现定义了启动时需要做的事呢？

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,
    ];

$bootstrappers 就定义了我们的 RegisterFacades.class,RegisterProviders.class 这两个类的意思就是要将我们在 app.config 中的 Providers,Facades 注入到我们的 Ioc 容器中。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/f262a6b319404cb3904915298183ceb8.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAd2djaGVufg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/6a71f67f77a447bab5ffaedff7e0488f.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAd2djaGVufg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/866a69381b944d6295b993500026aa69.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAd2djaGVufg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2djaGVufg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/29e0f2ea5af549a9ba46a1376e1ae880.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAd2djaGVufg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWd1YW5nMTAy_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210512133124562.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWd1YW5nMTAy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWd1YW5nMTAy_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/d27d2f08665c41d795389e5b36bf6e99.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWd1YW5nMTAy,size_16,color_FFFFFF,t_70