当前位置:首页 > CMS教程 > Thinkphp > 列表

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

发布:smiling 来源: PHP粉丝网  添加日期:2021-12-09 15:11:51 浏览: 评论:0 

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

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

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

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

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

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

  1. // 在框架目录下的base.php文件 
  2. // 注册核心类到容器 
  3. Container::getInstance()->bind([ 
  4.   'app'          => App::class
  5.   'build'         => Build::class
  6.   'cache'         => Cache::class
  7.   'config'        => Config::class
  8.   ... 
  9. ]); 
  10. // 注册核心类的静态代理 
  11. Facade::bind([ 
  12.   facade\App::class   => App::class
  13.   facade\Build::class  => Build::class
  14.   facade\Cache::class  => Cache::class
  15.   facade\Config::class  => Config::class
  16.   ... 
  17. ]); 
  18. // 注册类库别名 
  19. Loader::addClassAlias([ 
  20.   'App'   => facade\App::class
  21.   'Build'  => facade\Build::class
  22.   'Cache'  => facade\Cache::class
  23.   'Config'  => facade\Config::class
  24.   ... 
  25. ]); 

容器实现:

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

  1. // 实例化缓存类 
  2. app('cache'); 
  3. // app('cache', ['file']); 参数化调用 
  4. // 相当于执行了 
  5. Container::get('cache'); 
  6. // 查看源码,Container调用的其实是make方法,在该方法里调用反射等实现类的实例化,过程如下: 
  7. public function make($abstract$vars = [], $newInstance = false) 
  8.   if (true === $vars) { 
  9.     // 总是创建新的实例化对象 
  10.     $newInstance = true; 
  11.     $vars    = []; 
  12.   } 
  13.   if (isset($this->instances[$abstract]) && !$newInstance) { 
  14.     $object = $this->instances[$abstract]; 
  15.   } else { 
  16.     if (isset($this->bind[$abstract])) { 
  17.       $concrete = $this->bind[$abstract]; 
  18.        // 闭包实现 
  19.       if ($concrete instanceof \Closure) { 
  20.         $object = $this->invokeFunction($concrete$vars); 
  21.       } else { 
  22.         $object = $this->make($concrete$vars$newInstance); 
  23.       } 
  24.     } else { 
  25.        // 反射实现 
  26.       $object = $this->invokeClass($abstract$vars); 
  27.     } 
  28.     if (!$newInstance) { 
  29.       $this->instances[$abstract] = $object
  30.     } 
  31.   } 
  32.   return $object
  33. /** 
  34.  * 调用反射执行类的实例化 支持依赖注入 
  35.  * @access public 
  36.  * @param string  $class 类名 
  37.  * @param array   $vars 变量 
  38.  * @return mixed 
  39.  */ 
  40. public function invokeClass($class$vars = []) 
  41.   $reflect   = new \ReflectionClass($class); 
  42.   $constructor = $reflect->getConstructor(); 
  43.   if ($constructor) { 
  44.     $args = $this->bindParams($constructor$vars); 
  45.   } else { 
  46.     $args = []; 
  47.   } 
  48.   return $reflect->newInstanceArgs($args); 
  49. /** 
  50.  * 执行函数或者闭包方法 支持参数调用 
  51.  * @access public 
  52.  * @param string|array|\Closure $function 函数或者闭包 
  53.  * @param array         $vars   变量 
  54.  * @return mixed 
  55.  */ 
  56. public function invokeFunction($function$vars = []) 
  57.   $reflect = new \ReflectionFunction($function); 
  58.   $args  = $this->bindParams($reflect$vars); 
  59.   return $reflect->invokeArgs($args); 

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

门面实现:

以一个例子来分析:

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

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

  1. // thinkphp\library\facade\Config 类 
  2. namespace think\facade; 
  3. use think\Facade; 
  4. class Config extends Facade 
  5. // 从源代码上看 Config本身没有任何方法,它继承了Facade的方法,但Facade并没有get这个静态方法 
  6. // 此时,系统自动触发了魔术方法:__callStatic(),Facade重写了此方法: 
  7. public static function __callStatic($method$params
  8.   return call_user_func_array([static::createFacade(), $method], $params); 
  9. // 可见,最后调用的是用户自定义函数:call_user_func_array([实例, 方法], 参数),为了获得Config实例,Facade又定义了一个获取对象的方法: 
  10. /** 
  11.  * 创建Facade实例 
  12.  * @static 
  13.  * @access protected 
  14.  * @param string  $class     类名或标识 
  15.  * @param array   $args      变量 
  16.  * @param bool   $newInstance  是否每次创建新的实例 
  17.  * @return object 
  18.  */ 
  19. protected static function createFacade($class = ''$args = [], $newInstance = false) 
  20.   $class    = $class ?: static::class
  21.   $facadeClass = static::getFacadeClass(); 
  22.   if ($facadeClass) { 
  23.     $class = $facadeClass
  24.   } elseif (isset(self::$bind[$class])) { 
  25.     $class = self::$bind[$class]; 
  26.   } 
  27.   if (static::$alwaysNewInstance) { 
  28.     $newInstance = true; 
  29.   } 
  30.   return Container::getInstance()->make($class$args$newInstance); 
  31. // 其内部是通过容器来实例化对象 
  32. // 因为在base.php中已经将 think\Config 类绑定到 config 这个标识 
  33. Container::getInstance()->bind([ 
  34.   'config' => Config::class 
  35. ]) 
  36. // 在 createFacade 方法中,获取类的名称:$class = $class ?: static::class; 即得到 config 这个标识 
  37. // 在容器的make方法中,根据config标识,找到绑定的 think\Config 类,并调用其动态方法 get。 
  38. facade\Config::get('app_debug'); 
  39. // 最后调用的是: 
  40. (new think\Config())->get('app_debug'); 

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

Tags: thinkphp5 1 Container Facade

分享到: