【反射】PHP的反射机制【原创】

摘要：主要是参考列旭松、陈文著的《PHP核心技术与最佳实践》的1.5节。

1.1 定义

反射，直观理解就是根据到达地找到出发地和来源。比如说，给你一个光秃秃的对象，可以仅仅通过这个对象就能知道它所属的类以及拥有的方法。

反射，指在PHP运行状态中，扩展分析PHP程序，导出或提取出关于类、方法、属性、参数等的详细信息，包括注释。这种动态获取信息以及动态调用对象方法的功能称为反射API。

1.2 获取对象属性和方法

getMethods和 getProperties分别用来获取对象的所有方法和所有属性，返回对象数组，然后通过getName来获取具体的方法和属性即可。但都是必须先通过反射获取类的原型，即使用 $reflect = new ReflectionObject($student);来获取对象的原型。

下面是使用反射API来获取对象的属性和方法：

 
     
   
 
          
        
<?php
/**
 * 使用反射API获取对象的属性和方法
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2017/7/10
 * Time: 15:22
 */
class Person3
{
    public $name;
    public $gender;
    public function say()
    {
        echo $this->name . " is " . $this->gender . "\r\n";
    }
    public function __set($name, $value)
    {
       echo "Setting $name to $value \r\n";
       $this->$name = $value;
    }
    public function __get($name)
    {
        if (!isset($this->$name)) {
            echo '未设置';
            $this->$name = '正在为你设置默认值';
        }
        return $this->$name;
    }
}
$student = new Person3();
$student->name = 'Tom';
$student->gender = 'male';
$student->age = 24;
$student->say();
$reflect = new ReflectionObject($student);
// 获取对象属性列表
$props = $reflect->getProperties();
echo "\r\n对象的属性有：\r\n";
foreach ($props as $prop) {
    echo $prop->getName() . "\n";
}
print_r($props);
// 获取对象方法列表
$methods = $reflect->getMethods();
echo "\r\n对象的方法有：\r\n";
foreach ($methods as $method) {
    echo $method->getName() . "\n";
}
print_r($methods);
echo "------------------分隔线-----------------\r\n";
/**
 * 也可以不用反射 API，而使用class函数来获取对象属性的关联数组以及更多的信息，但是使用反射 API可以获得更多的信息
 */
// 返回对象属性的关联数组
echo "对象属性的关联数组：\r\n";
print_r(get_object_vars($student));
// 返回对象属性列表所属的类
echo "对象属性列表所属的类：\r\n";
print_r(get_class($student));
// 类属性
echo "类属性：\r\n";
print_r(get_class_vars(get_class($student)));
// 返回由类的方法名组成的数组
echo "类的方法名组成的数组：\r\n";
print_r(get_class_methods(get_class($student)));

运行：

Setting age to 24
Tom is male

对象的属性有：
name
gender
age
Array
(
    [0] => ReflectionProperty Object
        (
            [name] => name
            [class] => Person3
        )

    [1] => ReflectionProperty Object
        (
            [name] => gender
            [class] => Person3
        )

    [2] => ReflectionProperty Object
        (
            [name] => age
            [class] => Person3
        )

)

对象的方法有：
say
__set
__get
Array
(
    [0] => ReflectionMethod Object
        (
            [name] => say
            [class] => Person3
        )

    [1] => ReflectionMethod Object
        (
            [name] => __set
            [class] => Person3
        )

    [2] => ReflectionMethod Object
        (
            [name] => __get
            [class] => Person3
        )

)
------------------分隔线-----------------
对象属性的关联数组：
Array
(
    [name] => Tom
    [gender] => male
    [age] => 24
)
对象属性列表所属的类：
Person3类属性：
Array
(
    [name] =>
    [gender] =>
)
类的方法名组成的数组：
Array
(
    [0] => say
    [1] => __set
    [2] => __get
)

1.3 还原类的原型

既然上面已经可以使用反射来获取对象的属性和方法了，那么再进一步，获取方法和属性的访问权限，那么就可以根据对象来获取类的原型了：

 
     
   
 
          
        
<?php
/**
 * 使用反射 API 来还原类的原型
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2017/7/13
 * Time: 17:42
 */
