Detailed explanation of usage of php reflection mechanism

Reflection

In object-oriented programming, objects are given the ability to introspect, and this introspection 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?

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 '未设置';
     　　
     $this->$name="正在为你设置默认值";
  }
  return $this->$name;
  }
}
$student=new person();
$student->name='Tom';
$student->gender='male';
$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 Coming 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 does reflection do?

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:

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('mysql');
$obj->connect('member');

In normal development, there are not many places where reflection is used: one is to debug objects, 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.

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.

If you want to know more related content, please visit the PHP Chinese website: PHP Video Tutorial

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