###1、基于反射机制可以实现哪些功能？
基于Class的反射机制，我们主要可以实现以下三种功能：
```
1、利用注释生成简单的文档，实现注释即是文档的概念，注意，这种生成文档的方式是为了省力，并不会精修文档，如果对文档的细节要求很高，就需要手写文档。
2、实现钩子机制，自动触发成员函数。
3、实现插件机制，实现程序的安装卸载。
```
当然，Class反射机制的强大，并不单止可以实现以上功能，还能可以运用在其他地方，但作为筑基期的知识点，同学们只需要掌握上面三种机制就可以了。

###1、基于反射机制：实现注释生成文档
实现注释生成文档，主要是依赖反射机制获得成员函数的注释，然后基于注释的规范风格，进行参数切割(不建议使用正则表达式，因为效率太低)，然后生成对应的html结构。

生成文档需要对注释风格编写是统一，并且规范才有可能实现，一旦不规范注释，就有可能生成错误。

具体的案例代码如下：
```php
<?php
# 测试用的A类
class TestA {
    /**
     * 尼妹的
     * @author 小黄牛
     * @version v1.0.0.1
     * @deprecated v1.0.9.* 版本后弃用 
     * @global 无
     * @todo 后期这个函数需要优化到神一样的执行速度
     * @param string $name 打死你
     * @param string $name 打死你
     * @param string $name 打死你
     * @return void
    */
    public function orderBackA() {}

/**
     * 你哥的
     * 这是一个给小黄牛用的函数，哈哈，不服你来打我啊
     *
     * @author 小黄牛
     * @version v1.0.0.1
     * @deprecated v1.0.9.* 版本后弃用 
     * @global 无
     * @todo 后期这个函数需要优化到神一样的执行速度
     * @param string $name 打死你
     * @param string $name 打死你
     * @param string $name 打死你
     * @return void
    */
    private function orderBackB() {}
}

# 文档生成类
class WordApi{
    private $_obj_Public;
    private $_obj_Private;
    private $_obj_Protected;
    private $_wordData;
    private $_length = 0;
    private $_wordGroup = [
        '@author'     => '作者',
        '@version'    => '版本',
        '@deprecated' => '废弃说明',
        '@global'     => '全局变量',
        '@todo'       => '优化建议',
        '@param'      => '参数',
        '@return'     => '返回值',
    ];

/**
     * 自动反射类
     *
     * @param string $className 类名
    */
    public function __construct($className) {
        # 使用ReflectionClass类
        $class = new ReflectionClass($className);
        # 获得成员函数
        $this->_obj_Public    = $class->getMethods(ReflectionMethod::IS_PUBLIC);
        $this->_obj_Private   = $class->getMethods(ReflectionMethod::IS_PRIVATE);
        $this->_obj_Protected = $class->getMethods(ReflectionMethod::IS_PROTECTED);
        # 自动触发解析
        $this->getFunction();
        $this->getNotes();
    }

/**
     * 反射类下面的所有成员函数名称
    */
    private function getFunction() {
        # 读取不同权限下的方法名称
        foreach ($this->_obj_Public as $method) {
            $this->_wordData[$this->_length]['obj']   = $method;
            $this->_wordData[$this->_length]['class'] = $method->class;
            $this->_wordData[$this->_length]['name']  = $method->name;
            $this->_wordData[$this->_length]['auto']  = ['控制权限', 'public'];
            $this->_length++;
        }
        foreach ($this->_obj_Private as $method) {
            $this->_wordData[$this->_length]['obj']   = $method;
            $this->_wordData[$this->_length]['class'] = $method->class;
            $this->_wordData[$this->_length]['name']  = $method->name;
            $this->_wordData[$this->_length]['auto']  = ['控制权限', 'private'];
            $this->_length++;
        }
        foreach ($this->_obj_Protected as $method) {
            $this->_wordData[$this->_length]['obj']   = $method;
            $this->_wordData[$this->_length]['class'] = $method->class;
            $this->_wordData[$this->_length]['name']  = $method->name;
            $this->_wordData[$this->_length]['auto']  = ['控制权限', 'protected'];
            $this->_length++;
        }
    }

/**
     * 解析成员函数对应的注释内容
    */
    private function getNotes() {
        foreach ($this->_wordData as $key=>$val) {
            # 获得成员函数对应的注释内容
            $note = $val['obj']->getDocComment();
            # 删除头尾标记(这里的第三个换行删除很重要)
            $note = str_replace(['/**', '*/', '
    '], '', $note);
            $note = explode(' *', $note);
            # 删除为空数组并更新键名索引
            $note = array_values(array_filter($note));

foreach ($note as $k=>$v) {
                foreach ($this->_wordGroup as $kk=>$vv) {
                    if (strrpos($v, $kk) !== false) {
                        unset($this->_wordData[$key]['obj']); // 删除操作对象
                        $name = str_replace('@', '', $kk);
                        $this->_wordData[$key][$name][0] = $vv;
                        $word = str_replace(" $kk ", '', $v);

# 对一些标记元做特殊处理
                        if (strrpos($v, '@param') !== false) {
                            $array = explode(' ', $word);
                            $this->_wordData[$key][$name][1][$k] = $array;
                        } else {
                            $this->_wordData[$key][$name][1] = $word;
                        }
                    } else {
                        if ($k == 0) {
                            $this->_wordData[$key]['title'][0] = '标题';
                            $this->_wordData[$key]['title'][1] = $v;
                        } else if ($k == 1) {
                            $this->_wordData[$key]['des'][0] = '详情';
                            if (strrpos($v, '@') === false) {
                                $this->_wordData[$key]['des'][1] = $v;
                            } else {
                                $this->_wordData[$key]['des'][1] = '';
                            }
                            
                        }
                    }
                }
            }
        }
    }

/**
     * 生成文档 
    */
    public function makeWord() {
        $table = "<br/>函数规范：<hr/><table><tr><td width='150'>标记元</td><td width='120'>说明</td><td>详细</td></tr>";
        $html  = '';
        foreach ($this->_wordData as $key=>$val) {
            foreach ($val as $k=>$v) {
                if ($k == 'class') {
                    $html .= "<h2>函数路径：$v -> ";
                } else if ($k == 'name') {
                    $html .= "$v();</h2><hr/>";
                } else if ($k == 'auto') {
                    $html .= '<h3>'.$v[0].'：'.$v[1].'<h3/>';
                } else if ($k == 'title') {
                    $html .= '<h3>'.$v[0].'：'.$v[1].'<h3/>';
                    if (empty($val['des'])) {
                        $html .= $table;
                    }
                } else if ($k == 'des') {
                    $html .= '<h3>'.$v[0].'：'.$v[1].'<h3/>'.$table;
                } else if ($k != 'param') {
                    $html .= '<tr><td>@'.$k.'</td><td>'.$v[0].'</td><td>'.$v[1].'</td></tr>';
                }
            }
            $html .= '</table>';
            if (!empty($val['param'])) {
                $html .= "<br/>函数参数：<hr/><table><tr><td width='150'>变量名</td><td width='120'>类型</td><td>说明</td></tr>";
                foreach ($val['param'][1] as $k=>$v) {
                    $html .= '<tr><td>'.$v[1].'</td><td>'.$v[0].'</td><td>'.$v[2].'</td></tr>';
                }
                $html .= '</table><hr/><br/>';
            }
        }
        echo $html;
    }

}

# 使用demo
$obj = new WordApi('TestA');
$obj->makeWord();
```

