欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2023-12-26 21:40:21
ThinkPHP 6 从原先的 App 类中分离出 Http 类,负责应用的初始化和调度等功能,而 App 类则专注于容器的管理,符合单一职责原则。 以下源码分析,我们可以从 App,Http 类的实例化过程,了解类是如何实现自动实例化的,依赖注入是怎么实现的。 从入口文件出发 当访问一个 Thin ......

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

以下源码分析,我们可以从 apphttp 类的实例化过程,了解类是如何实现自动实例化的,依赖注入是怎么实现的。

 

从入口文件出发

当访问一个 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 成员变量的值如下:

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

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

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

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

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;

}

 

执行结果大概是这样的:

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

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相关知识请关注我的专栏php​zhuanlan.zhihu.com

上一篇:

下一篇: