ThinkPHP6 原始碼閱讀（一）：Http 類是如何例項化的

ThinkPHP 6 從原先的App類中分離出Http類，負責應用的初始化和排程等功能，而App類則專注於容器的管理，符合單一職責原則。
以下原始碼分析，我們可以從App，Http類的例項化過程，瞭解類是如何實現自動例項化的，依賴注入是怎麼實現的。

從入口檔案出發

當訪問一個ThinkPHP搭建的站點，框架最先是從入口檔案開始的，然後才是應用初始化、路由解析、控制器呼叫和響應輸出等操作。
入口檔案主要程式碼如下：

// 引入自動載入器，實現類的自動載入功能（PSR4標準）
// 對比Laravel、Yii2、Thinkphp的自動載入實現，它們基本就都一樣
// 具體實現可參考我之前寫的Laravel的自動載入實現：
// @link： https://learnku.com/articles/20816
require __DIR__ . '/../vendor/autoload.php';

// 這一句和分為兩部分分析，App的例項化和呼叫「http」，具體見下文分析
$http = (new App())->http;

$response = $http->run();

$response->send();

$http->end($response);

App例項化

執行new App()例項化時，首先會呼叫它的建構函式。

public function __construct(string $rootPath = '')
{
    // thinkPath目錄：如，D:\dev\tp6\vendor\topthink\framework\src\
    $this->thinkPath   = dirname(__DIR__) . DIRECTORY_SEPARATOR;
    // 專案根目錄，如：D:\dev\tp6\
    $this->rootPath    = $rootPath ? rtrim($rootPath, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR : $this->getDefaultRootPath();
    $this->appPath     = $this->rootPath . 'app' . DIRECTORY_SEPARATOR;
    $this->runtimePath = $this->rootPath . 'runtime' . DIRECTORY_SEPARATOR;

    // 如果存在「繫結類庫到容器」檔案
    if (is_file($this->appPath . 'provider.php')) {
        //將檔案裡的所有對映合併到容器的「$bind」成員變數中
        $this->bind(include $this->appPath . 'provider.php');
    }

    //將當前容器例項儲存到成員變數「$instance」中，也就是容器自己儲存自己的一個例項
    static::setInstance($this);

    // A-1 見對應分析
    $this->instance('app', $this);
    $this->instance('think\Container', $this);
}

建構函式實現了專案各種基礎路徑的初始化，並讀取了provider.php檔案，將其類的繫結併入$bind成員變數，provider.php檔案預設內容如下：

return [
    'think\Request'          => Request::class,
    'think\exception\Handle' => ExceptionHandle::class,
];

合併後，$bind成員變數的值如下：

$bind的值是一組類的標識到類的對映。從這個實現也可以看出，我們不僅可以在provider.php檔案中新增標識到類的對映，而且可以覆蓋其原有的對映，也就是將某些核心類替換成自己定義的類。

static::setInstance($this)實現的作用，如圖：

think\App類的$instance成員變數指向think\App類的一個例項，也就是類自己儲存自己的一個例項。

instance方法的實現：

public function instance(string $abstract, $instance)
{
    //檢查「$bind」中是否儲存了名稱到實際類的對映，如 'app'=> 'think\App'
    //也就是說，只要繫結了這種對應關係，通過傳入名稱，就可以找到實際的類
    if (isset($this->bind[$abstract])) {
        //$abstract = 'app', $bind = "think\App"
        $bind = $this->bind[$abstract];
        //如果「$bind」是字串，重走上面的流程
        if (is_string($bind)) {
            return $this->instance($bind, $instance);
        }
    }
    //儲存繫結的例項到「$instances」陣列中
    //比如，$this->instances["think\App"] = $instance;
    $this->instances[$abstract] = $instance;

    return $this;
}

Http類的例項化以及依賴注入原理

這裡，$http = (new App())->http，前半部分好理解，後半部分乍一看有點讓人摸不著頭腦，App類並不存在http成員變數，這裡何以大膽呼叫了一個不存在的東東呢？
原來，App類繼承自Container類，而Container類實現了__get() 魔術方法，在PHP中，當訪問到的變數不存在，就會觸發__get()魔術方法。該方法的實現如下：

public function __get($name)
{
    return $this->get($name);
}

實際上是呼叫get()方法：

public function get($abstract)
{
    //先檢查是否有繫結實際的類或者是否例項已存在
    //比如，$abstract = 'http'
    if ($this->has($abstract)) {
        return $this->make($abstract);
    }
    // 找不到類則丟擲類找不到的錯誤
    throw new ClassNotFoundException('class not exists: ' . $abstract, $abstract);
}

然而，實際上，主要是make()方法：

public function make(string $abstract, array $vars = [], bool $newInstance = false)
    {
        //如果已經存在例項，且不強制建立新的例項，直接返回已存在的例項
        if (isset($this->instances[$abstract]) && !$newInstance) {
            return $this->instances[$abstract];
        }
        //如果有繫結，比如 'http'=> 'think\Http',則 $concrete = 'think\Http'
        if (isset($this->bind[$abstract])) {
            $concrete = $this->bind[$abstract];

            if ($concrete instanceof Closure) {
                $object = $this->invokeFunction($concrete, $vars);
            } else {
                //重走一遍make函式，比如上面http的例子，則會調到後面「invokeClass()」處
                return $this->make($concrete, $vars, $newInstance);
            }
        } else {
            //例項化需要的類，比如'think\Http'
            $object = $this->invokeClass($abstract, $vars);
        }

        if (!$newInstance) {
            $this->instances[$abstract] = $object;
        }

        return $object;
    }

然而，然而，make()方法主要靠invokeClass()來實現類的例項化。該方法具體分析：

public function invokeClass(string $class, array $vars = [])
    {
        try {
            //通過反射例項化類
            $reflect = new ReflectionClass($class);
            //檢查是否有「__make」方法
            if ($reflect->hasMethod('__make')) {
                //返回的$method包含'__make'的各種資訊，如公有/私有
                $method = new ReflectionMethod($class, '__make');
                //檢查是否是公有方法且是靜態方法
                if ($method->isPublic() && $method->isStatic()) {
                    //繫結引數
                    $args = $this->bindParams($method, $vars);
                    //呼叫該方法（__make），因為是靜態的，所以第一個引數是null
                    //因此，可得知，一個類中，如果有__make方法，在類例項化之前會首先被呼叫
                    return $method->invokeArgs(null, $args);
                }
            }
            //獲取類的建構函式
            $constructor = $reflect->getConstructor();

            //有建構函式則繫結其引數
            $args = $constructor ? $this->bindParams($constructor, $vars) : [];
            //根據傳入的引數，通過反射，例項化類
            $object = $reflect->newInstanceArgs($args);

            $this->invokeAfter($class, $object);

            return $object;
        } catch (ReflectionException $e) {
            throw new ClassNotFoundException('class not exists: ' . $class, $class, $e);
        }
    }

以上程式碼可看出，在一個類中，新增__make()方法，在類例項化時，會最先被呼叫。以上最值得一提的是bindParams()方法：

protected function bindParams($reflect, array $vars = []): array
{
    //如果引數個數為0，直接返回
    if ($reflect->getNumberOfParameters() == 0) {
        return [];
    }

    // 判斷陣列型別 數字陣列時按順序繫結引數
    reset($vars);
    $type   = key($vars) === 0 ? 1 : 0;
    //通過反射獲取函式的引數，比如，獲取Http類建構函式的引數，為「App $app」
    $params = $reflect->getParameters();
    $args   = [];

    foreach ($params as $param) {
        $name      = $param->getName();
        $lowerName = self::parseName($name);
        $class     = $param->getClass();

        //如果引數是一個類
        if ($class) {
            //將型別提示的引數例項化
            $args[] = $this->getObjectParam($class->getName(), $vars);
        } elseif (1 == $type && !empty($vars)) {
            $args[] = array_shift($vars);
        } elseif (0 == $type && isset($vars[$name])) {
            $args[] = $vars[$name];
        } elseif (0 == $type && isset($vars[$lowerName])) {
            $args[] = $vars[$lowerName];
        } elseif ($param->isDefaultValueAvailable()) {
            $args[] = $param->getDefaultValue();
        } else {
            throw new InvalidArgumentException('method param miss:' . $name);
        }
    }

    return $args;
}

而這之中，又最值得一提的是getObjectParam()方法：

protected function getObjectParam(string $className, array &$vars)
{
    $array = $vars;
    $value = array_shift($array);

    if ($value instanceof $className) {
        $result = $value;
        array_shift($vars);
    } else {
        //例項化傳入的類
        $result = $this->make($className);
    }

    return $result;
}

getObjectParam()方法再一次光榮地呼叫make()方法，例項化一個類，而這個類，正是從Http的建構函式提取的引數，而這個引數又恰恰是一個類的例項——App類的例項。到這裡，程式不僅通過PHP的反射類例項化了Http類，而且例項化了Http類的依賴App類。假如App類又依賴C類，C類又依賴D類……不管多少層，整個依賴鏈條依賴的類都可以實現例項化。

總的來說，整個過程大概是這樣的：需要例項化Http類 ==> 提取建構函式發現其依賴App類 ==> 開始例項化App類（如果發現還有依賴，則一直提取下去，直到天荒地老）==> 將例項化好的依賴（App類的例項）傳入Http類來例項化Http類。

這個過程，起個裝逼的名字就叫做「依賴注入」，起個摸不著頭腦的名字，就叫做「控制反轉」。

這個過程，如果退回遠古時代，要例項化Http類，大概是這樣實現的（假如有很多層依賴）：

.
.
.
$e = new E();
$d = new D($e);
$c = new D($d);
$app = new App($c);
$http = new Http($app);
.
.
.

這得有多累人。而現代PHP，交給「容器」就好了。容器還有不少功能，後面再詳解。