容器 · thinkphp6文档

[https://learnku.com/articles/32321](https://learnku.com/articles/32321) ``` $http = (new App())->http; ``` 过程：执行`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, ]; ``` 然后将`provider.php`文件你的内容合并到App的 bind（属性）容器下，$bind 的值是一组类的标识到类的映射可以接受类、闭包、接口、实现等，不接受类对象（单独绑定到instances属性容器） ->http调用一个不存在的http属性，触发__get方法（调用get方法在调用make实例化类并返回该类对象，make的第一个参数就是这个不存在的http属性） ``` public function make(string $abstract, array $vars = [], bool $newInstance = false) { $abstract = $this->getAlias($abstract); //如果已经存在实例，且不强制创建新的实例，直接返回已存在的实例 if (isset($this->instances[$abstract]) && !$newInstance) { return $this->instances[$abstract]; } //如果有绑定，且绑定的是闭包 if (isset($this->bind[$abstract]) && $this->bind[$abstract] instanceof Closure) { //通过反射实执行方法 $object = $this->invokeFunction($this->bind[$abstract], $vars); } else { //通过反射实例化需要的类，比如'think\Http' $object = $this->invokeClass($abstract, $vars); } if (!$newInstance) { $this->instances[$abstract] = $object; } return $object; } ``` 由上可知make主要是执行invokeFunction返回回调函数（闭包）的内容，invokeClass示例化并返回（这两个函数通过反射机制实现）值得注意的是 invokeClass 除了返回示例外，还会调用invokeAfter 执行容器回调 ``` public function invokeClass(string $class, array $vars = []) { try { //通过反射实例化类 $reflect = new ReflectionClass($class); } catch (ReflectionException $e) { throw new ClassNotFoundException('class not exists: ' . $class, $class, $e); } if ($reflect->hasMethod('__make')) { //返回的$method包含'__make'的各种信息，如公有/私有 $method = $reflect->getMethod('__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; } ``` 以上代码可看出，在一个类中，添加`__make()`方法，在类实例化时，会最先被调用以上最值得一提的是`bindParams()`方法： ``` protected function bindParams(ReflectionFunctionAbstract $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，交给「容器」就好了。