What is the principle of php reflection mechanism? Detailed explanation of the function of reflection mechanism

This article mainly introduces the principle and usage of PHP reflection mechanism, and analyzes the principle, usage and related aspects of PHP reflection mechanism in the form of examples. Notes, friends in need can refer to it

The examples in this article describe the principles and usage of PHP reflection mechanism. Share it with everyone for your reference, as follows:

Reflection

Object-orientedIn programming, objects are given the ability to introspect, and this introspection The process is reflection.

Reflection, intuitive understanding is to find the departure place and source based on the arrival place. For example, with a bare object, we can know the class it belongs to and what methods it has just through this object.

Reflection refers to extending the analysis of PHP programs in the running state of PHP, exporting or proposing detailed information about classes, methods, properties, parameters, etc., including Comments. This function of dynamically obtaining information and dynamically calling object methods is called reflection API.

How to use reflection API

<?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;

Now, what should we do to get the method and property list of this student object? As shown in the following code:

// 获取对象属性列表
$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";
}

You can also use the class function without reflection API to return an associative array of object properties and more information:

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

If this object is passed from other pages Come here, how do you know which category it belongs to? You can get it done with just one line of code:

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

The function of reflection API is obviously more powerful, and it can even restore the prototype of this class, including the access permissions of methods, etc., such as:

// 反射获取类的原型
$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";

The output is as follows:

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

Not only that, there are dozens of reflection APIs in the PHP Manual. It can be said that reflection completely describes the prototype of a class or object. Reflection can be used not only for classes and objects, but also for functions, extension modules, exceptions, etc.

What is the role of reflection

Reflection can be used for document generation. Therefore, you can use it to scan the classes in the file and generate description documents one by one.

Since reflection can detect the internal structure of a class, can it be used as a hook to implement plug-in functions? Or is it a dynamic proxy?

For example:

<?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;);

In normal development, there are not many places where reflection is used: one is to debug the object, and the other is to obtain class information. In MVC and plug-in development, the use of reflection is very common, but reflection is also very expensive. Don't abuse it if you can find an alternative.

PHP has the Token function, which can implement some reflection functions through this mechanism. From the perspective of simplicity and flexibility, it is advisable to use the reflection API that has been provided.

Many times, making good use of reflection can keep the code elegant and concise, but reflection can also destroy the encapsulation of the class, because reflection can force methods or properties that should not be exposed to be exposed. This is both The advantages are also the disadvantages.

The above is the detailed content of What is the principle of php reflection mechanism? Detailed explanation of the function of reflection mechanism. For more information, please follow other related articles on the PHP Chinese website!