thinkphp5 自动注册Hook机制钩子扩展

thinkphp5 自动注册Hook机制钩子扩展
Hook.php 文件已更新
1、修复在linux环境下类的在basename 下无法获取到类名的问题
2、修复linux 环境下无法使用hook::call 调用失败问题

请先安装thinkphp5，包里的文件可直接使用，
application ags.php、applicationindexcontrollerIndex.php 文件都已经把文件名改成tags.php.bak，Index.php.bak

钩子机制我这里分为两种使用方法，注：二者只能选其一：
1、采用thinkphp5内置的钩子调用方案。配置参数 jntoo_hook_call 为true 情况下才有效，为了兼容已经写好了钩子机制的使用
2、采用自有的钩子调用方案，此方法支持钩子分类，钩子权重自动排序

个人不建议使用think内置钩子作为系统的扩展。

如何写自动加载文件：
在模块下新建一个hook目录，并在目录下创建Category.php文件，如下图：

类名等于钩子类型，方法名等于钩子名称。（注：类型只存在于钩子机制方法2。方法1只有方法名生效）
如图所示：

我们创建了 Category 类型的钩子
里面有两个方法：
index 和 index_5

方法1的调用方法： hinkHook::listen('index'); 就可以直接调用到Category 类 index 方法。
输出结果：

方法2的调用方法：appcommonHook::call('Category','index'); 就可以调用到 Category 类 index 方法和index_5 方法
输出结果：

方法2为什么能调用Category.index 钩子时会调用到Category.index_5 这个钩子呢？这个我们后面进行一个讲解。

讲个小故事
有一天客户说要求实现一个会员的注册模块。
我这里键盘敲了半天完成了代码会员的注册模块。
第二天客户说“现在客户注册没问题了，我想能不能在注册完成后给他添加50积分，让他能进行一些消费。”，我说“没问题”
敲敲敲半天代码我完成了客户的要求。现在注册会员后，有赠送50积分了。
第三天同事问我你前两天不是在系统里弄了个注册模块和赠送积分？我说是啊。同事说“把你这个提交一下svn库，我这边也有个客户想弄个注册模块和赠送积分，还要添加发送邮件验证”，我：“好的，不过你要自己添加发送邮件验证。”代码提交到svn库，
同事敲了半天代码，完成了发送邮件。
第四天我找同事让他提交一下SVN库，让我进行一下代码同步。
第五天另一个客户问我“你们的注册模块有没有会员注册验证手机”，这个我当然只能说有（实际上是没有短信认证），客户说”能装好环境让我测试一下？“，我只能说：“抱歉先生，我们现在还没装好环境，这个我明天给您装好，您在测试一下”，客户说“好”
蹭蹭蹭敲了半天代码在会员注册模块上面加了会员注册手机验证。
第六天客户觉得挺好的。
故事讲到这里。
假设以上会员注册模块的形成是这样的一段代码片段：
1. namespace appindexcontroller;
3. class member{
4. function register($username , $password , $tel , $email){
5. // 第五天加的代码：
6. if(是否短信验证)
7. VerifTel($tel , 验证码);
8. // 第一天写的代码：
9. if(table('member')->where('username' , $username)->count())
10. {
11. $this->error = '用户名已存在'
12. return false;
13. }
14. $uid = 写入数据库得到新的用户UID
15. ....省略大部分代码
17. // 第二天加的代码：
18. if(赠送积分)
19. sendPoints($uid . 赠送积分); // 发送积分50
20. // 第三天
21. if(发送邮件)
22. sendEmail($uid , 邮件);
24. return true;
25. }
26. }
复制代码

从以上我们可以看出，当写完一个功能模块的时候，并不知道客户一些需求的情况，我们会在当前模块中加入代码。
如果一直下去加下去，回头看代码的时候你会发现你的代码实在是太多了。
这个代码是不是可以变得优雅一些

如果我们在这个代码中加入钩子机制会是怎么样的呢？
看如下代码
1. namespace appindexcontroller;
2. class member{
3. function register($username , $password , $tel , $email){
5. // 我不知道以后会变成什么样，先加个前置钩子,参数：$username,$password,$tel,$email
6. $param = [ $username,$password,$tel,$email ];
7. appcommonHook::call('member','registerPre',$param);
9. // 第一天写的代码：
10. if(table('member')->where('username' , $username)->count())
11. {
12. $this->error = '用户名已存在'
13. return false;
14. }
15. $uid = 写入数据库得到新的用户UID
16. ....省略大部分代码
18. // 我不知道以后会变成什么样，先加个注册成功后的钩子,参数 $uid
19. $param = [ $uid ];
20. appcommonHook::call('member','registerSuccess',$param);
22. return true;
23. }
24. }
复制代码

