乾貨預警，一篇文章帶你徹底搞懂 Laravel 框架的執行原理！！！

前言

知其然知其所以然，剛開始接觸框架的時候大不部分人肯定一臉懵逼，不知道如何實現的，沒有一定的基礎知識，直接去看框架的原始碼，只會被直接勸退，Laravel 框架是一款非常優秀的 PHP 框架，這篇文章就是帶你徹底搞懂框架的執行原理，好讓你在面試的過程中有些談資（吹牛），學習和研究優秀框架的原始碼也有助於我們自身技術的提升，接下來繫好安全帶，老司機要開始開車了！！！

本文收錄在 Github 上，持續分享乾貨
地址：github.com/yefangyong/PHP-Intervie...
歡迎三連 （star + fork + follow）

準備知識

• 熟悉 php 基本知識，如常見的陣列方法，閉包函式的使用，魔術方法的使用
• 熟悉 php 的反射機制和依賴注入
• 熟悉 php 名稱空間概念和 compose 自動載入
• 熟悉常見的設計模式，包括但是不限於單例模式，工廠模式，門面模式，註冊樹模式，裝飾者模式等

執行原理概述

Laravel 框架的入口檔案 index.php

1、引入自動載入 autoload.php 檔案

2、建立應用例項，並同時完成了

基本繫結($this、容器類Container等等)、

基本服務提供者的註冊（Event、log、routing）、

核心類別名的註冊(比如db、auth、config、router等)

3、開始 Http 請求的處理

make 方法從容器中解析指定的值為實際的類，比如 $app->make(Illuminate\Contracts\Http\Kernel::class); 解析出來 App\Http\Kernel 

handle 方法對 http 請求進行處理

實際上是 handle 中 sendRequestThroughRouter 處理 http 的請求

首先，將 request 繫結到共享例項

然後執行 bootstarp 方法，執行給定的引導類陣列 $bootstrappers，這裡是重點，包括了載入配置檔案、環境變數、服務提供者、門面、異常處理、引導提供者等

之後，進入管道模式，經過中介軟體的處理過濾後，再進行使用者請求的分發

在請求分發時，首先，查詢與給定請求匹配的路由，然後執行 runRoute 方法，實際處理請求的時候 runRoute 中的 runRouteWithinStack 

最後，經過 runRouteWithinStack 中的 run 方法，將請求分配到實際的控制器中，執行閉包或者方法，並得到響應結果

4、 將處理結果返回

詳細原始碼分析

1、註冊自動載入類，實現檔案的自動載入

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

2、建立應用容器例項 Application （該例項繼承自容器類 Container）,並繫結核心（web、命令列、異常），方便在需要的時候解析它們

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

app.php 檔案如下：

<?php
// 建立Laravel例項 【3】
$app = new Illuminate\Foundation\Application(
 $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
);
// 繫結Web端kernel
$app->singleton(
 Illuminate\Contracts\Http\Kernel::class, App\Http\Kernel::class);
// 繫結命令列kernel
$app->singleton(
 Illuminate\Contracts\Console\Kernel::class, App\Console\Kernel::class);
// 繫結異常處理
$app->singleton(
 Illuminate\Contracts\Debug\ExceptionHandler::class, App\Exceptions\Handler::class);
// 返回應用例項
return $app;

3、在建立應用例項（Application.php）的建構函式中，將基本繫結註冊到容器中，並註冊了所有的基本服務提供者，以及在容器中註冊核心類別名

3.1、將基本繫結註冊到容器中

    /**
     * Register the basic bindings into the container.
     *
     * @return void
     */
    protected function registerBaseBindings()
    {
        static::setInstance($this);
        $this->instance('app', $this);
        $this->instance(Container::class, $this);
        $this->singleton(Mix::class);
        $this->instance(PackageManifest::class, new PackageManifest(
            new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
        ));
        # 注：instance方法為將...註冊為共享例項，singleton方法為將...註冊為共享繫結
    }

3.2、註冊所有基本服務提供者（事件，日誌，路由）

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

3.3、在容器中註冊核心類別名

4、上面完成了類的自動載入、服務提供者註冊、核心類的繫結、以及基本註冊的繫結

5、開始解析 http 的請求

index.php
//5.1
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
//5.2
$response = $kernel->handle(
 $request = Illuminate\Http\Request::capture());

