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() を実行すると、これは first のコンストラクターと呼ばれます。

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 中国語 Web サイトの他の関連記事を参照してください。