###2、基于反射机制：实现钩子机制
钩子是编程里一个常见的概念，非常的重要。 它可以让程序变得非常容易扩展(而不用理解其内部的实现机理，这样可以减少很多工作量)。

只要有一个钩子样本，能很容易仿照第一个钩子快速的编写出第二个钩子，

(钩子是插件的原型，只有先理解钩子的实现原理，才有可能掌握插件机制)

下面我们通过一个简单的案例对钩子进行一个简单的理解：
```php
<?php
class Test {
    public static function example() {
        $arr = [1, 2];

echo '我是一个钩子测试<br/>';
        echo 'hello<br/>';

var_dump($arr);
    }
}

Test::example();
```
一个`Test`类里面，写了一个`example()`方法。

本来这个`example()`的方法非常简单，就是输出`hello`，

但是在这之前，我们刚好还有其他的事情要做

(例如：假定在输入`hello`之前，有一个字符串要输出，并且在之后有个数组要打印)。

那么我们现在有2种实现写法：

1、直接在成员函数里实现我们需要的功能(就像上面的案例代码那样)；

但是这种方式有个问题，就是我们每次更改程序，都需要去更改系统的核心部分(我们假定Test是系统的核心部分)，这样会需要我们每次改动都要跳到Test类内部去改动，开发成本非常大，而且代码全部在一起非常不好维护。