那么问题来了我们怎么去解决钩子的问题？
假设我们的类都已经注册进了钩子里：
我们来完成第二天的事情，如下代码：
1. namespace appindexhook;
2. class member{
3. // 钩子类型，挂入 member 类型钩子，中的registerSuccess钩子
4. function registerSuccess($uid)
5. {
6. if(赠送积分)
7. sendPoints($uid . 赠送积分); // 发送积分50
8. }
9. }
复制代码

第三天的时候同事要用我的代码怎么办？那么我会告诉他：“我这边已经下了两个钩子，一个是注册前置钩子，一个是注册成功后的钩子”并告诉他钩子类型，名称，还有相应的参数，同事的代码将变成这样
1. namespace app ongshihook;
2. class member{
3. // 钩子类型，挂入 member 类型钩子，中的registerSuccess钩子
4. function registerSuccess($uid)
5. {
6. if(发送邮件)
7. sendEmail($uid , 邮件);
8. }
9. }
复制代码

第五天的时候这样的：
1. namespace appindexhook;
2. class member{
3. // 挂入 member 类型钩子，中的registerSuccess钩子
4. function registerSuccess($uid)
5. {
6. if(赠送积分)
7. sendPoints($uid . 赠送积分); // 发送积分50
8. }
9. // 挂入member 类型钩子中的registerPre钩子
10. function registerPre()
11. {
12. if(是否短信验证)
13. VerifTel($tel , 验证码);
14. }
15. }
复制代码

回到我们上面讲的“为什么能调用Category.index 钩子时会调用到Category.index_5 这个钩子呢？”

在钩子机制设计时想到钩子有可能有先后顺序，而设计了一个能写入权重排序的数字，在尾部添加数字，排序从小到大排序，实际的钩子注册会自动删除尾部的“_数字”：

一：先来讲讲钩子机制
在项目代码中，你认为要扩展（暂时不扩展）的地方放置一个钩子函数，等需要扩展的时候，把需要实现的类和函数挂载到这个钩子上，就可以实现扩展了。
思想就是这样听起来比较笼统。
在二次开发别人写的代码时，如果有钩子机制，作者会告诉你哪些地方给下了钩子，当你扩展时就可以在不改动原代码的情况下进行一个升级扩展。

本插件扩展配置参数信息：
1. 1、jntoo_hook_cache
2. 逻辑值，是否开启钩子编译缓存，开启后只需要编译一次，以后都将成为惰性加载，如果安装了新的钩子，需要先调用Hook::clearCache() 清除缓存
4. 2、jntoo_hook_call
5. 逻辑值，是否使用think钩子系统。值为真使用think钩子后，将无法使用权重排序和钩子自动分类，只有类中的方法将自动注册到think钩子机制中
7. 3、jntoo_hook_path
8. 某个文件夹下的PHP文件都自动为其注册钩子
9. 配置实现
10. jntoo_hook_path => [
11. [
12. 'path'=>'你的路径', // 路径尾部必须加斜杠 "/"
13. 'pattern'=> '规则,类的匹配规则' 例如：'/plugin\\module\\hook\\([0-9a-zA-Z_]+)/'
14. ],
15. ....
16. ]
18. 4、jntoo_hook_plugin
19. 多模块目录自动编译，在模块文件夹下加入hook目录，此目录下的php文件会自动注册钩子
20. 配置实现：
21. 'jntoo_hook_plugin' => [
22. [
23. 'path'=>'你的app模块路径',
24. 'pattern'=> '规则,类的匹配规则' 例如：'/plugin\\([0-9a-zA-Z_]+)\\hook\\([0-9a-zA-Z_]+)/'
25. ],
26. ....
27. ]
复制代码

请在application/tags.php
'app_init'行为处加上：'\app\common\Hook'
例如：
// 应用行为扩展定义文件
return [
// 应用初始化
'app_init' => [
'\app\common\Hook'
],
// 应用开始
'app_begin' => [],
// 模块初始化
'module_init' => [],
// 操作开始执行
'action_begin' => [],
// 视图内容过滤
'view_filter' => [],
// 日志写入
'log_write' => [],
// 应用结束
'app_end' => [],
];

请自行创建文件：

applicationindexcontrollerIndex.php下钩子文件
1. namespace appindexcontroller;
3. use appcommonHook;
4. use thinkHook AS thinkHook;
5. class Index
6. {
7. public function index()
8. {
9. Hook::call('Category' , 'index');
10. }
11. }
复制代码

