TP5 automatic registration hook mechanism hook extension, with a complete case

There are two ways to use hook mechanism , notes ： You can only choose one of them ：
1、 use thinkphp5 Built in hook call scheme . Configuration parameters jntoo_hook_call by true It works only when , For compatibility, the use of hook mechanism has been written
2、 Adopt its own hook calling scheme , This method supports hook classification , Hook weight automatic sorting

Personal not recommended think Built in hook as an extension of the system .

How to write auto load file ：
Create a new one under the module hook Catalog , And create... In the directory Category.php file , Here's the picture ：

The class name is equal to the hook type , Method name equals hook name .（ notes ： Types only exist in hook mechanism methods 2. Method 1 Only method name takes effect ）
As shown in the figure ：

We created Category Type of hook
There are two ways ：
index and index_5

Method 1 Call method of ：\think\Hook::listen('index'); You can directly call Category class index Method .
Output results ：

Method 2 Call method of ：\app\common\Hook::call('Category','index'); You can call Category class index Methods and index_5 Method
Output results ：

Method 2 Why can call Category.index Hook will call Category.index_5 This hook ？ We will explain this later .


Tell me a little story
One day, the customer said that he wanted to implement a member registration module .
I've finished the registration module of code members after typing for half a day .
The next day the customer said “ Now there is no problem with customer registration , I wonder if I can add it to him after registration 50 integral , So that he can make some consumption .”, I said, “ That's all right. ”
After knocking on the code for half a day, I completed the customer's requirements . Now after registering for membership , Free 50 I've got points .
On the third day, my colleague asked me if you did not get a registration module and give points in the system two days ago ？ I said yes . Colleagues said “ Submit this to you svn library , I also have a customer who wants to get a registration module and give away points , Also add send mail verification ”, I ：“ well , But you should add email verification yourself .” Code commit to svn library ,
My colleague knocked the code for a long time , Finished sending email .
On the fourth day, I asked my colleague to submit SVN library , Let me synchronize the code .
On the fifth day, another customer asked me “ Does your registration module have a member registration verification mobile phone ”, Of course, I can only say that there is （ In fact, there is no SMS authentication ）, Customer said ” Can you set up the environment for me to test ？“, I can only say ：“ Sorry, sir , We haven't installed the environment yet , I'll fix this for you tomorrow , You are testing ”, Customer said “ good ”
It took a long time to add the member registration mobile phone verification to the member registration module .
On the sixth day, the customer thought it was very good .
Here's the story .
Suppose the formation of the above member registration module is such a code fragment ：

1. namespace app\index\controller;
2.  
3. class member{
4.        function register($username , $password , $tel , $email){
5.               //  The code added on the fifth day ：
6.               if( Whether SMS verification )
7.                      VerifTel($tel ,  Verification Code );
8.               //  Code written on day one ：
9.               if(table('member')->where('username' , $username)->count())
10.               {
11.                      $this->error = ' User name already exists '
12.                      return false;
13.               }
14.               $uid =  Write to the database to get new users UID
15.               .... Omit most of the code
16.              
17.               //  The code added the next day ：
18.               if( Bonus points )
19.                     sendPoints($uid .  Bonus points ); //  Send points 50
20.               //  On the third day
21.              if( Send E-mail )
22.                    sendEmail($uid ,  mail );
23.              
24.              return true;
25.        }
26. }

As we can see from the above , When you finish writing a function module , I don't know the situation of some customers' needs , We will add code to the current module .
If you keep on adding , When you look back at the code, you will find that you have too much code .
Can this code become more elegant

What if we add a hook mechanism to this code ？
Look at the code below

1. namespace app\index\controller;
2. class member{
3.        function register($username , $password , $tel , $email){
4.               
5.               //  I don't know what it will be like in the future , First add a front hook , Parameters ：$username,$password,$tel,$email
6.               $param = [ $username,$password,$tel,$email ];
7.               \app\common\Hook::call('member','registerPre',$param);
8.                
9.               //  Code written on day one ：
10.               if(table('member')->where('username' , $username)->count())
11.               {
12.                      $this->error = ' User name already exists '
13.                      return false;
14.               }
15.               $uid =  Write to the database to get new users UID
16.               .... Omit most of the code
17.              
18.              //  I don't know what it will be like in the future , Add a hook after successful registration , Parameters  $uid
19.               $param = [ $uid ];
20.               \app\common\Hook::call('member','registerSuccess',$param);
21.               
22.              return true;
23.        }
24. }

So the problem is how to solve the hook problem ？
Suppose our classes have been registered in the hook ：
Let's finish the next day , The following code ：

