Explication détaillée de l'utilisation du mécanisme de réflexion PHP

Réflexion

Dans la programmation orientée objet, les objets ont la capacité de s'introspecter, et ce processus d'introspection est la réflexion.

La réflexion, la compréhension intuitive consiste à trouver le lieu de départ et la source en fonction du lieu d'arrivée. Par exemple, avec un objet nu, nous pouvons connaître la classe à laquelle il appartient et de quelles méthodes il dispose grâce à cet objet.

La réflexion fait référence à l'extension de l'analyse des programmes PHP dans l'état d'exécution de PHP, à l'exportation ou à la proposition d'informations détaillées sur les classes, méthodes, propriétés, paramètres, etc., y compris des commentaires. Cette fonction d'obtention dynamique d'informations et d'appel dynamique de méthodes objet est appelée API de réflexion.

Comment utiliser l'API de réflexion ?

<?php
class person{
public $name;
public $gender;
public function say(){
  echo $this->name," \tis ",$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 &#39;未设置&#39;;
     　　
     $this->$name="正在为你设置默认值";
  }
  return $this->$name;
  }
}
$student=new person();
$student->name=&#39;Tom&#39;;
$student->gender=&#39;male&#39;;
$student->age=24;

Maintenant, que devons-nous faire pour obtenir la méthode et la liste des propriétés de cet objet étudiant ? Comme indiqué dans le code suivant :

// 获取对象属性列表
$reflect = new ReflectionObject($student);
$props　= $reflect->getProperties();
foreach ($props as $prop) {
  print $prop->getName() ."\n";
}
// 获取对象方法列表
$m=$reflect->getMethods();
foreach ($m as $prop) {
  print $prop->getName() ."\n";
}

Vous pouvez également utiliser la fonction de classe sans API de réflexion pour renvoyer un tableau associatif de propriétés d'objet et plus d'informations :

// 返回对象属性的关联数组
var_dump(get_object_vars($student));
// 类属性
var_dump(get_class_vars(get_class($student)));
// 返回由类的方法名组成的数组
var_dump(get_class_methods(get_class($student)));

Si cet objet est transmis depuis d'autres pages En venant ici, comment savoir à quelle catégorie il appartient ? Vous pouvez le faire avec une seule ligne de code :

// 获取对象属性列表所属的类
echo get_class($student);

La fonction de l'API de réflexion est évidemment plus puissante, et elle peut même restaurer le prototype de cette classe, y compris les autorisations d'accès aux méthodes, etc., tels que :

// 反射获取类的原型
$obj = new ReflectionClass('person');
$className = $obj->getName();
$Methods = $Properties = array();
foreach($obj->getProperties() as $v)
{
　　　　$Properties［$v->getName()］ = $v;
}
foreach($obj->getMethods() as $v)
 　　
 {
　　　　$Methods［$v->getName()］ = $v;
}
echo "class {$className}\n{\n";
is_array($Properties)&&ksort($Properties);
foreach($Properties as $k => $v)
{
　　　　echo "\t";
　　　　echo $v->isPublic() ? ' public' : '',$v->isPrivate() ? ' private' : '',
　　　　$v->isProtected() ? ' protected' : '',
　　　　$v->isStatic() ? ' static' : '';
　　　　echo "\t{$k}\n";
}
echo "\n";
if(is_array($Methods)) ksort($Methods);
foreach($Methods as $k => $v)
{
　　　　echo "\tfunction {$k}(){}\n";
}
echo "}\n";

Le résultat est le suivant :

class person
{
  public　gender
  public　name
  function get(){}
  function set(){}
  function say(){}
}

De plus, il existe des dizaines d'API de réflexion dans le manuel PHP. On peut dire que la réflexion décrit complètement le. prototype d'une classe ou d'un objet. La réflexion peut être utilisée non seulement pour les classes et les objets, mais aussi pour les fonctions, les modules d'extension, les exceptions, etc.

A quoi sert la réflexion ?

La réflexion peut être utilisée pour la génération de documents. Par conséquent, vous pouvez l'utiliser pour analyser les classes du fichier et générer des documents de description un par un.

Puisque la réflexion peut détecter la structure interne d'une classe, peut-elle être utilisée comme un hook pour implémenter des fonctions de plug-in ? Ou est-ce un proxy dynamique ?

Par exemple :

<?php
class mysql {
  function connect($db) {
    echo "连接到数据库${db［0］}\r\n";
  }
}
class sqlproxy {
  private $target;  
  function construct($tar) { 
    $this->target［］ = new $tar();
  }
  function call($name, $args) {
    foreach ($this->target as $obj) {
      $r = new ReflectionClass($obj);
      if ($method = $r->getMethod($name)) {
        if ($method->isPublic() && !$method->isAbstract()) {
          echo "方法前拦截记录LOG\r\n";
          $method->invoke($obj, $args);
          echo "方法后拦截\r\n";
        }
      }
    }
  }
}
$obj = new sqlproxy(&#39;mysql&#39;);
$obj->connect(&#39;member&#39;);

Dans le développement normal, il n'y a pas beaucoup d'endroits où la réflexion est utilisée : l'un consiste à déboguer des objets et l'autre à obtenir des informations de classe. Dans le développement de MVC et de plug-ins, l'utilisation de la réflexion est très courante, mais la réflexion est également très coûteuse. N'en abusez pas si vous pouvez trouver une alternative.

Souvent, une bonne utilisation de la réflexion peut garder le code élégant et concis, mais la réflexion peut également détruire l'encapsulation de la classe, car la réflexion peut forcer l'exposition de méthodes ou de propriétés qui ne devraient pas être exposées. les deux Les avantages sont aussi les inconvénients.

Pour plus de contenu connexe, veuillez visiter le site Web PHP chinois : Tutoriel vidéo 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!