您的位置:首页 > 编程语言 > PHP开发

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

2020-01-12 17:27 344 查看

ThinkPHP 6 从原先的 

App
 类中分离出 
Http
 类,负责应用的初始化和调度等功能,而 
App
 类则专注于容器的管理,符合单一职责原则。

以下源码分析,我们可以从 

App
Http
 类的实例化过程,了解类是如何实现自动实例化的,依赖注入是怎么实现的。

我的官方群点击此处

从入口文件出发

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

入口文件主要代码如下:

[code]// 引入自动加载器,实现类的自动加载功能(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() 实例化时,首先会调用它的构造函数。

[code]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 文件默认内容如下:

[code]return [

'think\Request'          => Request::class,

'think\exception\Handle' => ExceptionHandle::class,

];

合并后,$bind 成员变量的值如下:

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

static::setInstance($this) 实现的作用,如图:

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

instance() 方法的实现:

[code]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() 魔术方法。该方法的实现如下:

[code]public function __get($name)

{

return $this->get($name);

}

实际上是调用 get() 方法:

[code]public function get($abstract)

{

//先检查是否有绑定实际的类或者是否实例已存在

//比如,$abstract = 'http'

if ($this->has($abstract)) {

return $this->make($abstract);

}

// 找不到类则抛出类找不到的错误

throw new ClassNotFoundException('class not exists: ' . $abstract, $abstract);

}

然而,实际上,主要是 make() 方法:

[code]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() 来实现类的实例化。该方法具体分析:

[code]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() 方法:

[code]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() 方法:

[code]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 类,大概是这样实现的(假如有很多层依赖):

[code].

.

.

$e = new E();

$d = new D($e);

$c = new D($d);

$app = new App($c);

$http = new Http($app);

.

.

.

这得有多累人。而现代 PHP,交给「容器」就好了。容器还有不少功能,后面再详解。

以上就是ThinkPHP6源码:从Http类的实例化看依赖注入是如何实现的的详细内容。

以上内容希望帮助到大家,很多PHPer在进阶的时候总会遇到一些问题和瓶颈,业务代码写多了没有方向感,不知道该从那里入手去提升,对此我整理了一些资料,包括但不限于:分布式架构、高可扩展、高性能、高并发、服务器性能调优、TP6,laravel,YII2,Redis,Swoole、Swoft、Kafka、Mysql优化、shell脚本、Docker、微服务、Nginx等多个知识点高级进阶干货需要的可以免费分享给大家,需要的可以加入我的官方群点击此处

  • 点赞
  • 收藏
  • 分享
  • 文章举报
八重樱。 发布了187 篇原创文章 · 获赞 12 · 访问量 3459 私信 关注
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: