当前位置：首页 > PHP教程 > php高级应用 > 列表

深入了解PHP反射API！

发布:smiling　来源: PHP粉丝网 　添加日期：2022-07-16 09:04:59　浏览: 评论：0　

PHP中的反射API就像Java中的java.lang.reflect包一样。它由一系列可以分析属性、方法和类的内置类组成。它在某些方面和对象函数相似，比如get_class_vars()，但是更加灵活，而且可以提供更多信息。

反射API也可与PHP最新的面向对象特性一起工作，如访问控制、接口和抽象类。旧的类函数则不太容易与这些新特性一起使用。看过框架源码的朋友应该对PHP的反射机制有一定的了解，像是依赖注入，对象池，类加载，一些设计模式等等，都用到了反射机制。

反射API的部分类

使用反射API这些类，可以获得在运行时访问对象、函数和脚本中的扩展的信息。通过这些信息可以用来分析类或者构建框架。

类 描 述

Reflection 为类的摘要信息提供静态函数export()

ReflectionClass 类信息和工具

ReflectionMethod 类方法信息和工具

ReflectionParameter 方法参数信息

ReflectionProperty 类属性信息

ReflectionFunction 函数信息和工具

ReflectionExtension PHP扩展信息

ReflectionException 错误类

获取类的信息

我们在工作中使用过一些用于检查类属性的函数，例如：get_class_methods、getProduct等。这些方法对获取详细类信息有很大的局限性。

我们可以通过反射API类：Reflection 和 ReflectionClass 提供的静态方法 export 来获取类的相关信息， export 可以提供类的几乎所有的信息，包括属性和方法的访问控制状态、每个方法需要的参数以及每个方法在脚本文档中的位置。这两个工具类， export 静态方法输出结果是一致的，只是使用方式不同。

首先，构建一个简单的类

  1. <?php 
  2.  
  3. class Student { 
  4.  
  5.     public    $name; 
  6.  
  7.     protected $age; 
  8.  
  9.     private   $sex; 
  10.  
  11.  
  12.  
  13.     public function __construct($name, $age, $sex) 
  14.  
  15.     { 
  16.  
  17.         $this->setName($name); 
  18.  
  19.         $this->setAge($age); 
  20.  
  21.         $this->setSex($sex); 
  22.  
  23.     } 
  24.  
  25.  
  26.  
  27.     public function setName($name) 
  28.  
  29.     { 
  30.  
  31.        $this->name = $name; 
  32.  
  33.     } 
  34.  
  35.  
  36.  
  37.     protected function setAge($age) 
  38.  
  39.     { 
  40.  
  41.         $this->age = $age; 
  42.  
  43.     } 
  44.  
  45.  
  46.  
  47.     private function setSex($sex) 
  48.  
  49.     { 
  50.  
  51.         $this->sex = $sex; 
  52.  
  53.     } 
  54.  
  55. } 

使用 ReflectionClass::export() 获取类信息

ReflectionClass::export('Student');

打印结果：

  1. Class [ class Student ] { 
  2.  
  3.     @@ D:\wamp\www\test2.php 3-29 
  4.  
  5.     - Constants [0] { } 
  6.  
  7.     - Static properties [0] { } 
  8.  
  9.     - Static methods [0] { } 
  10.  
  11.     - Properties [3] { 
  12.  
  13.         Property [ public $name ] 
  14.  
  15.         Property [ protected $age ] 
  16.  
  17.         Property [ private $sex ] 
  18.  
  19.     } 
  20.  
  21.     - Methods [4] { 
  22.  
  23.         Method [ public method __construct ] { 
  24.  
  25.             @@ D:\wamp\www\test2.php 8 - 13 
  26.  
  27.             - Parameters [3] { 
  28.  
  29.                 Parameter #0 [ $name ] 
  30.  
  31.                 Parameter #1 [ $age ] 
  32.  
  33.                 Parameter #2 [ $sex ] 
  34.  
  35.             } 
  36.  
  37.         } 
  38.  
  39.         Method [ public method setName ] { 
  40.  
  41.             @@ D:\wamp\www\test2.php 15 - 18 
  42.  
  43.             - Parameters [1] { 
  44.  
  45.                 Parameter #0 [ $name ] 
  46.  
  47.             } 
  48.  
  49.         } 
  50.  
  51.         Method [ protected method setAge ] { 
  52.  
  53.             @@ D:\wamp\www\test2.php 20 - 23 
  54.  
  55.             - Parameters [1] { 
  56.  
  57.                 Parameter #0 [ $age ] 
  58.  
  59.             } 
  60.  
  61.         } 
  62.  
  63.         Method [ private method setSex ] { 
  64.  
  65.             @@ D:\wamp\www\test2.php 25 - 28 
  66.  
  67.             - Parameters [1] { 
  68.  
  69.                 Parameter #0 [ $sex ] 
  70.  
  71.             } 
  72.  
  73.         } 
  74.  
  75.     } 
  76.  
  77. } 