5.1、make方法是從容器解析給定值

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

中的Illuminate\Contracts\Http\Kernel::class 是在index.php 中的$app = require_once __DIR__.'/../bootstrap/app.php';這裡面進行繫結的，實際指向的就是App\Http\Kernel::class這個類

5.2、這裡對 http 請求進行處理

$response = $kernel->handle(
 $request = Illuminate\Http\Request::capture());

進入 $kernel 所代表的類 App\Http\Kernel.php 中，我們可以看到其實裡面只是定義了一些中介軟體相關的內容，並沒有 handle 方法

我們再到它的父類 use Illuminate\Foundation\Http\Kernel as HttpKernel; 中找 handle 方法，可以看到 handle 方法是這樣的

public function handle($request)
{
    try {
        $request->enableHttpMethodParameterOverride();
        // 最核心的處理http請求的地方【6】
        $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;
}

6、處理 Http 請求（將 request 繫結到共享例項，並使用管道模式處理使用者請求）

vendor/laravel/framework/src/Illuminate/Foundation/Http/Kernel.php的handle方法
// 最核心的處理http請求的地方
$response = $this->sendRequestThroughRouter($request);

protected function sendRequestThroughRouter($request)
{
    // 將請求$request繫結到共享例項
    $this->app->instance('request', $request);
    // 將請求request從已解析的門面例項中清除（因為已經繫結到共享例項中了，沒必要再浪費資源了）
    Facade::clearResolvedInstance('request');
    // 引導應用程式進行HTTP請求
    $this->bootstrap();【7、8】
    // 進入管道模式，經過中介軟體，然後處理使用者的請求【9、10】
    return (new Pipeline($this->app))
                ->send($request)
                ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
                ->then($this->dispatchToRouter());
}

7、在 bootstrap 方法中，執行給定的 引導類陣列 $bootstrappers，載入配置檔案、環境變數、服務提供者、門面、異常處理、引導提供者，非常重要的一步，位置在 vendor/laravel/framework/src/Illuminate/Foundation/Http/Kernel.php

/**
 * Bootstrap the application for HTTP requests.
 *
 * @return void
 */
public function bootstrap()
{
    if (! $this->app->hasBeenBootstrapped()) {
        $this->app->bootstrapWith($this->bootstrappers());
    }
}

/**
 * 執行給定的引導類陣列
 *
 * @param  string[]  $bootstrappers
 * @return void
 */
public function bootstrapWith(array $bootstrappers)
{
    $this->hasBeenBootstrapped = true;
    foreach ($bootstrappers as $bootstrapper) {
        $this['events']->dispatch('bootstrapping: '.$bootstrapper, [$this]);
        $this->make($bootstrapper)->bootstrap($this);
        $this['events']->dispatch('bootstrapped: '.$bootstrapper, [$this]);
    }
}

/**
 * Get the bootstrap classes for the application.
 *
 * @return array
 */
protected function bootstrappers()
{
    return $this->bootstrappers;
}

/**
 * 應用程式的引導類
 *
 * @var array
 */
protected $bootstrappers = [
    // 載入環境變數
    \Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,
    // 載入config配置檔案【重點】
    \Illuminate\Foundation\Bootstrap\LoadConfiguration::class,
    // 載入異常處理
    \Illuminate\Foundation\Bootstrap\HandleExceptions::class,
    // 載入門面註冊
    \Illuminate\Foundation\Bootstrap\RegisterFacades::class,
    // 載入在config/app.php中的providers陣列裡所定義的服務【8 重點】
    \Illuminate\Foundation\Bootstrap\RegisterProviders::class,
    // 記載引導提供者
    \Illuminate\Foundation\Bootstrap\BootProviders::class,
];

8、載入 config/app.php 中的 providers 陣列裡定義的服務

Illuminate\Auth\AuthServiceProvider::class,
Illuminate\Broadcasting\BroadcastServiceProvider::class,
......

/**
 * 自己新增的服務提供者 */\App\Providers\HelperServiceProvider::class,

可以看到，關於常用的 Redis、session、queue、auth、database、Route 等服務都是在這裡進行載入的

9、使用管道模式處理使用者請求，先經過中介軟體進行處理和過濾

return (new Pipeline($this->app))
    ->send($request)
    // 如果沒有為程式禁用中介軟體，則載入中介軟體（位置在app/Http/Kernel.php的$middleware屬性）
    ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
    ->then($this->dispatchToRouter());
}

