2. php
  3. Laravel的生命周期，我们从加载index.php开始聊起！

Laravel的生命周期，我们从加载index.php开始聊起！

admin 2022-05-06 11:21:02 2413

任何应用或者框架，不管前端框架又或者后端框架甚至web前端框架，他们都是有生命周期的。如果我们能很好的了解这些生命周期，对我们学习、工作、自身提升、编码质量都有很大的帮助。

那么，在我们看Laravel生命周期之前，我们先思考一下php的生命周期吧！我们都知道php运行模式大致有2种，也就是：WEB模式、CLI模式。

当请求一个index.php的时候大致经过下面5个生命周期：

  • 1 模块初始化（MINIT），即调用 php.ini 中指明的扩展的初始化函数进行初始化工作，如 mysql 扩展。

  • 2 请求初始化（RINIT），即初始化为执行本次脚本所需要的变量名称和变量值内容的符号表，如 $_SESSION变量。

  • 3 执行该PHP脚本。

  • 4 请求处理完成(Request Shutdown)，按顺序调用各个模块的 RSHUTDOWN 方法，对每个变量调用 unset 函数，如 unset $_SESSION 变量。

  • 5 关闭模块(Module Shutdown) ， PHP调用每个扩展的 MSHUTDOWN 方法，这是各个模块最后一次释放内存的机会。这意味着没有下一个请求了。

 

CLI (命令行模式)模式每次运行都会走这5个，因为结束就结束了；

WEB模式为了应对并发，可能采用多线程，其生命周期1和5只有启动和停止的时候加载一次(若失败，直接启动失败)，下次请求到来时重复2～4的生命周期，这样就节省了系统模块初始化所带来的开销。

好了，php的生命周期就聊到这里(太深入的也不懂)。并且，5个生命周期，我想你也看出来了，我们php的脚本只运行在第三个生命周期，也就是今天我们的主题！Laravel的生命周期！

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

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

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

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

下面，就让我们一起啃啃Laravel的生命周期吧！

我们知道laravel也是单入口类型的框架，也就是所有的请求都到public\index.php上面。

简单说就是 从 index.php 开始，从 index.php 结束。

现在我们就看看这个文件！简单做了一些注释，一共四步，应该比较了然！(不懂没事，下面还会讲)

<?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);
  • 1 文件载入composer生成的自动加载设置，包括所有你 composer require的依赖。
  • 2 生成容器 Container，Application实例，并向容器注册核心组件（HttpKernel，ConsoleKernel ，ExceptionHandler），是从 bootstrap/app.php 脚本获取 Laravel 应用实例。（对应代码2，容器很重要，后面详细讲解）
  • # 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();
    }
  • 3 处理请求，生成并发送响应（对应代码3，毫不夸张的说，你99%的代码都运行在这个小小的handle 方法里面）。
  • 4 请求结束，进行回调（对应代码4，还记得可终止中间件吗？没错，就是在这里回调的）。

我们先说下 【3.处理请求】

请求被发送到 HTTP 内核或 Console 内核，这取决于进入应用的请求类型。

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

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

<?php
    /**
     * The bootstrap classes for the application.
     *
     * @var string[]
     */
    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
    ];

上面这个图主要是介绍中间件所处的位置，下面还有一张图，主要是看逻辑处理的流程

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启动分析

启动代码很简洁，

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

 

构造函数主要干了一件事，注册一个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,
];

  1. 加载延迟的服务提供者；

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 操作）

在回到开始的public/index.php,是不是就比较明了这生命周期了？

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

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

打开 Illuminate\Foundation\Http\Kernel，你会发现定义了启动时需要做的事呢？(具体看上面的代码注释)

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

原文：www.php.cn/phpkj/laravel/491291.html

最后于 2022-8-8 被admin编辑 ，原因：
可爱猫?Telegram电报群 https://t.me/ikeaimao ➦
收藏的用户（0） X
正在加载信息~
【->注册 OR 登陆<-】
社区声明 1、本站提供的一切软件、教程和内容信息仅限用于学习和研究目的
2、本站资源为用户分享，如有侵权请邮件与我们联系处理敬请谅解！
3、本站信息来自网络，版权争议与本站无关。您必须在下载后的24小时之内，从您的电脑或手机中彻底删除上述内容
相关推荐
 可爱猫微信机器人下载(可爱猫4.6.5、可爱猫5.2.7、可爱猫5.5.4以及iHttp插件)-可爱猫微信机器人全套
 下载可爱猫以及发布插件的注意事项！新人必看！
 可爱猫|http-sdk|官方唯一开源|完整功能支持
 可爱猫5.5.4+最新版(打开可爱猫自动更新)以及微信WeChatSetup_3.4.0.38下载，支持单独开微信和可爱猫，速度更快更稳
 千寻微信机器人框架下载地址
最新回复 (0)

您可以在 登录 or 注册 后，对此帖发表评论！

返回
发新帖
admin
主题数
178 		帖子数
88 		2
精华数 		注册排名
1
热门节点
作者最近主题：