ReflectionClass类提供了非常多的工具方法，官方手册给的列表如下：

ReflectionClass::__construct — 初始化 ReflectionClass 类

ReflectionClass::export — 导出一个类

ReflectionClass::getConstant — 获取定义过的一个常量

ReflectionClass::getConstants — 获取一组常量

ReflectionClass::getConstructor — 获取类的构造函数

ReflectionClass::getDefaultProperties — 获取默认属性

ReflectionClass::getDocComment — 获取文档注释

ReflectionClass::getEndLine — 获取最后一行的行数

ReflectionClass::getExtension — 根据已定义的类获取所在扩展的 ReflectionExtension 对象

ReflectionClass::getExtensionName — 获取定义的类所在的扩展的名称

ReflectionClass::getFileName — 获取定义类的文件名

ReflectionClass::getInterfaceNames — 获取接口（interface）名称

ReflectionClass::getInterfaces — 获取接口

ReflectionClass::getMethod — 获取一个类方法的 ReflectionMethod。

ReflectionClass::getMethods — 获取方法的数组

ReflectionClass::getModifiers — 获取类的修饰符

ReflectionClass::getName — 获取类名

ReflectionClass::getNamespaceName — 获取命名空间的名称

ReflectionClass::getParentClass — 获取父类

ReflectionClass::getProperties — 获取一组属性

ReflectionClass::getProperty — 获取类的一个属性的 ReflectionProperty

ReflectionClass::getReflectionConstant — Gets a ReflectionClassConstant for a class's constant

ReflectionClass::getReflectionConstants — Gets class constants

ReflectionClass::getShortName — 获取短名

ReflectionClass::getStartLine — 获取起始行号

ReflectionClass::getStaticProperties — 获取静态（static）属性

ReflectionClass::getStaticPropertyValue — 获取静态（static）属性的值

ReflectionClass::getTraitAliases — 返回 trait 别名的一个数组

ReflectionClass::getTraitNames — 返回这个类所使用 traits 的名称的数组

ReflectionClass::getTraits — 返回这个类所使用的 traits 数组

ReflectionClass::hasConstant — 检查常量是否已经定义

ReflectionClass::hasMethod — 检查方法是否已定义

ReflectionClass::hasProperty — 检查属性是否已定义

ReflectionClass::implementsInterface — 接口的实现

ReflectionClass::inNamespace — 检查是否位于命名空间中

ReflectionClass::isAbstract — 检查类是否是抽象类（abstract）

ReflectionClass::isAnonymous — 检查类是否是匿名类

ReflectionClass::isCloneable — 返回了一个类是否可复制

ReflectionClass::isFinal — 检查类是否声明为 final

ReflectionClass::isInstance — 检查类的实例

ReflectionClass::isInstantiable — 检查类是否可实例化

ReflectionClass::isInterface — 检查类是否是一个接口（interface）

ReflectionClass::isInternal — 检查类是否由扩展或核心在内部定义

ReflectionClass::isIterateable — 检查是否可迭代（iterateable）

ReflectionClass::isSubclassOf — 检查是否为一个子类