app/Http/Kernel.php

/**
 * 應用程式的全域性HTTP中介軟體
 *
 * These middleware are run during every request to your application.
 *
 * @var array
 */
protected $middleware = [
    \App\Http\Middleware\TrustProxies::class,
    \App\Http\Middleware\CheckForMaintenanceMode::class,
    \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
    \App\Http\Middleware\TrimStrings::class,
    \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
];

10、經過中介軟體處理後，再進行請求分發（包括查詢匹配路由）

/**
 * 10.1 通過中介軟體/路由器傳送給定的請求
 *
 * @param  \Illuminate\Http\Request  $request
 * @return \Illuminate\Http\Response
 */
 protected function sendRequestThroughRouter($request)
{
    ...
    return (new Pipeline($this->app))
        ...
        // 進行請求分發
        ->then($this->dispatchToRouter());
}

/**
 * 10.2 獲取路由排程程式回撥
 *
 * @return \Closure
 */
protected function dispatchToRouter()
{
    return function ($request) {
        $this->app->instance('request', $request);
        // 將請求傳送到應用程式
        return $this->router->dispatch($request);
    };
}

/**
 * 10.3 將請求傳送到應用程式
 *
 * @param  \Illuminate\Http\Request  $request
 * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse
 */
 public function dispatch(Request $request)
{
    $this->currentRequest = $request;
    return $this->dispatchToRoute($request);
}

 /**
 * 10.4 將請求分派到路由並返回響應【重點在runRoute方法】
 *
 * @param  \Illuminate\Http\Request  $request
 * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse
 */
public function dispatchToRoute(Request $request)
{   
    return $this->runRoute($request, $this->findRoute($request));
}

/**
 * 10.5 查詢與給定請求匹配的路由
 *
 * @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;
}

/**
 * 10.6 查詢與給定請求匹配的第一條路由
 *
 * @param  \Illuminate\Http\Request  $request
 * @return \Illuminate\Routing\Route
 *
 * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
 */
public function match(Request $request)
{
    // 獲取使用者的請求型別（get、post、delete、put），然後根據請求型別選擇對應的路由
    $routes = $this->get($request->getMethod());
    // 匹配路由
    $route = $this->matchAgainstRoutes($routes, $request);
    if (! is_null($route)) {
        return $route->bind($request);
    }
    $others = $this->checkForAlternateVerbs($request);
    if (count($others) > 0) {
        return $this->getRouteForMethods($request, $others);
    }
    throw new NotFoundHttpException;
}

到現在，已經找到與請求相匹配的路由了，之後將執行了，也就是 10.4 中的 runRoute 方法

/**
 * 10.7 返回給定路線的響應
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Illuminate\Routing\Route  $route
 * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse
 */
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.
 * 10.8 在棧中執行路由,先檢查有沒有控制器中介軟體，如果有先執行控制器中介軟體
 *
 * @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);
    return (new Pipeline($this->container))
        ->send($request)
        ->through($middleware)
        ->then(function ($request) use ($route) {
            return $this->prepareResponse(
                $request, $route->run()
            );
        });
}

 /**
     * Run the route action and return the response.
     * 10.9 最後一步，執行控制器的方法，處理資料
     * @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();
        }
    }

11、執行路由並返回響應（重點）
可以看到，10.7 中有一個方法是 prepareResponse，該方法是從給定值建立響應例項，而 runRouteWithinStack 方法則是在棧中執行路由，也就是說，http 的請求和響應都將在這裡完成。

總結

到此為止，整個 Laravel 框架的執行流程就分析完畢了，揭開了 Laravel 框架的神祕面紗，其中為了文章的可讀性，只給出了核心程式碼，需要大家結合文章自行去閱讀原始碼，需要注意的是必須瞭解文章中提到的準備知識，這是閱讀框架原始碼的前提和基礎，希望大家有所收穫，下車！！！

參考資料

• www.haveyb.com/article/298
• 《Laravel核心分析》 重點，最好讀完這些文章，再來看這篇文章
• 《深入 Laravel 核心》

本作品採用《CC 協議》，轉載必須註明作者和本文連結