1. namespace app\index\hook;
2. class member{
3.        //  Hook type , Hang the  member  Type hook , Medium registerSuccess hook
4.        function registerSuccess($uid)
5.        {
6.               if( Bonus points )
7.                     sendPoints($uid .  Bonus points ); //  Send points 50
8.        }
9. }

What should my colleagues do with my code on the third day ？ Then I will tell him ：“ I have put two hooks here , One is to register the front hook , One is the hook after successful registration ” And tell him the type of hook , name , There are also corresponding parameters , Colleagues' code will become like this

1. namespace app\tongshi\hook;
2. class member{
3.        //  Hook type , Hang the  member  Type hook , Medium registerSuccess hook
4.        function registerSuccess($uid)
5.        {
6.               if( Send E-mail )
7.                    sendEmail($uid ,  mail );
8.        }
9. }

On the fifth day, it was like this ：

1. namespace app\index\hook;
2. class member{
3.        //  Hang the  member  Type hook , Medium registerSuccess hook
4.        function registerSuccess($uid)
5.        {
6.               if( Bonus points )
7.                     sendPoints($uid .  Bonus points ); //  Send points 50
8.        }
9.        //  Hang the member  Type hook registerPre hook
10.        function registerPre()
11.        {
12.               if( Whether SMS verification )
13.                      VerifTel($tel ,  Verification Code );
14.        }
15. }

Back to what we said above “ Why can call Category.index Hook will call Category.index_5 This hook ？”

When designing the hook mechanism, I think that hooks may have a sequence , And designed a number that can write weight sorting , Add a number at the end , Sort from small to large , The actual hook registration will automatically delete the tail “_ Numbers ”：



One ： Let's talk about the hook mechanism first
In the project code , You think we need to expand （ Don't expand for the time being ） Place a hook function in place of , When you need to expand , Attach the classes and functions to this hook , You can expand .
That's the idea. It sounds general .
When redeveloping the code written by others , If there is a hook mechanism , The author will tell you where to hook , When you expand, you can upgrade and expand without changing the original code .


This plug-in extends the configuration parameter information ：

1. 1、jntoo_hook_cache
2.       Boolean value , Whether to enable hook compilation cache , You only need to compile once after opening , In the future, it will become lazy loading , If a new hook is installed , You need to call Hook::clearCache()  Clear cache
3.  
4. 2、jntoo_hook_call
5.       Boolean value , Whether to use think Hook system . If the value is true, use think After the hook , You will not be able to use weight sorting and hook automatic classification , Only the methods in the class will be automatically registered to think Hook mechanism
6.  
7. 3、jntoo_hook_path
8.       Under a folder PHP Files automatically register hooks for them
9.       Configuration to realize
10.      jntoo_hook_path => [
11.            [
12.                  'path'=>' Your path ', //  A slash must be added at the end of the path  "/"
13.                  'pattern'=> ' The rules , Class matching rules '  for example ：'/plugin\\\\module\\\\hook\\\\([0-9a-zA-Z_]+)/'
14.            ],
15.            ....
16.     ]
17.  
18. 4、jntoo_hook_plugin
19.       Automatic compilation of multi module directories , Add hook Catalog , Under this directory php The file will automatically register the hook
20.       Configuration to realize ：
21.      'jntoo_hook_plugin' => [
22.             [
23.                  'path'=>' Yours app The module path ',
24.                  'pattern'=> ' The rules , Class matching rules '  for example ：'/plugin\\\\([0-9a-zA-Z_]+)\\\\hook\\\\([0-9a-zA-Z_]+)/'
25.            ],
26.            ....
27.      ]

Please be there. application/tags.php
'app_init' Add ：'\\app\\common\\Hook'
for example ：
// Application behavior extension definition file
return [
// Application initialization
'app_init' => [
'\\app\\common\\Hook'
],
// App start
'app_begin' => [],
// Module initialization
'module_init' => [],
// The operation begins
'action_begin' => [],
// View content filtering
'view_filter' => [],
// Log write
'log_write' => [],
// End of application
'app_end' => [],
];





Please create your own file ：

application\index\controller\Index.php Hook file

1. namespace app\index\controller;
2.  
3. use app\common\Hook;
4. use think\Hook AS thinkHook;
5. class Index
6. {
7.     public function index()
8.     {
9.         Hook::call('Category' , 'index');
10.     }
11. }

application\index\hook\Category.php Hook file

1. <?php
2. /**
3.  * Created by PhpStorm.
4.  * User: JnToo
5.  * Date: 2016/11/12
6.  * Time: 1:11
7.  */
8.  
9. namespace app\index\hook;
10. class Category
11. {
12.     function index()
13.     {
14.         echo ' I am a Category Type hook index Method <br>';
15.     }
16.  
17.     function index_5()
18.     {
19.         echo ' I am a Category Type hook index Method , My weight is relatively low <br>';
20.     }
21. }

