ThinkPHP6原始碼：從Http類別的實例化看依賴注入是如何實現的
- 藏色散人轉載
- 2019-08-16 14:28:513665瀏覽
ThinkPHP 6 從原先的App 類別中分離出Http 類，負責應用的初始化和調度等功能，而 App 類別則專注於容器的管理，符合單一職責原則。
以下原始碼分析，我們可以從App，Http 類別的實例化過程，了解類別是如何實現自動實例化的，依賴注入是怎麼實現的。
從入口文件出發
當訪問一個ThinkPHP 搭建的站點，框架最先是從入口文件開始的，然後才是應用初始化、路由解析、控制器呼叫和回應輸出等操作。
入口檔主要程式碼如下：
// 引入自动加载器，实现类的自动加载功能（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() 實例化時，首先會呼叫它的構造函數。
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)
{
//检查「$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() 魔術方法。這個方法的實作如下：
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)
{
//如果已经存在实例，且不强制创建新的实例，直接返回已存在的实例
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() 來實作類別的實例化。此方法具體分析：
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() 方法：
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() 方法：
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，交給「容器」就好了。容器還有不少功能，後面再詳解。
以上是ThinkPHP6原始碼：從Http類別的實例化看依賴注入是如何實現的的詳細內容。更多資訊請關注PHP中文網其他相關文章！