Detailed explanation of the principles and usage of reflection mechanism in PHP with pictures and texts

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

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

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

<?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 to do to get the method and property list of this student object Woolen cloth? 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 instead of the 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, how do you know which class it belongs to? You can get it done with just one line of code:

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

The reflection API is obviously more powerful and can even restore the prototype of this class, including method access permissions, 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, the PHP manual about reflection API There are dozens more. 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 objects, and the other is Get 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 entire content of this article, I hope it will be helpful to everyone's study.

Related recommendations:

php object-orientedReflectionFunction and usage

PHPReflectionDetailed explanation of mechanism examples

PHP classReflectionDetailed explanation of the steps to implement dependency injection

The above is the detailed content of Detailed explanation of the principles and usage of reflection mechanism in PHP with pictures and texts. For more information, please follow other related articles on the PHP Chinese website!