ReflectionClass::isTrait — 返回了是否为一个 trait

ReflectionClass::isUserDefined — 检查是否由用户定义的

ReflectionClass::newInstance — 从指定的参数创建一个新的类实例

ReflectionClass::newInstanceArgs — 从给出的参数创建一个新的类实例。

ReflectionClass::newInstanceWithoutConstructor — 创建一个新的类实例而不调用它的构造函数

ReflectionClass::setStaticPropertyValue — 设置静态属性的值

ReflectionClass::__toString — 返回 ReflectionClass 对象字符串的表示形式。

使用 Reflection::export() 获取类信息

$prodClass = new ReflectionClass('Student');

Reflection::export($prodClass);

打印结果

  1. Class [ class Student ] { 
  2.  
  3.     @@ D:\wamp\www\test2.php 3-29 
  4.  
  5.     - Constants [0] { } 
  6.  
  7.     - Static properties [0] { } 
  8.  
  9.     - Static methods [0] { } 
  10.  
  11.     - Properties [3] { 
  12.  
  13.         Property [ public $name ] 
  14.  
  15.         Property [ protected $age ] 
  16.  
  17.         Property [ private $sex ] 
  18.  
  19.     } 
  20.  
  21.     - Methods [4] { 
  22.  
  23.         Method [ public method __construct ] { 
  24.  
  25.             @@ D:\wamp\www\test2.php 8 - 13 
  26.  
  27.             - Parameters [3] { 
  28.  
  29.                 Parameter #0 [ $name ] 
  30.  
  31.                 Parameter #1 [ $age ] 
  32.  
  33.                 Parameter #2 [ $sex ] 
  34.  
  35.             } 
  36.  
  37.         } 
  38.  
  39.         Method [ public method setName ] { 
  40.  
  41.             @@ D:\wamp\www\test2.php 15 - 18 
  42.  
  43.             - Parameters [1] { 
  44.  
  45.                 Parameter #0 [ $name ] 
  46.  
  47.             } 
  48.  
  49.         } 
  50.  
  51.         Method [ protected method setAge ] { 
  52.  
  53.             @@ D:\wamp\www\test2.php 20 - 23 
  54.  
  55.             - Parameters [1] { 
  56.  
  57.                 Parameter #0 [ $age ] 
  58.  
  59.             } 
  60.  
  61.         } 
  62.  
  63.         Method [ private method setSex ] { 
  64.  
  65.             @@ D:\wamp\www\test2.php 25 - 28 
  66.  
  67.             - Parameters [1] { 
  68.  
  69.                 Parameter #0 [ $sex ] 
  70.  
  71.             } 
  72.  
  73.         } 
  74.  
  75.     } 
  76.  
  77. } 

创建 ReflectionClass对象后，就可以使用 Reflection 工具类输出 Student 类的相关信息。Reflection::export() 可以格式化和输出任何实现 Reflector 接口的类的实例。

检查类

前面我们了解的 ReflectionClass 工具类，知道此类提供了很多的工具方法用于获取类的信息。例如，我们可以获取到 Student 类的类型，是否可以实例化

工具函数

  1. function classData(ReflectionClass $class) { 
  2.  
  3.     $details = ''; 
  4.  
  5.     $name = $class->getName();          // 返回要检查的类名 
  6.  
  7.     if ($class->isUserDefined()) {      // 检查类是否由用户定义 
  8.  
  9.         $details .= "$name is user defined" . PHP_EOL; 
  10.  
  11.     } 
  12.  
  13.     if ($class->isInternal()) {         // 检查类是否由扩展或核心在内部定义 
  14.  
  15.         $details .= "$name is built-in" . PHP_EOL; 
  16.  
  17.     } 
  18.  
  19.     if ($class->isInterface()) {        // 检查类是否是一个接口 
  20.  
  21.         $details .= "$name is interface" . PHP_EOL; 
  22.  
  23.     } 
  24.  
  25.     if ($class->isAbstract()) {         // 检查类是否是抽象类 
  26.  
  27.         $details .= "$name is an abstract class" . PHP_EOL; 
  28.  
  29.     } 
  30.  
  31.     if ($class->isFinal()) {            // 检查类是否声明为 final 
  32.  
  33.         $details .= "$name is a final class" . PHP_EOL; 
  34.  
  35.     } 
  36.  
  37.     if ($class->isInstantiable()) {     // 检查类是否可实例化 
  38.  
  39.         $details .= "$name can be instantiated" . PHP_EOL; 
  40.  
  41.     } else { 
  42.  
  43.         $details .= "$name can not be instantiated" . PHP_EOL; 
  44.  
  45.     } 
  46.  
  47.     return $details; 
  48.  
  49. } 
  50.  
  51.  
  52.  
  53. $prodClass = new ReflectionClass('Student'); 
  54.  
  55. print classData($prodClass); 

