[TOC] # 说明 从这一节开始,我们对一次请求(比如web访问)的生命周期进行分析,涵盖框架个核心功能。这一节 分析`App`,`Http` 类的实例化过程,同时了解类是如何实现自动实例化的,即依赖注入是怎么实现的。 # 再次从入口文件出发 当访问一个ThinkPHP搭建的站点,框架最先是从入口文件开始的,然后才是应用初始化、路由解析、控制器调用和响应输出等操作。 入口文件主要代码如下: ``` // 引入自动加载器,实现类的自动加载功能(PSR4标准) // 具体参见上一节分析 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`成员变量的值如下: ![](https://img.kancloud.cn/c9/52/c95263cc87ec4033b9e6f080308ea5b6_365x554.PNG) `$bind`的值是一组类的标识到类的映射。从这个实现也可以看出,**我们不仅可以在`provider.php`文件中添加标识到类的映射,而且可以覆盖其原有的映射,也就是将某些核心类替换成自己定义的类**。 ## `static::setInstance($this)`实现的作用 如图所示: ![](https://img.kancloud.cn/93/87/93879f332fc40e75a87d152d15d61bec_285x47.PNG) `think\App`类的`$instance`成员变量指向`think\App`类的一个实例,也就是类自己保存自己的一个实例。 ## `instance()`方法的实现 ``` public function instance(string $abstract, $instance) { $abstract = $this->getAlias($abstract); //保存绑定的实例到「$instances」数组中 //比如,$this->instances["think\App"] = $instance; $this->instances[$abstract] = $instance; return $this; } ``` 其中的`getAlias`方法: ``` public function getAlias(string $abstract): string { //检查「$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->getAlias($bind); } } return $abstract; } ``` 执行结果大概是这样的: ![](https://img.kancloud.cn/4e/93/4e93bdf853a3dcba636c68ee03ce97c5_355x52.PNG) # 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) { $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()`方法主要靠`invokeClass()`来实现类的实例化(如果绑定的是闭包的话,则靠invokeFunction方法)。该方法具体分析: ``` 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 C($d); $app = new App($c); $http = new Http($app); . . . ``` 这得有多累人。而现代PHP,交给「容器」就好了。 另外,需要提的一点是`make`方法的` $vars`参数,它的形式可以是普通数组、关联数组,而且数组中元素的值可以是一个类的实例。` $vars`参数的值最终将传递给要实例化的类的构造函数或者`__make`方法中对应的参数。