2、我们封装一个`execute()`自定义函数（注意不是class的成员函数），只需要调用这个函数就相当于触发程序执行：
```php
<?php
function execute($params) {
    if(is_array($params)){
        var_dump($params);
    }else{
        echo $params;
    }
}

class Test {
    public static function example() {
        execute('我是一个钩子测试<br/>');

echo 'hello<br/>';

execute([1, 2]);
    }
}

Test::example();
```
但是现在仍然有个问题，我们改动的时候，仍然要去系统内部改动

(如果是简单的数组和字符串，是可以进行配置，但是如果是复杂的逻辑处理，那么单靠配置`execute()`函数肯定行不通)。

这时候我们可以设计一个类，这个类实现了`execute()`函数的钩子触发、配置逻辑分离的功能，

通过这个类，向系统发送消息的时候，系统可以直接调用我们的类，

而且我们的类只要遵循一定的规则来设计，就和原系统是相容的。

做了改进后的钩子格式代码如下：
```php
<?php
# 钩子类
class Hook {
    /**
     * 触发钩子
     * @param string $type  事件类型
     * @param string $model 触发对象
    */
    static public function execute($type, $model) {
        $obj = new $model();

if ($type == 'string') {
            $obj->string();
        } elseif ($type == 'array') {
            $obj->array();
        }
    }
}

# 钩子对象类
class Hello {
    public function string() {
        $str = '我是一个钩子测试<br>';
        echo $str;
    }

public function array() {
        var_dump([1, 2]);
    }
}

# 测试类
class Test {
    public static function example() {
        Hook::execute('string', 'Hello');

echo 'hello<br/>';

Hook::execute('array', 'Hello');
    }
}

Test::example();
```
从上面可以看出，组成一个单独的类，系统的内部固定了后，外部可以写各种类，进行钩子的实现。

现在写了一个`Hello`类，假如需要拓展一个`World`类，同样可以仅仅改动`Hook`内部，增加更多的构造行为， 而不用去改动`Test`内部，只要我们定义一个抽象类：
```php
<?php
abstract class Behavior{
    abstract public function string();
    abstract public function array();
}
```
然后让所有的拓展类，比如`Hello`类或者`World`类继承这个抽象类，就可以直接编写更多的扩展。

可能很多同学到这里会有些疑惑？

上面所说的案例都是跟反射机制无关的，那使用反射机制应该怎么实现钩子自动触发呢？

