Laravel是我最熟悉的框架,却一直没认真的梳理过它的源码,甚是遗憾,遂在此梳理一遍laravel的源码。

Laravel版本:5.7
Composer版本:1.6.5

请求生命周期

大部分框架都有一个入口文件,Laravel也不例外,入口文件即public/index.php,我们在Nginx中配置server的时候就是将index属性指向到public/index.php的绝对路径。 我们先从入口文件讲起:

define('LARAVEL_START', microtime(true));

定义了框架运行的开始时间,方便打印整个request请求的执行时间,5.5版本之前是没有的,这里是5.5新加的

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

加载composer提供的类,进入到vender/autoload_real.php文件中可以看到这个文件具体加载了什么东西


//此处开始按照psr-4规范设置加载器 //设置命名空间、md解析器、测试框架、console高亮显示器等 
$map = require __DIR__ . '/autoload_namespaces.php';
foreach ($map as $namespace => $path) {
    $loader->set($namespace, $path);
}
//设置tinker、log、Symfony组件等(Laravel的路由、http核心等是基于Symfony框架的) 
$map = require __DIR__ . '/autoload_psr4.php';
foreach ($map as $namespace => $path) {
    $loader->setPsr4($namespace, $path);
}
//设置映射类 
$classMap = require __DIR__ . '/autoload_classmap.php';
if ($classMap) {
    $loader->addClassMap($classMap);
}

最后返回一个autoloader,这时Composer提供的东西全部加载完毕。 让我们继续返回到public/index.php

$app = require_once __DIR__.'/../bootstrap/app.php';

下一步就是开始初始化框架,可以看到在bootstrap/app.php引导文件中,第一行便是初始化一个Laravel容器,在初始化的过程中做了哪些工作呢?

这是Application.php的构造器:

public function __construct($basePath = null)
{
    if ($basePath) {
        $this->setBasePath($basePath);
    }

    $this->registerBaseBindings();

    $this->registerBaseServiceProviders();

    $this->registerCoreContainerAliases();
}

首先设置整个项目的根目录,并且将config_path,storage_path,database_path,resource_path,bootstrap_path等绑定到容器的instance属性

下一步便是注册基本绑定,注册BaseServiceProviders

/**
 * Register all of the base service providers.  
 * @return void 
 */ 
protected function registerBaseServiceProviders()
{
    $this->register(new EventServiceProvider($this));

    $this->register(new LogServiceProvider($this));

    $this->register(new RoutingServiceProvider($this));
}

可以看到容器初始化的时候已经注册了三个基本服务:event,log,routing 再次回到Application.php,构造器的最后一步是注册alias,这时一个完整的app容器才算注册完成。容器有了,接下来如何处理http请求和控制台请求,如何处理异常呢? 答案是继续往容器里绑定服务:

//绑定http处理服务
$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 );

至此我们可以看到,整个Laravel框架几乎都是通过这样的思想来注册服务的,当需要用哪个服务的时候,ok,绑定一下。如果要移除一个服务,从容器实例中解除绑定即可。大大降低了系统的耦合,提高了灵活性。 再次回到public/index.php, 由于容器已经绑定了将 Illuminate\Contracts\Http\Kernel::class,绑定为App\Http\Kernel::class,

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

当容器传入make一个http核心时,实际是创建了一个类型为App\Http\Kernel::class的kernal对象。通过____construct发放可以看到处理http请求之前的中间件都已准备完毕。

下一步开始创建request对象:

public static function capture()
{
    static::enableHttpMethodParameterOverride();

    return static::createFromBase(SymfonyRequest::createFromGlobals());
}

public static function createFromGlobals()
{
    $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;
}

可以看到$request请求是基于php的全局变量 $_GET, $_POST, $_COOKIE, $_FILES, $_SERVER 来创建的。 将$request对象传入httpKernal之后,执行handle方法,handle方法中需要先加载环境变量、配置文件等

protected $bootstrappers = [
    //从env文件加载环境变量
  \Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,
    //从app/config目录加载各种配置文件
  \Illuminate\Foundation\Bootstrap\LoadConfiguration::class,
    //自定义异常处理函数,php执行终止函数
  \Illuminate\Foundation\Bootstrap\HandleExceptions::class,
    \Illuminate\Foundation\Bootstrap\RegisterFacades::class,
    //注册provider
  \Illuminate\Foundation\Bootstrap\RegisterProviders::class,
    //启动provider
  \Illuminate\Foundation\Bootstrap\BootProviders::class,
];

各种配置、中间件加载完毕后将request传入Pipeline

return (new Pipeline($this->app))
            ->send($request)
            ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
            ->then($this->dispatchToRouter());

pipeline翻译过来就是管道,request对象通过pipeline被传送到middleware,经过middleware的层层传递,进入到then方法,这也是pipeline类的关键。

public function then(Closure $destination)
{
    $pipeline = array_reduce(
        array_reverse($this->pipes), $this->carry(), $this->prepareDestination($destination)
    );

    return $pipeline($this->passable);
}

