ThinkPHP6源码：从Http类的实例化看依赖注入是如何实现的

thinkphp 6 从原先的app类中分离出http类，负责应用的初始化和调度等功能，而app类则专注于容器的管理，符合单一职责原则。

以下源码分析，我们可以从app，http类的实例化过程，了解类是如何实现自动实例化的，依赖注入是怎么实现的。

从入口文件出发

当访问一个 thinkphp 搭建的站点，框架最先是从入口文件开始的，然后才是应用初始化、路由解析、控制器调用和响应输出等操作。

入口文件主要代码如下：

// 引入自动加载器，实现类的自动加载功能（psr4标准）// 对比laravel、yii2、thinkphp的自动加载实现，它们基本就都一样// 具体实现可参考我之前写的laravel的自动加载实现：// @link： https://learnku.com/articles/20816require __dir__ . '/../vendor/autoload.php';// 这一句和分为两部分分析，app的实例化和调用「http」，具体见下文分析$http = (new app())->http;$respon = $ht四级考试分数tp->run();$respon->nd();$http->end($respon);

app 实例化

执行 new app() 实例化时，首先会调用它的构造函数。

public function __construct(string $rootpath = ''){    // thinkpath目录：如，d:\dev\tp6\vendor\topthink\framework\src\    $this->thinkpath   = dirname(__dir__) . directory_parator;    // 项目根目录，如：d:\dev\tp6\    $this->rootpath    = $rootpath ? rtrim($rootpath, directory_parator) . directory_parator : $this->getdefaultrootpath();    $this->apppath     = $this->rootpath . 'app' . directory_parator;    $this->runtimepath = $this->rootpath . 'runtime' . directory_parator;    // 如果存在「绑定类库到容器」文件    if (is_file($this->apppath . 'provider.php')) {        //将文件里的所有映射合并到容器的「$bind」成员变量中        $this->bind(include $this->apppath . 'provider.php');    }    //将当前容器实例保存到成员变量「$instance」中，也就是容器自己保存自己的一个实例    static::tinstance($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::tinstance($this) 实现的作用，如图：

think\app 类的 $instance 成员变量指向 think\app 类的一个实例，也就是类自己保存自己的一个实例。

instance() 方法的实现：

public function instance(string $abstract, $instance){    //检查「$bind」中是否保存了名称到实际类的映射，如 'app'=> 'think\app'    //也就是说，只要绑定了这种对应关系，通过传入名称，就可以找到实际的类    if (ist($this->bind[$abstract])) {        //$abstract = 'app', $bind = "think\app"        $bind = $this->bind[$a香辣干锅虾bstract];        //如果「$bind」是字符串，重走上面的流程        if (is_string($bind)) {            return雨水节气吃什么 $this->instance($bind, $instance);        }    }    //保存绑定的实例到「$instances」数组中    //比如，$this->instances["think\app"] = $instance;    $this->instances[$abst长方体的定义ract] = $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 = fal)    {        //如果已经存在实例，且不强制创建新的实例，直接返回已存在的实例        if (ist($this->instances[$abstract]) && !$newinstance) {            return $this->instances[$abstract];        }        //如果有绑定，比如 'http'=> 'think\http',则 $concrete = 'think\http'        if (ist($this->bind[$abstract])) {            $concrete = $this->bind[$abstract];            if ($concrete instanceof closure) {                $object = $this->invokefunction($concrete, $vars);            } el {                //重走一遍make函数，比如上面http的例子，则会调到后面「invokeclass()」处                return $this->make($concrete, $vars, $newinstance);            }        } el {            //实例化需要的类，比如'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('cla学习美容ss not exists: ' . $class, $class, $e);        }    }

以上代码可看出，在一个类中，添加__make() 方法，在类实例化时，会最先被调用。以上最值得一提的是 bindparams() 方法：

protected function bindparams($reflect, array $vars = []): array{    //如果参数个数为0，直接返回    if ($reflect->getnumberofparameters() == 0) {        return [];    }    // 判断数组类型 数字数组时按顺序绑定参数    ret($vars);    $type   = key($vars) === 0 ? 1 : 0;    //通过反射获取函数的参数，比如，获取http类构造函数的参数，为「app $app」    $params = $reflect->getparameters();    $args   = [];    foreach ($params as $param) {        $name      = $param->getname();        $lowername = lf::parname($name);        $class     = $param->getclass();        //如果参数是一个类        if ($class) {            //将类型提示的参数实例化            $args[] = $this->getobjectparam($class->getname(), $vars);        } elif (1 == $type && !empty($vars)) {            $args[] = array_shift($vars);        } elif (0 == $type && ist($vars[$name])) {            $args[] = $vars[$name];        } elif (0 == $type && ist($vars[$lowername])) {            $args[] = $vars[$lowername];        } elif ($param->isdefaultvalueavailable()) {            $args[] = $param->getdefaultvalue();        } el {            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);    } el {        //实例化传入的类        $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