依赖注入底层反射原理_依赖注入原理 · ThinkPHP 6.0 核心分析 · 看云

[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`成员变量的值如下：


`$bind`的值是一组类的标识到类的映射。从这个实现也可以看出，**我们不仅可以在`provider.php`文件中添加标识到类的映射，而且可以覆盖其原有的映射，也就是将某些核心类替换成自己定义的类**。

## `static::setInstance($this)`实现的作用

如图所示：


`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;

}

```

执行结果大概是这样的：


# 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`方法中对应的参数。