打印结果

Student is user defined

Student can be instantiated

除了获取类的相关信息，还可以获取 ReflectionClass 对象提供自定义类所在的文件名及文件中类的起始和终止行等相关源代码信息。

  1. function getClassSource(ReflectionClass $class) { 
  2.  
  3.     $path  = $class->getFileName();  // 获取类文件的绝对路径 
  4.  
  5.     $lines = @file($path);           // 获得由文件中所有行组成的数组 
  6.  
  7.     $from  = $class->getStartLine(); // 提供类的起始行 
  8.  
  9.     $to    = $class->getEndLine();   // 提供类的终止行 
  10.  
  11.     $len   = $to - $from + 1; 
  12.  
  13.     return implode(array_slice($lines, $from - 1, $len)); 
  14.  
  15. } 
  16.  
  17.  
  18.  
  19. $prodClass = new ReflectionClass('Student'); 
  20.  
  21. var_dump(getClassSource($prodClass)); 

打印结果

  1. string 'class Student { 
  2.  
  3.     public    $name; 
  4.  
  5.     protected $age; 
  6.  
  7.     private   $sex;  
  8.  
  9.     public function __construct($name, $age, $sex) 
  10.  
  11.     { 
  12.  
  13.         $this->setName($name); 
  14.  
  15.         $this->setAge($age); 
  16.  
  17.         $this->setSex($sex); 
  18.  
  19.     } 
  20.  
  21.     public function setName($name) 
  22.  
  23.     { 
  24.  
  25.         $this->name = $name; 
  26.  
  27.     } 
  28.  
  29.     protected function setAge($age) 
  30.  
  31.     { 
  32.  
  33.         $this->age = $age; 
  34.  
  35.     } 
  36.  
  37.     private function setSex($sex) 
  38.  
  39.     { 
  40.  
  41.         $this->sex = $sex; 
  42.  
  43.     } 
  44.  
  45. } 
  46.  
  47. ' (length=486) 

我们看到 getClassSource 接受一个 ReflectionClass 对象作为它的参数，并返回相应类的源代码。该函数忽略了错误处理，在实际中应该要检查参数和结果代码！

检查方法

类似于检查类，ReflectionMethod 对象可以用于检查类中的方法。

获得 ReflectionMethod 对象的方法有两种：

第一种是通过 ReflectionClass::getMethods() 获得 ReflectionMethod 对象的数组，这种方式的好处是不用提前知道方法名，会返回类中所有方法的 ReflectionMethod 对象。

第二种是直接使用 ReflectionMethod 类实例化对象，这种方式只能获取一个类方法对象，需要提前知道方法名。

ReflectionMethod 对象的工具方法：

ReflectionMethod::__construct — ReflectionMethod 的构造函数

ReflectionMethod::export — 输出一个回调方法

ReflectionMethod::getClosure — 返回一个动态建立的方法调用接口，译者注：可以使用这个返回值直接调用非公开方法。

ReflectionMethod::getDeclaringClass — 获取反射函数调用参数的类表达

ReflectionMethod::getModifiers — 获取方法的修饰符

ReflectionMethod::getPrototype — 返回方法原型 (如果存在)

