ThinkPHP6源碼：從Http類的實例化看依賴注入是如何實現的

ThinkPHP 6 從原先的 App 類中分離出 Http 類，負責應用的初始化和調度等功能，而 App 類則專一於容器的管理，符合單一職責原則。

如下源碼分析，咱們能夠從 App，Http 類的實例化過程，瞭解類是如何實現自動實例化的，依賴注入是怎麼實現的。

 

從入口文件出發

當訪問一個 ThinkPHP 搭建的站點，框架最早是從入口文件開始的，而後纔是應用初始化、路由解析、控制器調用和響應輸出等操做。

入口文件主要代碼以下：

// 引入自動加載器，實現類的自動加載功能（PSR4標準）

// 對比Laravel、Yii二、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);

    // 保存綁定的實例到「$instances」數組中，見對應分析

    $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，交給「容器」就行了。容器還有很多功能，後面再詳解。

以上就是ThinkPHP6源碼：從Http類的實例化看依賴注入是如何實現的的詳細內容。

更多PHP相關知識請關注個人專欄PHP​zhuanlan.zhihu.com