L'API de réflexion en PHP est comme le package java.lang.reflect en Java. Il se compose d'un ensemble de classes intégrées capables d'analyser des propriétés, des méthodes et des classes. Elle est similaire à certains égards aux fonctions d'objet, telles que get_class_vars(), mais elle est plus flexible et peut fournir plus d'informations.
L'API de réflexion fonctionne également avec les dernières fonctionnalités orientées objet de PHP, telles que le contrôle d'accès, les interfaces et les classes abstraites. Les fonctions des classes plus anciennes sont moins faciles à utiliser avec ces nouvelles fonctionnalités. Les amis qui ont lu le code source du framework doivent avoir une certaine compréhension des mécanismes de réflexion de PHP, tels que l'injection de dépendances, le pooling d'objets, le chargement de classes, certains modèles de conception, etc., qui utilisent tous des mécanismes de réflexion.
Certaines classes de l'API de réflexion
En utilisant ces classes de l'API de réflexion, vous pouvez obtenir un accès d'exécution aux objets, fonctions et extensions dans informations sur les scripts. Ces informations peuvent être utilisées pour analyser des classes ou créer des frameworks.
|
Description | ||||||||||||||||||
| Réflexion | Fournit des informations récapitulatives sur la classe Statique function export() | ||||||||||||||||||
| ReflectionClass | Informations et outils sur la classe | ||||||||||||||||||
| ReflectionMethod | Informations et outils sur la méthode de classe|||||||||||||||||||
| ReflectionParameter | Informations sur les paramètres de méthode | ||||||||||||||||||
| ReflectionProperty td > | Informations sur les attributs de classe | ||||||||||||||||||
| ReflectionFunction | Informations et outils sur les fonctions | ||||||||||||||||||
| ReflectionExtension | |||||||||||||||||||
| ReflectionExtension | td>Informations sur l'extension PHP | ||||||||||||||||||
| ReflectionException | Classe d'erreur |
Obtenir des informations sur la classe
Nous avons utilisé certaines fonctions pour vérifier les attributs de classe dans notre travail, telles que : get_class_methods, getProduct, etc. Ces méthodes présentent des limites importantes pour obtenir des informations détaillées sur les classes.
Nous pouvons obtenir des informations pertinentes sur la classe grâce à l'exportation de méthodes statiques fournie par la classe API de réflexion : l'exportation Reflection et ReflectionClass peut fournir presque toutes les informations sur la classe, y compris l'état de contrôle d'accès des attributs et des méthodes, et chaque méthode. Les paramètres requis et l'emplacement de chaque méthode dans le document de script. Pour ces deux classes d'outils, les résultats de sortie de la méthode statique d'exportation sont les mêmes, mais les méthodes d'utilisation sont différentes.
Tout d'abord, créez une classe simple
<?php
class Student {
public $name;
protected $age;
private $sex;
public function __construct($name, $age, $sex)
{
$this->setName($name);
$this->setAge($age);
$this->setSex($sex);
}
public function setName($name)
{
$this->name = $name;
}
protected function setAge($age)
{
$this->age = $age;
}
private function setSex($sex)
{
$this->sex = $sex;
}
}Utilisez ReflectionClass::export() pour obtenir des informations sur la classe
ReflectionClass::export('Student');
Imprimer les résultats :
Class [ class Student ] {
@@ D:\wamp\www\test2.php 3-29
- Constants [0] { }
- Static properties [0] { }
- Static methods [0] { }
- Properties [3] {
Property [ public $name ]
Property [ protected $age ]
Property [ private $sex ]
}
- Methods [4] {
Method [ public method __construct ] {
@@ D:\wamp\www\test2.php 8 - 13
- Parameters [3] {
Parameter #0 [ $name ]
Parameter #1 [ $age ]
Parameter #2 [ $sex ]
}
}
Method [ public method setName ] {
@@ D:\wamp\www\test2.php 15 - 18
- Parameters [1] {
Parameter #0 [ $name ]
}
}
Method [ protected method setAge ] {
@@ D:\wamp\www\test2.php 20 - 23
- Parameters [1] {
Parameter #0 [ $age ]
}
}
Method [ private method setSex ] {
@@ D:\wamp\www\test2.php 25 - 28
- Parameters [1] {
Parameter #0 [ $sex ]
}
}
}
}La classe ReflectionClass fournit de nombreuses méthodes d'outils. Le manuel officiel donne la liste suivante :
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 对象字符串的表示形式。
Utiliser Reflection::export(). pour obtenir des informations sur la classe
$prodClass = new ReflectionClass('Student'); Reflection::export($prodClass);
Imprimer les résultats
Class [ class Student ] {
@@ D:\wamp\www\test2.php 3-29
- Constants [0] { }
- Static properties [0] { }
- Static methods [0] { }
- Properties [3] {
Property [ public $name ]
Property [ protected $age ]
Property [ private $sex ]
}
- Methods [4] {
Method [ public method __construct ] {
@@ D:\wamp\www\test2.php 8 - 13
- Parameters [3] {
Parameter #0 [ $name ]
Parameter #1 [ $age ]
Parameter #2 [ $sex ]
}
}
Method [ public method setName ] {
@@ D:\wamp\www\test2.php 15 - 18
- Parameters [1] {
Parameter #0 [ $name ]
}
}
Method [ protected method setAge ] {
@@ D:\wamp\www\test2.php 20 - 23
- Parameters [1] {
Parameter #0 [ $age ]
}
}
Method [ private method setSex ] {
@@ D:\wamp\www\test2.php 25 - 28
- Parameters [1] {
Parameter #0 [ $sex ]
}
}
}
}Après avoir créé l'objet ReflectionClass, vous pouvez utiliser la classe d'outils Reflection pour générer des informations pertinentes sur la classe Student. Reflection::export() peut formater et exporter des instances de n'importe quelle classe qui implémente l'interface Reflector.
Vérifier la classe
Nous avons entendu parler de la classe d'outils ReflectionClass plus tôt, et nous savons que cette classe fournit de nombreuses méthodes d'outils pour obtenir la classe information. Par exemple, nous pouvons obtenir le type de classe Étudiant et si elle peut être instanciée
Fonction outil
function classData(ReflectionClass $class) {
$details = '';
$name = $class->getName(); // 返回要检查的类名
if ($class->isUserDefined()) { // 检查类是否由用户定义
$details .= "$name is user defined" . PHP_EOL;
}
if ($class->isInternal()) { // 检查类是否由扩展或核心在内部定义
$details .= "$name is built-in" . PHP_EOL;
}
if ($class->isInterface()) { // 检查类是否是一个接口
$details .= "$name is interface" . PHP_EOL;
}
if ($class->isAbstract()) { // 检查类是否是抽象类
$details .= "$name is an abstract class" . PHP_EOL;
}
if ($class->isFinal()) { // 检查类是否声明为 final
$details .= "$name is a final class" . PHP_EOL;
}
if ($class->isInstantiable()) { // 检查类是否可实例化
$details .= "$name can be instantiated" . PHP_EOL;
} else {
$details .= "$name can not be instantiated" . PHP_EOL;
}
return $details;
}
$prodClass = new ReflectionClass('Student');
print classData($prodClass);Imprimer les résultats
Student is user defined Student can be instantiated
En plus d'obtenir les informations pertinentes du classe, vous pouvez également obtenir le ReflectionClass. L'objet fournit des informations pertinentes sur le code source telles que le nom du fichier où se trouve la classe personnalisée et les lignes de début et de fin de la classe dans le fichier.
function getClassSource(ReflectionClass $class) {
$path = $class->getFileName(); // 获取类文件的绝对路径
$lines = @file($path); // 获得由文件中所有行组成的数组
$from = $class->getStartLine(); // 提供类的起始行
$to = $class->getEndLine(); // 提供类的终止行
$len = $to - $from + 1;
return implode(array_slice($lines, $from - 1, $len));
}
$prodClass = new ReflectionClass('Student');
var_dump(getClassSource($prodClass));Imprimer les résultats
string 'class Student {
public $name;
protected $age;
private $sex;
public function __construct($name, $age, $sex)
{
$this->setName($name);
$this->setAge($age);
$this->setSex($sex);
}
public function setName($name)
{
$this->name = $name;
}
protected function setAge($age)
{
$this->age = $age;
}
private function setSex($sex)
{
$this->sex = $sex;
}
}
' (length=486)On voit que getClassSource accepte un objet ReflectionClass comme paramètre et renvoie le code source de la classe correspondante. Cette fonction ignore la gestion des erreurs, en pratique vous devez vérifier les paramètres et le code résultat !
Vérification des méthodes
Semblable à la vérification des classes, les objets ReflectionMethod peuvent être utilisés pour vérifier les méthodes dans une classe.
Il existe deux manières d'obtenir des objets ReflectionMethod :
La première est d'obtenir un tableau d'objets ReflectionMethod via ReflectionClass::getMethods(). besoin de connaître le nom de la méthode à l'avance. Renvoie les objets ReflectionMethod pour toutes les méthodes de la classe.
La deuxième méthode consiste à utiliser directement la classe ReflectionMethod pour instancier l'objet. Cette méthode ne peut obtenir qu'un seul objet de méthode de classe, et vous devez connaître le nom de la méthode à l'avance.
Méthodes utilitaires des objets ReflectionMethod :
ReflectionMethod::__construct — Constructeur de ReflectionMethod
ReflectionMethod::__toString — Renvoie l'expression de chaîne de l'objet de la méthode de réflexion
ReflectionMethod::export — Exporte une méthode de rappel
ReflectionMethod::getClosure — Renvoie une interface d'appel de méthode créée dynamiquement. Remarque du traducteur : vous pouvez utiliser cette valeur de retour pour appeler directement des méthodes non publiques.
ReflectionMethod::getDeclaringClass — Récupère la représentation de classe des paramètres d'appel de la fonction de réflexion
ReflectionMethod::getModifiers — Récupère les modificateurs de la méthode
ReflectionMethod::getPrototype — Renvoie le prototype de la méthode (si présent)
ReflectionMethod::invoke — Invoke
ReflectionMethod::invokeArgs — Exécuter avec des paramètres
ReflectionMethod::isAbstract — Déterminer si la méthode est une méthode abstraite
ReflectionMethod::isConstructor — Déterminer si la méthode est un constructeur
ReflectionMethod::isConstructor — Déterminer si la méthode est un constructeur
ReflectionMethod::isDestructor — Détermine si la méthode est une méthode destructrice
ReflectionMethod::isFinal — Détermine si la méthode est définie comme finale
ReflectionMethod::isPrivate — Détermine si la méthode est une méthode privée
ReflectionMethod ::isProtected — Détermine si la méthode est une méthode protégée (protected )
ReflectionMethod::isPublic — Détermine si la méthode est une méthode publique
ReflectionMethod::isStatic — Détermine si la méthode est une méthode statique
ReflectionMethod::setAccessible — Définit si la méthode est accessible
ReflectionClass::getMethods()
Nous pouvons l'obtenir via le tableau ReflectionClass::getMethods() d'objets ReflectionMethod.$prodClass = new ReflectionClass('Student'); $methods = $prodClass->getMethods(); var_dump($methods);
array (size=4)
0 => &
object(ReflectionMethod)[2]
public 'name' => string '__construct' (length=11)
public 'class' => string 'Student' (length=7)
1 => &
object(ReflectionMethod)[3]
public 'name' => string 'setName' (length=7)
public 'class' => string 'Student' (length=7)
2 => &
object(ReflectionMethod)[4]
public 'name' => string 'setAge' (length=6)
public 'class' => string 'Student' (length=7)
3 => &
object(ReflectionMethod)[5]
public 'name' => string 'setSex' (length=6)
public 'class' => string 'Student' (length=7)ReflectionMethod
Utilisez directement la classe ReflectionMethod pour obtenir des informations sur les méthodes de classe$method = new ReflectionMethod('Student', 'setName'); var_dump($method);
object(ReflectionMethod)[1] public 'name' => string 'setName' (length=7) public 'class' => string 'Student' (length=7)
在PHP5中，如果被检查的方法只返回对象（即使对象是通过引用赋值或传递的），那么 ReflectionMethod::retursReference() 不会返回 true。只有当被检测的方法已经被明确声明返回引用（在方法名前面有&符号）时，ReflectionMethod::returnsReference() 才返回 true。
检查方法参数
在PHP5中，声明类方法时可以限制参数中对象的类型，因此检查方法的参数变得非常必要。
类似于检查方法，ReflectionParameter 对象可以用于检查类中的方法，该对象可以告诉你参数的名称，变量是否可以按引用传递，还可以告诉你参数类型提示和方法是否接受空值作为参数。
获得 ReflectionParameter 对象的方法有同样两种，这和获取 ReflectionMethod 对象非常类似：
第一种是通过 ReflectionMethod::getParameters() 方法返回 ReflectionParameter 对象数组，这种方法可以获取到一个方法的全部参数对象。
第二种是直接使用 ReflectionParameter 类实例化获取对象，这种方法只能获取到单一参数的对象。
ReflectionParameter 对象的工具方法：
ReflectionParameter::allowsNull — Checks if null is allowed ReflectionParameter::canBePassedByValue — Returns whether this parameter can be passed by value ReflectionParameter::__clone — Clone ReflectionParameter::__construct — Construct ReflectionParameter::export — Exports ReflectionParameter::getClass — Get the type hinted class ReflectionParameter::getDeclaringClass — Gets declaring class ReflectionParameter::getDeclaringFunction — Gets declaring function ReflectionParameter::getDefaultValue — Gets default parameter value ReflectionParameter::getDefaultValueConstantName — Returns the default value's constant name if default value is constant or null ReflectionParameter::getName — Gets parameter name ReflectionParameter::getPosition — Gets parameter position ReflectionParameter::getType — Gets a parameter's type ReflectionParameter::hasType — Checks if parameter has a type ReflectionParameter::isArray — Checks if parameter expects an array ReflectionParameter::isCallable — Returns whether parameter MUST be callable ReflectionParameter::isDefaultValueAvailable — Checks if a default value is available ReflectionParameter::isDefaultValueConstant — Returns whether the default value of this parameter is constant ReflectionParameter::isOptional — Checks if optional ReflectionParameter::isPassedByReference — Checks if passed by reference ReflectionParameter::isVariadic — Checks if the parameter is variadic ReflectionParameter::__toString — To string
ReflectionMethod::getParameters()
同获取方法，此方法会返回一个数组，包含方法每个参数的 ReflectionParameter 对象
$method = new ReflectionMethod('Student', 'setName'); $params = $method->getParameters(); var_dump($params);
打印结果
array (size=1)
0 => &
object(ReflectionParameter)[2]
public 'name' => string 'name' (length=4)ReflectionParameter
我们来了解一下这种方式，为了更好的理解，我修改一下 Student 类的 setName方法，增加两个参数 a, b
...
public function setName($name, $a, $b)
{
$this->name = $name;
}
...首先我们看一下 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)
我们再定义一个函数测试一下
function foo($a, $b, $c) { }
$reflect = new ReflectionParameter('foo', 'c');
var_dump($reflect);打印结果
object(ReflectionParameter)[2] public 'name' => string 'c' (length=1)
结语
php的反射API功能非常的强大，它可以将一个类的详细信息获取出来。我们可以通过反射API编写个类来动态调用Module对象，该类可以自由加载第三方插件并集成进已有的系统。而不需要把第三方的代码硬编码进原有的代码中。虽然实际开发中使用反射情况比较少，但了解反射API对工作中对代码结构的了解和开发业务模式帮助还是非常大的。此篇博文断断续续的写了很久（主要就是懒！），如有错误与不足欢迎指正，建议！！
相关教程推荐：《PHP教程》
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment ouvrir le fichier php
Comment supprimer les premiers éléments d'un tableau en php
Que faire si la désérialisation php échoue
Comment connecter PHP à la base de données mssql
Comment connecter PHP à la base de données mssql
Comment télécharger du HTML
Comment résoudre les caractères tronqués en PHP
Comment ouvrir des fichiers php sur un téléphone mobile
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
