ThinkPHP5源码学习篇--Hook.php
Hook类解析
在学习TP5源码的过程中，经常有执行Hook::listen()的地方，一查原来是TP5的行为拓展，当应用程序执行到定义的标签时，能够拦截下来执行一些公共的逻辑。对AOP(面向切面编程)了解的不多，只知道在Java的实现中，通过配置文件，非常自由的决定前置、后置，以及应该被环绕的执行方法。从此方面来说，TP5的行为有点相像AOP功能，但是实现度和完整性略有不够。
Hook的功能可以区分为添加、监听、执行三块，虽然内容不多，但是利用的好可以提高我们的业务开发效率，因此还是很有必要研究一下的。
从Hook类的方法清单列表来入手
标签添加行为拓展
/**
* 动态添加行为扩展到某个标签
* @access public
* @param string $tag 标签名称
* @param mixed $behavior 行为名称
* @param bool $first 是否放到开头执行
* @return void
*/
public static function add($tag, $behavior, $first = false)
{
//添加一个标签对应到behavior
//判断是否已添加过当前$tag，若未添加过则$tag对应结构初始化为数组
isset(self::$tags[$tag]) || self::$tags[$tag] = [];
if (is_array($behavior) && !is_callable($behavior)) {
//传入格式如：
/*
[
'app\\index\\behavior\\Test',
'app\\index\\behavior\\Test2'
]
* 为可调用的行为类
* */
//判断是否_overlay键 且对应值是否为true
if (!array_key_exists('_overlay', $behavior) || !$behavior['_overlay']) {
//作追加操作
unset($behavior['_overlay']);
self::$tags[$tag] = array_merge(self::$tags[$tag], $behavior);
} else {
//_overlay是为true，作覆盖操作
unset($behavior['_overlay']);
self::$tags[$tag] = $behavior;
}
} elseif ($first) {
//array_unshift — 在数组开头插入一个或多个单元
//添加到数组开头
array_unshift(self::$tags[$tag], $behavior);
} else {
//默认添加到数组尾部
self::$tags[$tag][] = $behavior;
}
}
①结合isset()和||来初始化标签数组
②区分$behavior的参数类型来实现不同效果
$behavior是数组格式且不可被调用
is_callable()目前发现能够调用的四种情况
- 闭包函数
$callback = function () {
return '123';
};
var_export(is_callable($callback));
//执行结果：true
- 函数
function func()
{
return '123';
}
var_export(is_callable('func'));
//执行结果：true
- 类方法
class Obj
{
public function func()
{
return '123';
}
}
$obj = new Obj();
$param = [$obj, 'func'];
var_export(is_callable($param));
//执行结果：true
- 类静态方法
class Obj
{
public static function func()
{
return '123';
}
}
$param = ['Obj', 'func'];
var_export(is_callable($param));
//执行结果：true
③标签添加方式判断
经过以上判断后，$behavior传入数组格式，按照TP5行为开发准则，举如下示例
[
'app\\index\\behavior\\Test',
'app\\index\\behavior\\Test2'
]
判断是否存在_overlay键，且键值是否为真(true等等)
_overlay键是为了让用户决定在已定义标签行为的基础上，选择追加还是覆盖，视线转回源码，还是比较好理解的。
再来就是$first变量的判断，默认为false，即将新行为添加到标签数组尾部，若传入true，则通过array_unshift()插入数组头部。
顺便一提，这四个函数让PHP的数组实现栈和队列的结构。
array_unshift()、array_shift()、array_push()、array_pop()
从他处看到，PHP被承认推崇的一点是处理字符串和数组极其方便，所以好好研究并能完全掌握字符串和数组的处理函数很有必要。
批量导入
/**
* 批量导入插件
* @access public
* @param array $tags 插件信息
* @param boolean $recursive 是否递归合并
* @return void
*/
public static function import(array $tags, $recursive = true)
{
if ($recursive) {
//逐个赋值
foreach ($tags as $tag => $behavior) {
self::add($tag, $behavior);
}
} else {
//以新传入数据为准，进行两个数据的合并
self::$tags = $tags + self::$tags;
}
}
先看递归合并，其实也就是将二维数组拆分，调用上面讲述的add()方法将单个行为逐个绑定到标签。
而两个数组的合并，数组间的加号处理和array_merge()函数实现数组覆盖的优先不同值得一看。
获取标签的行为列表
/**
* 获取插件信息
* @access public
* @param string $tag 插件位置(留空获取全部)
* @return array
*/
public static function get($tag = '')
{
if (empty($tag)) {
return self::$tags;
}
return array_key_exists($tag, self::$tags) ? self::$tags[$tag] : [];
}
监听标签
/**
* 监听标签的行为
* @access public
* @param string $tag 标签名称
* @param mixed $params 传入参数
* @param mixed $extra 额外参数
* @param bool $once 只获取一个有效返回值
* @return mixed
*/
public static function listen($tag, &$params = null, $extra = null, $once = false)
{
$results = [];
//获取指定标签的行为对应数据
foreach (static::get($tag) as $key => $name) {
//执行行为逻辑，以多维数组的角度考虑
$results[$key] = self::exec($name, $tag, $params, $extra);
// 如果返回 false，或者仅获取一个有效返回则中断行为执行
if (false === $results[$key] || (!is_null($results[$key]) && $once)) {
break;
}
}
//end() 获取数组的最后一个值
return $once ? end($results) : $results;
}
终于来到了文章开头提到的Hook::listen()方法。
参数：
$tag 标签名
$params 引用参数，可在行为内部对值直接操作
$extra 额外参数
$once 决定当行为执行成功返回有效值时，是否中止后续行为的执行
直接观察foreach循环，通过get()方法获取一个标签内所有对应的行为，逐个调用exec()方法来执行，并将结果存储在$result数组内。同时要注意添加了if判断，若行为执行后返回为false或值有效且只获取一个结果，则中止后续待调用行为的执行，最后是行为执行后return结果的获取，以$once作为标识选择调用end()函数获取数组最后一个值或将数组返回。
行为执行过程揭秘
/**
* 执行某个行为
* @access public
* @param mixed $class 要执行的行为
* @param string $tag 方法名（标签名）
* @param mixed $params 传人的参数
* @param mixed $extra 额外参数
* @return mixed
*/
public static function exec($class, $tag = '', &$params = null, $extra = null)
{
//调试模式记录行为开始执行时间
App::$debug && Debug::remark('behavior_start', 'time');
//tag字符串 转换 驼峰定义方式的方法名
$method = Loader::parseName($tag, 1, false);
if ($class instanceof \Closure) {
//若添加的闭包函数，通过call_user_func_array()调用
$result = call_user_func_array($class, [ & $params, $extra]);
//日志记录
$class = 'Closure';
} elseif (is_array($class)) {
//如class对应以下数组
//['\\app\\index\\behavior\\Test', 'myInit1']
//实例化Test类，执行myInit1方法
list($class, $method) = $class;
$result = (new $class())->$method($params, $extra);
$class = $class . '->' . $method;
} elseif (is_object($class)) {
//传入已实例化的对象，以标签名作为方法执行
$result = $class->$method($params, $extra);
$class = get_class($class);
} elseif (strpos($class, '::')) {
//'\\app\\index\\behavior\\Test::myInit2'
$result = call_user_func_array($class, [ & $params, $extra]);
} else {
$obj = new $class();
/*
class Test
{
public function appInit(&$params)
{
}
public function appEnd(&$params)
{
}
}
* 存在这种用法，若监听app_init，同时存在appInit方法，则可直接调用
* */
$method = ($tag && is_callable([$obj, $method])) ? $method : 'run';
$result = $obj->$method($params, $extra);
}
if (App::$debug) {
Debug::remark('behavior_end', 'time');
Log::record('[ BEHAVIOR ] Run ' . $class . ' @' . $tag . ' [ RunTime:' . Debug::getRangeTime('behavior_start', 'behavior_end') . 's ]', 'info');
}
return $result;
}
注释说明的比较明白了。细致点分析就是将exec()方法拆分三块，
调试模式下行为开始执行时间记录
执行行为逻辑
调试模式下行为执行持续时间记录
来看看执行的几种可能情况。
- 闭包函数
Hook::add('callback', function (){
return 'success';
});
var_export(Hook::listen('callback'));
//输出结果：array ( 0 => 'success', )
继续新增第二个闭包
Hook::add('callback', function (){
return 'success';
});
Hook::add('callback', function (){
return 'second success';
});
var_export(Hook::listen('callback'));
//执行结果：array ( 0 => 'success', 1 => 'second success', )
对比两个执行结果了解一个标签对应多个行为的含义。
- 以数组形式传入类名和方法名
class Test
{
public function myInit1(&$param)
{
return 'myInit1';
}
}
--------------------------------------
$tags = ['\\app\\index\\behavior\\Test', 'myInit1'];
Hook::add('HookTest', $tags);
var_export(Hook::listen('HookTest'));
//执行结果：array ( 0 => 'myInit1', )
- 传入已实例化的对象，以标签名作为方法执行
class Test
{
public function HookTest(&$param)
{
return 'HookTest';
}
}
--------------------------------------
$test = new Test();
Hook::add('HookTest', $test);
var_export(Hook::listen('HookTest'));
//执行结果：array ( 0 => 'HookTest', )
- 静态方法
class Test
{
public static function staticHook(&$param)
{
return 'staticHook';
}
}
--------------------------------------
$static = '\\app\\index\\behavior\\Test::staticHook';
Hook::add('HookTest', $static);
var_export(Hook::listen('HookTest'));
//执行结果：array ( 0 => 'staticHook', )
- 标签名作为标记执行
class Test
{
public function run(&$param)
{
return 'run';
}
}
--------------------------------------
Hook::add('HookTest', '\\app\\index\\behavior\\Test');
var_export(Hook::listen('HookTest'));
//执行结果：array ( 0 => 'run', )
++++++++++++++++++++++++++++++++++++++
class Test
{
public function hookTest(&$param)
{
return 'HookTest';
}
}
--------------------------------------
Hook::add('HookTest', '\\app\\index\\behavior\\Test');
var_export(Hook::listen('HookTest'));
//执行结果：array ( 0 => 'HookTest', )
参考执行结果和源码，监听某个标签，若存在标签对应的方法，则执行该方法，否则执行run()。至于这个方法，定义名称需遵循驼峰法命令，在执行前会使用Loader::parseName()转换。
总结
Hook的功能就到这了，个人感觉这块功能从源码中就展示的很清晰，使用也很方便，值得我们学习使用。
说点别的，执行行为的方法时，都会传入$params和$extra变量，而行为实际定义可以并不包含这俩参数，还挺有意思的。
参考代码：
public function index()
{
$this->test(null, null);
}
public function test()
{
echo 'text';
}
public function test($arg1)
{
echo 'text';
}
public function test($arg1, $arg2)
{
echo 'text';
}
以上三个test()方法都能正常执行，
如果被调方法参数多了，那可不行。
public function index()
{
$this->test(null, null);
}
public function test($arg1, $arg2, $arg3)
{
echo 'text';
}
这是会报错的。