本文实例讲述了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. { 
9.   if (true === $vars) { 
10.     // 总是创建新的实例化对象 
11.     $newInstance = true; 
12.     $vars    = []; 
13.   } 
14.   if (isset($this->instances[$abstract]) && !$newInstance) { 
15.     $object = $this->instances[$abstract]; 
16.   } else { 
17.     if (isset($this->bind[$abstract])) { 
18.       $concrete = $this->bind[$abstract]; 
19. 　　　　　　　// 闭包实现 
20.       if ($concrete instanceof \Closure) { 
21.         $object = $this->invokeFunction($concrete, $vars); 
22.       } else { 
23.         $object = $this->make($concrete, $vars, $newInstance); 
24.       } 
25.     } else { 
26. 　　　　　　　// 反射实现 
27.       $object = $this->invokeClass($abstract, $vars); 
28.     } 
29.     if (!$newInstance) { 
30.       $this->instances[$abstract] = $object; 
31.     } 
32.   } 
33.   return $object; 
34. } 
35. /** 
36.  * 调用反射执行类的实例化 支持依赖注入 
37.  * @access public 
38.  * @param string  $class 类名 
39.  * @param array   $vars 变量 
40.  * @return mixed 
41.  */ 
42. public function invokeClass($class, $vars = []) 
43. { 
44.   $reflect   = new \ReflectionClass($class); 
45.   $constructor = $reflect->getConstructor(); 
46.   if ($constructor) { 
47.     $args = $this->bindParams($constructor, $vars); 
48.   } else { 
49.     $args = []; 
50.   } 
51.   return $reflect->newInstanceArgs($args); 
52. } 
53. /** 
54.  * 执行函数或者闭包方法 支持参数调用 
55.  * @access public 
56.  * @param string|array|\Closure $function 函数或者闭包 
57.  * @param array         $vars   变量 
58.  * @return mixed 
59.  */ 
60. public function invokeFunction($function, $vars = []) 
61. { 
62.   $reflect = new \ReflectionFunction($function); 
63.   $args  = $this->bindParams($reflect, $vars); 
64.   return $reflect->invokeArgs($args); 
65. } 

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

门面实现：

以一个例子来分析：

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

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

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

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

Tags: thinkphp5 1 Container Facade

分享到：