ReflectionMethod::invoke — Invoke

ReflectionMethod::invokeArgs — 带参数执行

ReflectionMethod::isAbstract — 判断方法是否是抽象方法

ReflectionMethod::isConstructor — 判断方法是否是构造方法

ReflectionMethod::isDestructor — 判断方法是否是析构方法

ReflectionMethod::isFinal — 判断方法是否定义 final

ReflectionMethod::isPrivate — 判断方法是否是私有方法

ReflectionMethod::isProtected — 判断方法是否是保护方法 (protected)

ReflectionMethod::isPublic — 判断方法是否是公开方法

ReflectionMethod::isStatic — 判断方法是否是静态方法

ReflectionMethod::setAccessible — 设置方法是否访问

ReflectionMethod::__toString — 返回反射方法对象的字符串表达

ReflectionClass::getMethods()

我们可以通过 ReflectionClass::getMethods() 获得 ReflectionMethod 对象的数组。

$prodClass = new ReflectionClass('Student');

$methods = $prodClass->getMethods();

var_dump($methods);

打印结果

  1. array (size=4) 
  2.  
  3.   0 => & 
  4.  
  5.     object(ReflectionMethod)[2] 
  6.  
  7.       public 'name' => string '__construct' (length=11) 
  8.  
  9.       public 'class' => string 'Student' (length=7) 
  10.  
  11.   1 => & 
  12.  
  13.     object(ReflectionMethod)[3] 
  14.  
  15.       public 'name' => string 'setName' (length=7) 
  16.  
  17.       public 'class' => string 'Student' (length=7) 
  18.  
  19.   2 => & 
  20.  
  21.     object(ReflectionMethod)[4] 
  22.  
  23.       public 'name' => string 'setAge' (length=6) 
  24.  
  25.       public 'class' => string 'Student' (length=7) 
  26.  
  27.   3 => & 
  28.  
  29.     object(ReflectionMethod)[5] 
  30.  
  31.       public 'name' => string 'setSex' (length=6) 
  32.  
  33.       public 'class' => string 'Student' (length=7) 

可以看到我们获取到了 Student 的 ReflectionMethod 对象数组，每个元素是一个对象，其中有两个公共的属性，name 为方法名，class 为所属类。我们可以调用对象方法来获取方法的信息。

ReflectionMethod

直接使用 ReflectionMethod 类获取类方法有关信息

$method = new ReflectionMethod('Student', 'setName');

var_dump($method);

打印结果

  1. object(ReflectionMethod)[1] 
  2.  
  3.   public 'name' => string 'setName' (length=7) 
  4.  
  5.   public 'class' => string 'Student' (length=7) 

注意

在PHP5中，如果被检查的方法只返回对象（即使对象是通过引用赋值或传递的），那么 ReflectionMethod::retursReference() 不会返回 true。只有当被检测的方法已经被明确声明返回引用（在方法名前面有&符号）时，ReflectionMethod::returnsReference() 才返回 true。

检查方法参数

在PHP5中，声明类方法时可以限制参数中对象的类型，因此检查方法的参数变得非常必要。

类似于检查方法，ReflectionParameter 对象可以用于检查类中的方法，该对象可以告诉你参数的名称，变量是否可以按引用传递，还可以告诉你参数类型提示和方法是否接受空值作为参数。

获得 ReflectionParameter 对象的方法有同样两种，这和获取 ReflectionMethod 对象非常类似：

第一种是通过 ReflectionMethod::getParameters() 方法返回 ReflectionParameter 对象数组，这种方法可以获取到一个方法的全部参数对象。

第二种是直接使用 ReflectionParameter 类实例化获取对象，这种方法只能获取到单一参数的对象。