applicationindexhookCategory.php钩子文件
1. <?php
2. /**
3. * Created by PhpStorm.
4. * User: JnToo
5. * Date: 2016/11/12
6. * Time: 1:11
7. */
9. namespace appindexhook;
10. class Category
11. {
12. function index()
13. {
14. echo '我是Category类型钩子中的index方法<br>';
15. }
17. function index_5()
18. {
19. echo '我是Category类型钩子中的index方法，我的权重比较低<br>';
20. }
21. }
复制代码

applicationcommonhook.php主文件
1. <?php
2. /**
3. * Created by PhpStorm.
4. * User: JnToo
5. * Date: 2016/11/11
6. * Time: 22:57
7. */
8. namespace appcommon;
9. use thinkConfig;
10. use thinkHook as thinkHook;
11. use thinkCache;
13. /**
14. * 请在application/tags.php
15. * 'app_init'行为处加上：'\app\common\Hook'
16. * 例如：
17. * // 应用行为扩展定义文件
18. return [
19. // 应用初始化
20. 'app_init' => [
21. '\app\common\Hook'
22. ],
23. // 应用开始
24. 'app_begin' => [],
25. // 模块初始化
26. 'module_init' => [],
27. // 操作开始执行
28. 'action_begin' => [],
29. // 视图内容过滤
30. 'view_filter' => [],
31. // 日志写入
32. 'log_write' => [],
33. // 应用结束
34. 'app_end' => [],
35. ];
37. * Class Hook
38. * @package appcommon
39. */
42. class Hook
43. {
44. /**
45. * 编译钩子时使用计数器
46. * @var int
47. */
48. static protected $index = 0;
50. /**
51. * 添加引用计数
52. * @var int
53. */
54. static protected $indexAdd = 1;
56. /**
57. * 已编译好的钩子列表
58. * @var array
59. */
60. static protected $hookList = array();
62. /**
63. * application/config.php 文件中加入如下的配置信息
64. * @var array
65. */
66. static protected $default =[
67. // 是否开启钩子编译缓存，开启后只需要编译一次，以后都将成为惰性加载，如果安装了新的钩子，需要先调用Hook::clearCache() 清除缓存
68. 'jntoo_hook_cache'=>false,
69. // 钩子是否使用think钩子系统
70. 'jntoo_hook_call'=>false ,
71. /**
72. * 某个文件夹下hook加载，配置文件方法实现
73. * jntoo_hook_path => [
74. * [
75. * 'path'=>'你的路径', // 路径尾部必须加斜杠 "/"
76. * 'pattern'=> '规则,类的匹配规则' 例如：'/plugin\\module\\hook\\([0-9a-zA-Z_]+)/'
77. * ],
78. * ....
79. * ]
80. */
81. 'jntoo_hook_plugin'=>[],
82. /**
83. * 多模块目录下自动搜索，配置文件方法实现
84. * 'jntoo_hook_plugin' => [
85. * [,
86. * 'path'=>'你的app模块路径'
87. * 'pattern'=> '规则,类的匹配规则' 例如：'/plugin\\([0-9a-zA-Z_]+)\\hook\\([0-9a-zA-Z_]+)/'
88. * ],
89. * ....
90. * ]
91. */
92. 'jntoo_hook_plugin'=>[],
93. ];
95. /**
96. * 提供行为调用
97. */
98. public function run()
99. {
100. self::init();
101. }
103. /**
104. * 注册钩子
105. * @param $type 钩子类型
106. * @param $name 钩子名称
107. * @param $param Closure|array
108. */
109. static public function add($type , $name , $param , $listorder = 1)
110. {
111. $key = strtolower($type .'_'.$name);
112. isset(self::$hookList[$key]) or self::$hookList[$key] = [];
113. self::$hookList[$key][$listorder.'_'.self::$indexAdd++] = $param;
114. ksort(self::$hookList[$key]);
115. // 兼容
116. if(Config::get('jntoo_hook_call'))
117. {
118. thinkHook::add($name , $param);
119. }
120. return;
121. }
123. /**
124. * 清除编译钩子的缓存
125. */
126. static public function clearCache()
127. {
128. // 清楚编译钩子缓存
129. if(Config::get('jntoo_hook_cache')){
130. cache('jntoo_hook_cache' , null);
131. }
132. }
134. /**
135. * 执行钩子
136. * @param $type string
137. * @param $name string
138. * @param array $array
139. * @param mixe
140. */
141. static public function call($type , $name , &$array = array())
142. {
143. static $_cls = array();
145. $ret = '';
146. if(Config::get('jntoo_hook_call')){
147. return thinkHook::listen($name , $array);
148. }else{
150. $key = strtolower($type.'_'.$name);
151. // 自有的调用方案
152. if(isset(self::$hookList[$key]))
153. {
155. foreach(self::$hookList[$key] as $r){
156. // 闭包处理
157. $result = '';
158. if(is_callable($r)){
159. $result = call_user_func_array($r, $array);
160. }elseif(is_object($r)){
161. // 自己定义对象钩子
162. if(method_exists($r , $name)){
163. $result = call_user_func_array(array($r , $name), $array);
164. }
165. }else{
166. // 自动搜索出来的钩子
167. $class = $r['class'];
168. if(class_exists($class , false)){
169. // 如果不存在
170. if($r['filename'])require_once(ROOT_PATH.$r['filename']);
171. }
172. if(class_exists($class , false)){
173. if(!isset($_cls[$class])){
174. $_cls[$class] = new $class();
175. }
176. $func = $r['func'];
177. $result = call_user_func_array(array($_cls[$class] , $func), $array);
178. }
179. }
180. if($result)$ret.=$result;
181. }
182. }
183. }
184. return $ret;
185. }
187. /**
188. * 初始化钩子
189. */
190. static protected function init()
191. {
192. // 取钩子的缓存
193. self::$hookList = self::getCache();
194. if(!self::$hookList)
195. {
196. // 保存在当前变量中
197. $saveArray = [];
199. // 钩子不存在，先搜索app目录下的模块
200. //echo APP_PATH;
201. //echo ROOT_PATH;
203. $result = self::searchDir(APP_PATH);
204. // 先编译此模块
205. self::compileHook($result , '/app\\([0-9a-zA-Z_]+)\\hook\\([0-9a-zA-Z_]+)/' , $saveArray);
206. //print_r($saveArray);
207. // 多模块实现搜索加载
208. $jntooHook = Config::get('jntoo_hook_plugin');
209. if($jntooHook){
210. foreach($jntooHook as $t){
211. $result = self::searchDir($t['path']);
212. self::compileHook($result , $t['pattern'] , $saveArray);
213. }
214. }
216. // 单个路径的模块搜索
217. $jntooHook = Config::get('jntoo_hook_path');
218. if($jntooHook){
219. foreach($jntooHook as $t){
220. $result = [];
221. self::searchHook($t['path'] , $result);
222. self::compileHook($result , $saveArray);
223. }
224. }
225. // 编译完成，现在进行一个权重排序
226. foreach($saveArray as $k=>$t){
227. ksort($saveArray[$k]);
228. }
229. self::setCache($saveArray);
230. self::$hookList = $saveArray;
231. }
232. //print_r(self::$hookList);
233. $calltype = Config::get('jntoo_hook_call');
234. // 检测他的调用方法，是否需要注册到think中，不建议注册到 think 中，
235. // 因为这个系统含有分类的形式，注册进去后将无法使用排序功能
236. if($calltype){
237. // 注册进think 钩子中
238. self::registorThink();
239. }else{
240. // 注册系统行为钩子
241. self::registorCall();
242. }
243. }
245. /**
246. * 注册系统行为调用
247. */
248. static protected function registorCall()
249. {
250. thinkHook::add('app_init' , function( &$params = null ){
251. $arg = [&$params];
252. Hook::call('system' , 'app_init' , $arg);
253. });
254. thinkHook::add('app_begin' , function( &$params = null ){
255. $arg = [&$params];
256. Hook::call('system' , 'app_begin' , $arg);
257. });
258. thinkHook::add('module_init' , function( &$params = null ){
259. $arg = [&$params];
260. Hook::call('system' , 'module_init' , $arg);
261. });
262. thinkHook::add('action_begin' , function( &$params = null ){
263. $arg = [&$params];
264. Hook::call('system' , 'action_begin' , $arg);
265. });
266. thinkHook::add('view_filter' , function( &$params = null ){
267. $arg = [&$params];
268. Hook::call('system' , 'view_filter' , $arg);
269. });
270. thinkHook::add('app_end' , function( &$params = null ){
271. $arg = [&$params];
272. Hook::call('system' , 'app_end' , $arg);
273. });
274. thinkHook::add('log_write' , function( &$params = null ){
275. $arg = [&$params];
276. Hook::call('system' , 'log_write' , $arg);
277. });
278. thinkHook::add('response_end' , function( &$params = null ){
279. $arg = [&$params];
280. Hook::call('system' , 'response_end' , $arg);
281. });
282. }
284. /**
285. * 将钩子注册进thinkHook 钩子中
286. */
287. static protected function registorThink()
288. {
289. foreach(self::$hookList as $key=>$list)
290. {
291. foreach($list as $r){
292. thinkHook::add($r['func'] , $r['class']);
293. }
294. }
295. }
296. /**
297. * 搜索目录下的钩子文件
298. * @param $path string
299. * @param $saveArray array 保存的文件路径
300. * @return null
301. */
302. static protected function searchHook( $path , &$saveArray)
303. {
304. $fp = opendir($path);
305. if($fp){
306. while($file = readdir($fp))
307. {
308. if(substr($file , -4) == '.php')
309. {
310. $saveArray[] = $path.$file;
311. }
312. }
313. }
314. }
316. /**
317. * 编译钩子,编译后直接保存在静态成员变量 self::$hookList
318. * @param $filelist array 文件路径
319. * @param $namespace string 命名空间规则
320. * @param $saveHook array 保存Hook
321. * @return null
322. */
323. static protected function compileHook($filelist , $namespace , &$saveHook)
324. {
325. $root_path = strtr(ROOT_PATH,'\' , '/');
326. //print_r($filelist);
327. // 当前引用计数
328. $index = self::$index;
329. $indexAdd = self::$indexAdd;
330. foreach ($filelist as $file)
331. {
332. require_once($file);
333. // 获取已经加载的类
334. $class_list = get_declared_classes();
335. // 搜索计数器
336. for($len = count($class_list);$index<$len;$index++)
337. {
338. $classname = $class_list[$index];
339. if(preg_match($namespace , $classname))
340. {
341. // 这个类满足我们的需求
342. $ec = new ReflectionClass($classname);
343. // 钩子的类型
344. $type = basename(strtr($classname , '\' , '/'));
345. foreach($ec->getMethods() as $r){
346. if($r->name[0] != '_' && $r->class == $classname){
347. // 暂时还不知道怎么实现排序方法名后面有
348. $name = $r->name;
349. $listorder = 1;
350. if(strpos($name , '_') !== false){
351. // 存在排序
352. $temp = explode('_',$name);
353. $num = array_pop($temp);
354. if(is_numeric($num)){
355. $name = implode('_' , $temp);
356. $listorder = $num;
357. }
358. }
359. $typename = strtolower($type.'_'.$name);
360. !isset($saveHook[$typename]) AND $saveHook[$typename] = [];
362. $saveHook[$typename][$listorder.'_'.$indexAdd++] = [
363. 'filename'=>str_replace($root_path,'',$file), // 保存文件路径的好处是方便快速加载，无需在进行路径的查找
364. 'class'=>$classname, // 保存类的名称
365. 'func'=>$r->name, // 保存方法名
366. 'listorder'=>$listorder // 排序，编译完成后，进行一个权重的排序
367. ];
368. }
369. }
370. }
371. }
372. }
373. self::$index = $index;
374. self::$indexAdd = $indexAdd;
375. }
377. /**
378. * @param $path 搜索模块路径
379. * @return array
380. */
381. static protected function searchDir( $path )
382. {
383. // 目录自动补全
384. $path = strtr(realpath($path),'\' , '/');
385. $char = substr($path,-1);
386. if( $char != '/' || $char != '\' ){
387. $path .= '/';
388. }
389. $path .= '*';
391. $dirs = glob($path, GLOB_ONLYDIR );
392. $result = array();
393. foreach($dirs as $dir){
394. if(is_dir($dir .'/hook'))
395. {
396. self::searchHook($dir .'/hook/' , $result);
397. }
398. }
399. return $result;
400. }
401. /**
402. * 获取编译好的钩子
403. * @return bool|array
404. */
405. static protected function getCache()
406. {
407. if(Config::get('jntoo_hook_cache')){
408. // 获取缓存
409. return cache('jntoo_hook_cache');
410. }
411. return false;
412. }
414. /**
415. * 保存编译的缓存
416. * @param $value array
417. * @return bool
418. */
419. static protected function setCache( $value )
420. {
421. // 设置为永久缓存
422. if(Config::get('jntoo_hook_cache')){
423. cache('jntoo_hook_cache' , $value , null);
424. }
425. return true;
426. }
428. }
相关阅读:
mysql远程执行sql脚本
 数据库死锁
 sqlserver 数据库之调优
 sqlserver 数据库之性能优化
 Session共享的解决办法
 关于对session机制的理解--通俗易懂
 kafka之常用命令
 分布式消息队列之kafka
vuejs调试代码
 json
原文地址：https://www.cnblogs.com/liliuguang/p/10857501.html