[转]ThinkPHP6.0核心分析--依赖注入原理
in ThinkPHP with 0 comment

[转]ThinkPHP6.0核心分析--依赖注入原理

in ThinkPHP with 0 comment

版权信息

转载自v2ex hubqin 源地址

说明

从这一节开始,我们对一次请求(比如web访问)的生命周期进行分析,涵盖框架个核心功能。这一节 分析AppHttp类的实例化过程,同时了解类是如何实现自动实例化的,即依赖注入是怎么实现的。

再次从入口文件出发

当访问一个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成员变量的值如下: 转thinkphp1.PNG $bind的值是一组类的标识到类的映射。从这个实现也可以看出,我们不仅可以在provider.php文件中添加标识到类的映射,而且可以覆盖其原有的映射,也就是将某些核心类替换成自己定义的类。

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

如图所示: 转thinkphp2.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;
}

执行结果大概是这样的: 转thinkphp3.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方法中对应的参数。