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

thinkphp5.1框架中容器(Container)和门面(Facade)的实现方法分析

程序员文章站 2023-09-08 09:43:42
本文实例讲述了thinkphp5.1框架中容器(container)和门面(facade)的实现方法。分享给大家供大家参考,具体如下: tp5.1中引入了容器(conta...

本文实例讲述了thinkphp5.1框架中容器(container)和门面(facade)的实现方法。分享给大家供大家参考,具体如下:

tp5.1中引入了容器(container)和门面(facade)这两个新的类

官方文档已经给出了定义:

容器(container)实现类的统一管理,确保对象实例的唯一性。

门面(facade)为容器(container)中的类提供了一个静态调用接口,相比于传统的静态方法调用, 带来了更好的可测试性和扩展性,你可以为任何的非静态类库定义一个facade类。

深入源码,我们来看看它到底是如何实现的:

// 在框架目录下的base.php文件
// 注册核心类到容器
container::getinstance()->bind([
  'app'          => app::class,
  'build'         => build::class,
  'cache'         => cache::class,
  'config'        => config::class,
  ...
]);
// 注册核心类的静态代理
facade::bind([
  facade\app::class   => app::class,
  facade\build::class  => build::class,
  facade\cache::class  => cache::class,
  facade\config::class  => config::class,
  ...
]);
// 注册类库别名
loader::addclassalias([
  'app'   => facade\app::class,
  'build'  => facade\build::class,
  'cache'  => facade\cache::class,
  'config'  => facade\config::class,
  ...
]);

容器实现:

这里,框架已经帮我们绑定了系统常用类到容器中,在之后使用时,只需要调用助手函数 app()进行容器中的类解析调用,对于已经绑定的类标识,会自动快速实例化。

// 实例化缓存类
app('cache');
// app('cache', ['file']); 参数化调用
// 相当于执行了
container::get('cache');
// 查看源码,container调用的其实是make方法,在该方法里调用反射等实现类的实例化,过程如下:
public function make($abstract, $vars = [], $newinstance = false)
{
  if (true === $vars) {
    // 总是创建新的实例化对象
    $newinstance = true;
    $vars    = [];
  }
  if (isset($this->instances[$abstract]) && !$newinstance) {
    $object = $this->instances[$abstract];
  } else {
    if (isset($this->bind[$abstract])) {
      $concrete = $this->bind[$abstract];
       // 闭包实现
      if ($concrete instanceof \closure) {
        $object = $this->invokefunction($concrete, $vars);
      } else {
        $object = $this->make($concrete, $vars, $newinstance);
      }
    } else {
       // 反射实现
      $object = $this->invokeclass($abstract, $vars);
    }
    if (!$newinstance) {
      $this->instances[$abstract] = $object;
    }
  }
  return $object;
}
/**
 * 调用反射执行类的实例化 支持依赖注入
 * @access public
 * @param string  $class 类名
 * @param array   $vars 变量
 * @return mixed
 */
public function invokeclass($class, $vars = [])
{
  $reflect   = new \reflectionclass($class);
  $constructor = $reflect->getconstructor();
  if ($constructor) {
    $args = $this->bindparams($constructor, $vars);
  } else {
    $args = [];
  }
  return $reflect->newinstanceargs($args);
}
/**
 * 执行函数或者闭包方法 支持参数调用
 * @access public
 * @param string|array|\closure $function 函数或者闭包
 * @param array         $vars   变量
 * @return mixed
 */
public function invokefunction($function, $vars = [])
{
  $reflect = new \reflectionfunction($function);
  $args  = $this->bindparams($reflect, $vars);
  return $reflect->invokeargs($args);
}

简而言之,容器内部是通过反射类或闭包等来实现类的实例化。

门面实现:

以一个例子来分析:

facade\config::get('app_debug');

我们来分析一下它的实现方式:

// thinkphp\library\facade\config 类
namespace think\facade;
use think\facade;
class config extends facade
{
}
// 从源代码上看 config本身没有任何方法,它继承了facade的方法,但facade并没有get这个静态方法
// 此时,系统自动触发了魔术方法:__callstatic(),facade重写了此方法:
public static function __callstatic($method, $params)
{
  return call_user_func_array([static::createfacade(), $method], $params);
}
// 可见,最后调用的是用户自定义函数:call_user_func_array([实例, 方法], 参数),为了获得config实例,facade又定义了一个获取对象的方法:
/**
 * 创建facade实例
 * @static
 * @access protected
 * @param string  $class     类名或标识
 * @param array   $args      变量
 * @param bool   $newinstance  是否每次创建新的实例
 * @return object
 */
protected static function createfacade($class = '', $args = [], $newinstance = false)
{
  $class    = $class ?: static::class;
  $facadeclass = static::getfacadeclass();
  if ($facadeclass) {
    $class = $facadeclass;
  } elseif (isset(self::$bind[$class])) {
    $class = self::$bind[$class];
  }
  if (static::$alwaysnewinstance) {
    $newinstance = true;
  }
  return container::getinstance()->make($class, $args, $newinstance);
}
// 其内部是通过容器来实例化对象
// 因为在base.php中已经将 think\config 类绑定到 config 这个标识
container::getinstance()->bind([
  'config' => config::class
])
// 在 createfacade 方法中,获取类的名称:$class = $class ?: static::class; 即得到 config 这个标识
// 在容器的make方法中,根据config标识,找到绑定的 think\config 类,并调用其动态方法 get。
facade\config::get('app_debug');
// 最后调用的是:
(new think\config())->get('app_debug');

简而言之,门面的实现是通过php的魔术方法 __callstatic,再配合容器来实现动态类的静态化调用。