虽然只有短短的几行代码,理解起来却特别晦涩。 我们一个一个解析 $this->pipes 经过之前through方法的处理,其实就是middleware数组,将这个数组的顺序反转。(至于为什么要用array_reverse将中间件执行的顺序反过来,我也没搞懂)

$this->prepareDestination( $destination)

/**
 * Get the final piece of the Closure onion. 
 * 
 * @param  \Closure  $destination 
 * @return \Closure 
 */ 
protected function prepareDestination(Closure $destination)
{
    return function ($passable) use ($destination) {
        try {
            return $destination($passable);
        } catch (Exception $e) {
            return $this->handleException($passable, $e);
        } catch (Throwable $e) {
            return $this->handleException($passable, new FatalThrowableError($e));
        }
    };
}

$destination 本身就是一个闭包函数,经过prepareDestination方法的处理,返回值仍是一个闭包。经过debug我们可以看到 $destination参数变为了返回值的一个属性,可以这么理解:上面的prepareDestination方法相当于把 $destination参数格式化了一下,变为返回值的一个静态类型的属性。

再次回到then方法,array_reduce函数在php手册上是这样解释的:

mixed array_reduce ( array $array , callable $callback [, mixed $initial = NULL ] ) array_reduce() 将回调函数 callback 迭代地作用到 array 数组中的每一个单元中,从而将数组简化为单一的值。

array_reverse($this->pipes)是经过反转后的中间件数组, $this->carry()返回的是一个用来处理中间件的数组,prepareDestination方法的返回值(假设为p)是array_reduce的可选参数,p有两个作用:

  1. 如果p不为空则在处理中间件数组之前执行
  2. 如果中间件数组为空,则返回p

而我们知道,框架默认会有5个中间件(见上图pipes属性),所以array_reverse的执行结果一定是1,至此,Pipeline对象的then方法作用已明确: 先用prepareDestination方法格式化经过路由分发后返回的闭包函数,然后用 this->carry()方法挨个执行中间件。 可以看下this->carry()的具体代码:

protected function carry()
{
    return function ($stack, $pipe) {
        return function ($passable) use ($stack, $pipe) {
            if (is_callable($pipe)) {   // $pipe类型一

//如果$pipe是一个可以调用的闭包函数,则直接调用 //否则将从容器中解析$pipe,然后用响应的方法和参数调用

        return $pipe($passable, $stack);
            } elseif (! is_object($pipe)) {  // $pipe类型二

//如果$pipe不是对象类型,是字符串,则将此字符串从依赖注入容器中解析成class对象, //然后调用class的handle方法来处理参数(handle方法见下方注释)
        [$name, $parameters] = $this->parsePipeString($pipe);
                $pipe = $this->getContainer()->make($name);
                $parameters = array_merge([$passable, $stack], $parameters);
            } else {     // $pipe类型三

 //如果$pipe是对象类型,则直接将参数传入$pipe调用它的handle方法即可  
        $parameters = [$passable, $stack];
            }

            //可以看到method属性默认值为 'handle',
 //$pipe如果存在handle方法则执行handle //若不存在,说明$pipe是Closure类型,直接执行 $pipe

        $response = method_exists($pipe, $this->method)
                            ? $pipe->{$this->method}(...$parameters)
                            : $pipe(...$parameters);
            //经过中间件处理后的$response 如果是Responsable 类型,则按resopnse标准输出,
 //若不是,则直接输出 $response  
        return $response instanceof Responsable
                        ? $response->toResponse($this->container->make(Request::class))
                        : $response;
        };
    };
}

回顾一下Laravel框架中间件的实现方式:

  1. 通过运行 make:middleware Artisan 命令来创建中间件。 创建后的中间件在 app/Http/Middleware/ 目录下,自带handle方法,是由上面 elseif (! is_object($pipe)) 下的代码块来处理
  2. 创建中间件组 中间件组也有两种形式

    protected  $middlewareGroups  =  [  
    'web'  =>  [ 
    \App\Http\Middleware\EncryptCookies::class, 
    \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,    
    \Illuminate\Session\Middleware\StartSession::class, 
    \Illuminate\View\Middleware\ShareErrorsFromSession::class, 
    \App\Http\Middleware\VerifyCsrfToken::class, 
    \Illuminate\Routing\Middleware\SubstituteBindings::class,  
    ],  
    'api'  =>  [  'throttle:60,1',  'auth:api',  ],  
    ];

    api数组下的字符串类型对应 上述 elseif (! is_object($pipe)) 下的代码块来处理 web数组下的class类型跟 1相同

  3. Terminable中间件 这种中间件是用于HTTP 响应构建完毕之后处理一些工作,创建时直接在中间件class中添加 terminate 方法即可,这种中间件是由carry方法中的if (is_callable($pipe)) 代码块来处理

至此,this->carry()方法中正好将中间件的三种类型,都处理了。

绕了这么久终于回到public/index.php了,最后两行: 发送response,发送完毕之后调用fastcgi_finish_request方法关闭fastcgi kernal调用terminate方法结束请求声明周期。