本文实例讲述了thinkphp5.1框架中容器(Container)和门面(Facade)的实现方法。分享给大家供大家参考,具体如下:
tp5.1中引入了容器(Container)和门面(Facade)这两个新的类
官方文档已经给出了定义:
容器(Container)实现类的统一管理,确保对象实例的唯一性。
门面(Facade)为容器(Container)中的类提供了一个静态调用接口,相比于传统的静态方法调用, 带来了更好的可测试性和扩展性,你可以为任何的非静态类库定义一个facade类。
深入源码,我们来看看它到底是如何实现的:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
// 在框架目录下的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()
进行容器中的类解析调用,对于已经绑定的类标识,会自动快速实例化。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
// 实例化缓存类
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 );
}
|
简而言之,容器内部是通过反射类或闭包等来实现类的实例化。
门面实现:
以一个例子来分析:
1
|
facade\Config::get( 'app_debug' );
|
我们来分析一下它的实现方式:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
// 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
,再配合容器来实现动态类的静态化调用。
希望本文所述对大家基于ThinkPHP框架的PHP程序设计有所帮助。
原文链接:https://www.cnblogs.com/cqingt/p/8243294.html