application\common\hook.php Master file

1. <?php
2. /**
3.  * Created by PhpStorm.
4.  * User: JnToo
5.  * Date: 2016/11/11
6.  * Time: 22:57
7.  */
8. namespace app\common;
9. use think\Config;
10. use think\Hook as thinkHook;
11. use think\Cache;
12.  
13. /**
14.  *  Please be there. application/tags.php
15.  * 'app_init' Add ：'\\app\\common\\Hook'
16.  *  for example ：
17.  * //  Application behavior extension definition file
18. return [
19. //  Application initialization
20. 'app_init'     => [
21. '\\app\\common\\Hook'
22. ],
23. //  App start
24. 'app_begin'    => [],
25. //  Module initialization
26. 'module_init'  => [],
27. //  The operation begins
28. 'action_begin' => [],
29. //  View content filtering
30. 'view_filter'  => [],
31. //  Log write
32. 'log_write'    => [],
33. //  End of application
34. 'app_end'      => [],
35. ];
36.  
37.  * Class Hook
38.  * @package app\common
39.  */
40.  
41.  
42. class Hook
43. {
44.     /**
45.      *  Use counters when compiling hooks
46.      * @var int
47.      */
48.     static protected $index = 0;
49.  
50.     /**
51.      *  Add reference count
52.      * @var int
53.      */
54.     static protected $indexAdd = 1;
55.  
56.     /**
57.      *  Compiled hook list
58.      * @var array
59.      */
60.     static protected $hookList = array();
61.  
62.     /**
63.      * application/config.php  Add the following configuration information to the file
64.      * @var array
65.      */
66.     static protected $default =[
67.         //  Whether to enable hook compilation cache , You only need to compile once after opening , In the future, it will become lazy loading , If a new hook is installed , You need to call Hook::clearCache()  Clear cache
68.         'jntoo_hook_cache'=>false,
69.         //  Whether the hook is used think Hook system
70.         'jntoo_hook_call'=>false ,
71.         /**
72.          *  Under a folder hook load , Configuration file method implementation
73.          * jntoo_hook_path => [
74.          *     [
75.          *          'path'=>' Your path ', //  A slash must be added at the end of the path  "/"
76.          *          'pattern'=> ' The rules , Class matching rules '  for example ：'/plugin\\\\module\\\\hook\\\\([0-9a-zA-Z_]+)/'
77.          *     ],
78.          *     ....
79.          * ]
80.          */
81.         'jntoo_hook_plugin'=>[],
82.         /**
83.          *   Automatic search under multi module directory , Configuration file method implementation
84.          * 'jntoo_hook_plugin' => [
85.          *     [,
86.          *          'path'=>' Yours app The module path '
87.          *          'pattern'=> ' The rules , Class matching rules '  for example ：'/plugin\\\\([0-9a-zA-Z_]+)\\\\hook\\\\([0-9a-zA-Z_]+)/'
88.          *     ],
89.          *     ....
90.          * ]
91.          */
92.         'jntoo_hook_plugin'=>[],
93.     ];
94.  
95.     /**
96.      *  Provide behavior calls
97.      */
98.     public function run()
99.     {
100.         self::init();
101.     }
102.  
103.     /**
104.      *  Register hook
105.      * @param $type  Hook type
106.      * @param $name  Hook 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.         //  compatible
116.         if(Config::get('jntoo_hook_call'))
117.         {
118.             thinkHook::add($name , $param);
119.         }
120.         return;
121.     }
122.  
123.     /**
124.      *  Clear the cache of the compilation hook
125.      */
126.     static public function clearCache()
127.     {
128.         //  Compile hook cache clearly
129.         if(Config::get('jntoo_hook_cache')){
130.             cache('jntoo_hook_cache' , null);
131.         }
132.     }
133.  
134.     /**
135.      *  Carry out the hook
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();
144.  
145.         $ret = '';
146.         if(Config::get('jntoo_hook_call')){
147.             return thinkHook::listen($name , $array);
148.         }else{
149.  
150.             $key = strtolower($type.'_'.$name);
151.             //  Own call scheme
152.             if(isset(self::$hookList[$key]))
153.             {
154.  
155.                 foreach(self::$hookList[$key] as $r){
156.                     //  Closure processing
157.                     $result = '';
158.                     if(is_callable($r)){
159.                         $result = call_user_func_array($r, $array);
160.                     }elseif(is_object($r)){
161.                         //  Define your own object hook
162.                         if(method_exists($r , $name)){
163.                             $result = call_user_func_array(array($r , $name), $array);
164.                         }
165.                     }else{
166.                         //  Automatically searched hooks
167.                         $class = $r['class'];
168.                         if(class_exists($class , false)){
169.                             //  If it doesn't exist
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.     }
186.  
187.     /**
188.      *  Initialization hook
189.      */
190.     static protected function init()
191.     {
192.         //  Get the cache of the hook
193.         self::$hookList = self::getCache();
194.         if(!self::$hookList)
195.         {
196.             //  Save in the current variable
197.             $saveArray = [];
198.  
199.             //  The hook does not exist , First search app Module under directory
200.             //echo APP_PATH;
201.             //echo ROOT_PATH;
202.  
203.             $result = self::searchDir(APP_PATH);
204.             //  Compile this module first
205.             self::compileHook($result , '/app\\\\([0-9a-zA-Z_]+)\\\\hook\\\\([0-9a-zA-Z_]+)/' , $saveArray);
206.             //print_r($saveArray);
207.             //  Multiple modules realize search loading
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.             }
215.  
216.             //  Single path module search
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.             //  Compile the complete , Now let's do a weight sort
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.         //  Detect his calling method , Need to register to think in , It is not recommended to register to  think  in ,
235.         //  Because this system contains the form of classification , After you register, you will not be able to use the sorting function
236.         if($calltype){
237.             //  Sign up for think  In the hook
238.             self::registorThink();
239.         }else{
240.             //  Register system behavior hook
241.             self::registorCall();
242.         }
243.     }
244.  
245.     /**
246.      *  Register system behavior calls
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.     }
283.  
284.     /**
285.      *  Register the hook in thinkHook  In the hook
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.      *  Search the hook file in the directory
298.      * @param $path string
299.      * @param $saveArray array  Saved file path
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.     }
315.  
316.     /**
317.      *  Compile hook , After compilation, it is directly saved in static member variables  self::$hookList
318.      * @param $filelist array  File path
319.      * @param $namespace string  Namespace rules
320.      * @param $saveHook array  preservation 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.         //  Current reference count
328.         $index = self::$index;
329.         $indexAdd = self::$indexAdd;
330.         foreach ($filelist as $file)
331.         {
332.             require_once($file);
333.             //  Get the loaded class
334.             $class_list = get_declared_classes();
335.             //  Search counters
336.             for($len = count($class_list);$index<$len;$index++)
337.             {
338.                 $classname = $class_list[$index];
339.                 if(preg_match($namespace , $classname))
340.                 {
341.                     //  This class meets our needs
342.                     $ec = new \ReflectionClass($classname);
343.                     //  The type of hook
344.                     $type = basename(strtr($classname , '\\' , '/'));
345.                     foreach($ec->getMethods() as $r){
346.                         if($r->name[0] != '_' && $r->class == $classname){
347.                             //  I don't know how to realize sorting yet   The method name is followed by
348.                             $name = $r->name;
349.                             $listorder = 1;
350.                             if(strpos($name , '_') !== false){
351.                                 //  There is a sort
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] = [];
361.  
362.                             $saveHook[$typename][$listorder.'_'.$indexAdd++] = [
363.                                 'filename'=>str_replace($root_path,'',$file), //  The advantage of saving the file path is convenient and fast loading , No need to search the path
364.                                 'class'=>$classname, //  Save the name of the class
365.                                 'func'=>$r->name,   //  Save method name
366.                                 'listorder'=>$listorder //  Sort , After compilation , Sort the weights
367.                             ];
368.                         }
369.                     }
370.                 }
371.             }
372.         }
373.         self::$index = $index;
374.         self::$indexAdd = $indexAdd;
375.     }
376.  
377.     /**
378.      * @param $path  Search module path
379.      * @return array
380.      */
381.     static protected function searchDir( $path )
382.     {
383.         //  Automatic directory completion
384.         $path = strtr(realpath($path),'\\' , '/');
385.         $char = substr($path,-1);
386.         if( $char != '/' || $char != '\\' ){
387.             $path .= '/';
388.         }
389.         $path .= '*';
390.  
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.      *  Get the compiled hook
403.      * @return bool|array
404.      */
405.     static protected function getCache()
406.     {
407.         if(Config::get('jntoo_hook_cache')){
408.             //  Access to the cache
409.             return cache('jntoo_hook_cache');
410.         }
411.         return false;
412.     }
413.  
414.     /**
415.      *  Save the compiled cache
416.      * @param $value array
417.      * @return bool
418.      */
419.     static protected function setCache( $value )
420.     {
421.         //  Set to permanent cache
422.         if(Config::get('jntoo_hook_cache')){
423.             cache('jntoo_hook_cache' , $value , null);
424.         }
425.         return true;
426.     }
427.  
428. }