ReflectionParameter 对象的工具方法：

  1. ReflectionParameter::allowsNull — Checks if null is allowed 
  2.  
  3. ReflectionParameter::canBePassedByValue — Returns whether this parameter can be passed by value 
  4.  
  5. ReflectionParameter::__clone — Clone 
  6.  
  7. ReflectionParameter::__construct — Construct 
  8.  
  9. ReflectionParameter::export — Exports 
  10.  
  11. ReflectionParameter::getClass — Get the type hinted class 
  12.  
  13. ReflectionParameter::getDeclaringClass — Gets declaring class 
  14.  
  15. ReflectionParameter::getDeclaringFunction — Gets declaring function 
  16.  
  17. ReflectionParameter::getDefaultValue — Gets default parameter value 
  18.  
  19. ReflectionParameter::getDefaultValueConstantName — Returns the default value's constant name if default value is constant or null 
  20.  
  21. ReflectionParameter::getName — Gets parameter name 
  22.  
  23. ReflectionParameter::getPosition — Gets parameter position 
  24.  
  25. ReflectionParameter::getType — Gets a parameter's type 
  26.  
  27. ReflectionParameter::hasType — Checks if parameter has a type 
  28.  
  29. ReflectionParameter::isArray — Checks if parameter expects an array 
  30.  
  31. ReflectionParameter::isCallable — Returns whether parameter MUST be callable 
  32.  
  33. ReflectionParameter::isDefaultValueAvailable — Checks if a default value is available 
  34.  
  35. ReflectionParameter::isDefaultValueConstant — Returns whether the default value of this parameter is constant 
  36.  
  37. ReflectionParameter::isOptional — Checks if optional 
  38.  
  39. ReflectionParameter::isPassedByReference — Checks if passed by reference 
  40.  
  41. ReflectionParameter::isVariadic — Checks if the parameter is variadic 
  42.  
  43. ReflectionParameter::__toString — To string 
  44.  
  45. ReflectionMethod::getParameters() 

同获取方法，此方法会返回一个数组，包含方法每个参数的 ReflectionParameter 对象

$method = new ReflectionMethod('Student', 'setName');

$params = $method->getParameters();

var_dump($params);

打印结果

  1. array (size=1) 
  2.  
  3.   0 => & 
  4.  
  5.     object(ReflectionParameter)[2] 
  6.  
  7.       public 'name' => string 'name' (length=4) 
  8.  
  9. ReflectionParameter 

我们来了解一下这种方式，为了更好的理解，我修改一下 Student 类的 setName方法，增加两个参数 a, b

  1. ... 
  2.  
  3.     public function setName($name, $a, $b) 
  4.  
  5.     { 
  6.  
  7.         $this->name = $name; 
  8.  
  9.     } 
  10.  
  11. ... 

首先我们看一下 ReflectionParameter 类的构造方法

public ReflectionParameter::__construct ( string $function , string $parameter )

可以看到该类实例化时接收两个参数：

$function：当需要获取函数为公共函数时只需传函数名称即可。当该函数是某个类方法时，需要传递一个数组，格式为：array('class', 'function')。

$parameter：这个参数可以传递两种，第一种为参数名（无$符号），第二种为参数索引。注意：无论是参数名还是索引，该参数都必须存在，否则会报错。

下面举例：

$params = new ReflectionParameter(array('Student', 'setName'), 1);

var_dump($params);

打印结果

object(ReflectionParameter)[1]

public 'name' => string 'a' (length=1)

我们再定义一个函数测试一下

  1. function foo($a, $b, $c) { } 
  2.  
  3. $reflect = new ReflectionParameter('foo', 'c'); 
  4.  
  5. var_dump($reflect); 

打印结果

object(ReflectionParameter)[2]

public 'name' => string 'c' (length=1)

结语

php的反射API功能非常的强大，它可以将一个类的详细信息获取出来。我们可以通过反射API编写个类来动态调用Module对象，该类可以自由加载第三方插件并集成进已有的系统。而不需要把第三方的代码硬编码进原有的代码中。虽然实际开发中使用反射情况比较少，但了解反射API对工作中对代码结构的了解和开发业务模式帮助还是非常大的。此篇博文断断续续的写了很久（主要就是懒！），如有错误与不足欢迎指正，建议！！

Tags: PHP反射API

分享到：

推荐文章

热门文章

最新评论文章