class Person4
{
    public $name;
    private $gender;
    public function say()
    {
        echo $this->name . " is " . $this->gender . "\r\n";
    }
    public function __set($name, $value)
    {
        echo "Setting $name to $value \r\n";
        $this->$name = $value;
    }
    public function __get($name)
    {
        if (!isset($this->$name)) {
            echo '未设置';
            $this->$name = '正在为你设置默认值';
        }
        return $this->$name;
    }
    protected function run($method)
    {
        echo $this->name . ' runned with' . $method;
    }
}
// 反射获取类的原型
$obj = new ReflectionClass('Person4');
// 获取类的名称
$class_name = $obj->getName();
$methods = $properties = [];
// 获取类的所有属性
foreach ($obj->getProperties() as $value) {
    $properties[$value->getName()] = $value;
}
// 获取类的所有方法
foreach ($obj->getMethods() as $value) {
    $methods[$value->getName()] = $value;
}
echo "class {$class_name}\r\n{\n";
// 如果类有属性的话则进行排序
is_array($properties) && ksort($properties);
// 输出类的属性
foreach ($properties as $key => $value) {
    echo "\t";
    echo $value->isPublic() ? 'public' : '' , $value->isPrivate() ? 'private' : '' , $value->isProtected() ? 'protected' : '' , $value->isStatic() ? 'static' : '';
    echo "\t{$key}\n";
}
echo "\n";
// 对类的方法进行排序
if (is_array($methods)) {
    ksort($methods);
}
// 输出类的方法
foreach ($methods as $key => $value) {
    echo "\t";
    echo $value->isPublic() ? 'public' : '' , $value->isPrivate() ? 'private' : '' , $value->isProtected() ? 'protected' : '' , $value->isStatic() ? 'static' : '';
    echo " function {$key}() {}\n";
}
echo "}\n";
/**
运行：
class Person4
{
    private gender
    public  name
    public function __get() {}
    public function __set() {}
    protected function run() {}
    public function say() {}
}
 */

PHP手册中关于反射API的有很多，可以说，反射完整的描述了一个类或者对象的原型。反射不仅可以用于类和对象，还可以用于函数、扩展模块、异常等。

1.4 反射的invoke方法

invoke方法是个很实用的方法，用来执行一个反射的方法：

<?php
/**
 * 使用反射API的invoke方法来执行反射的方法
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2017/7/13
 * Time: 18:23
 */

class HelloWorld
{
    public function sayHelloTo($name) {
        return 'Hello ' . $name;
    }

}

// 获取反射的方法
$method = new ReflectionMethod('HelloWorld', 'sayHelloTo');
/** 上面的代码和下面注释的代码作用是一样的   */
//$reflectionClass = new ReflectionClass('HelloWorld');
//$method = $reflectionClass->getMethod('sayHelloTo');

// 执行一个反射的方法
echo $method->invoke(new HelloWorld(), 'Mike');    // Hello Mike

其中的：

 
$method = new ReflectionMethod('HelloWorld', 'sayHelloTo');

作用相当于：

$reflectionClass = new ReflectionClass('HelloWorld');
$method = $reflectionClass->getMethod('sayHelloTo');

1.5 动态代理

使用反射的invoke方法，可以实现简单的动态代理：

 
     
   
 
          
        
<?php
/**
 * 使用反射API实现简单的动态代理
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2017/7/14
 * Time: 9:33
 */
class MySql
{
    public function connect($db)
    {
        echo "已经连接到数据库${db[0]}\r\n";
    }
}
/**
 * Class SqlProxy
 * SqlProxy类实现了根据动态传入参数，代替实际的类MySql类的运行，并且在方法运行前后进行拦截，并且可以动态改变类中的方法和属性，这就是简单的动态代理
 */
class SqlProxy
{
    private $target;
    public function __construct($tar)
    {
        $this->target[] = new $tar();
    }
    public function __call($name, $arguments)
    {
        foreach ($this->target as $obj) {
            $method = new ReflectionMethod($obj, $name);
            if ($method) {
                if ($method->isPublic() && !$method->isAbstract()) {
                    echo "方法前拦截记录 Log\r\n";
                    $method->invoke($obj, $arguments);
                    echo "方法后拦截\r\n";
                }
            }
        }
    }
}
$obj = new SqlProxy('MySql');
$obj->connect('member');
$obj->connect('lottery');

运行：

方法前拦截记录 Log
已经连接到数据库member
方法后拦截
方法前拦截记录 Log
已经连接到数据库lottery
方法后拦截

这里简单说明一下，真正的操作类是MySql类，但 SqlProxy类实现了根据动态传入参数，代替实际的类MySql类的运行，并且在方法运行前后进行拦截，并且可以动态改变类中的方法和属性，这就是简单的动态代理。

1.6 反射的作用

反射的用处：

用于文档生成，因此可以用它对文件里的类进行扫描，逐个生成描述文档。
用来做hook实现插件功能
动态代理

在平常开发中，用到反射的地方很有限，主要有两个地方，一个是对对象进行调试，另一个是获取类的信息。而在MVC和插件开发中，使用反射很常见，但是反射的消耗也很大，在可以找到替代方案的情况下，不要滥用反射。

很多时候，善用反射能够保持代码的优雅和简洁，但反射也会破坏类的封装性，因为反射可以使本不应该暴露的方法或者属性被强制暴露了出来，这既是优点也是缺点。

站内首发文章

jiandanokok

发布了64 篇原创文章 · 获赞 47 · 访问量 19万+

私信关注