别急，下面我们来使用反射机制，实现钩子功能：
```
1、假设，我们Hook类下面有一个plugins目录，里面每一个类，就是一个钩子，而Hook类会自动监听这些钩子。
2、当使用Hook类的execute()成员函数时，就可以触发对应的钩子。
```
```php
<?php
class Hook{
	private $_rootDir;
	private $_Array = [];

/** 
	 * 构造函数
	*/
	public function __construct() {
		$this->_rootDir = dirname(__FILE__) . DIRECTORY_SEPARATOR .'plugins'. DIRECTORY_SEPARATOR;
		# 获得插件目录
		$this->directory($this->_rootDir);
    }

/**
	 * 获得插件的名称
	*/
	public function directory($dir_name){
		$dir_handle = opendir($dir_name);
		if (!$dir_handle) {
			die ('目录打开错误！');
		}
		# 文件名为'0'时，readdir返回FALSE，判断返回值是否不全等
		while (false!==($filename=readdir($dir_handle))) {
			if ($filename!='.' && $filename!='..') {
				$file = ltrim($dir_name, $this->_rootDir) . $filename;
				$this->_Array[] = trim($file, '.php');
			}
		}
		# 关闭目录句柄
		closedir($dir_handle);
	}

/** 
     * 触发一个钩子 
     * 
     * @param string $hook 钩子的名称 
	 * @param mixed $type 动态调用钩子内的方法
     * @param array $data 钩子的入参 
     * @return mixed 
    */
	public function trigger($hook, $type, $data=[]) { 
		if (!in_array($hook, $this->_Array)) {
			die('钩子不存在');
		}
		# 引入钩子类
		require_once $this->_rootDir.$hook.'.php';
		$class = new ReflectionClass($hook);
		if ($class->hasMethod($type) == false) {
			die ('钩子对应触发的函数不存在');
		}
		# 实例化钩子
		$class = new ReflectionMethod($hook, $type);
		# 触发钩子对应的成员函数，并传参
		$class->invokeArgs(new $hook(), $data);
    } 	
}

# 实例化Hook核心类
$plugin = new Hook();
# 触发一个钩子
$plugin->trigger('Order', 'Hello');
# 再触发一个钩子
$plugin->trigger('User', 'Ri', ['你妹啊', '我日']);
```
上面的案例是我们的核心代码，如果想尝试运行的同学可以下载完整代码后再运行： [下载](https://blog.junphp.com/cangjingge/php/13.zip "下载")。

相对于不使用反射机制实现的钩子触发功能，这样的实现方式是不是要灵活许多，

基于这种实现方式的钩子机制还能升级成插件机制，实现许多插件扩展的功能。

###3、基于反射机制：实现插件机制
插件机制是钩子的一个衍生，不同插件机制都有各自规定的的一套规范跟标准，

例如：
```
plugins目录下，每一个文件夹为一个插件；
插件中必须存在一个config/config.php文件，为这个插件的配置及描述信息；
同时该插件下，必须存在一个以.hook.php为后缀名的class类文件，该类为插件钩子触发对象。
```
以上，就是一套相对完整的插件机制规范了。

当然，如果我们还需要对齐进行升级的话，还可以继续定义：
```
如果有数据库操作，必须存在一个config/db.php文件，为数据库信息；
如果有数据库操作，必须存在一个config/mysql.sql文件，为数据库导入文件；
插件类里还必须实现一些抽象的成员函数，用于对应插件的安装、卸载、关闭操作等。
```
由于使用反射机制实现插件机制的代码较多，就不放在案例中的，

至于下面的练习题就是使用上面钩子机制的代码升级成插件模式。

下面提供一份老师多年前不使用反射类实现插件机制的代码，让同学们参考学习：[下载](https://blog.junphp.com/cangjingge/php/14.zip "下载")。

###4、练习题
实现上面所说的插件机制：

规则如下：
```
plugins目录下，每一个文件夹为一个插件；
插件中必须存在一个config/config.php文件，为这个插件的配置及描述信息；
同时该插件下，必须存在一个以.hook.php为后缀名的class类文件，该类为插件钩子触发对象。
```

答案：[下载](https://blog.junphp.com/cangjingge/php/15.zip "下载")。

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