Introduction to PHP's Reflection reflection mechanism

This article mainly introduces the reflection mechanism of PHP. It has certain reference value. Now I share it with you. Friends in need can refer to it

PHP5 adds a new feature: Reflection. This feature allows programmers to

reverse-engineer[reverse engineering] class, interface, function, method and extension[extension library support].

Through PHP code, you can get all the information of an object and interact with it.

Assume the following Person class:

 1 class Person { 
 2     /** 
 3      * For the sake of demonstration, we"re setting this private 
 4      */ 
 5     private $_allowDynamicAttributes = false; 
 6      
 7     /** 
 8      * type=primary_autoincrement 
 9      */
 10     protected $id = 0;
 11     
 12     /**
 13      * type=varchar length=255 null
 14      */
 15     protected $name;
 16     
 17     /**
 18      * type=text null19      */
 20     protected $biography;
 21     public function getId() {
 22         return $this->id;
 23     }
 24     public function setId($v) {
 25         $this->id = $v;
 26     }
 27     public function getName() {
 28         return $this->name;
 29     }
 30     public function setName($v) {
 31         $this->name = $v;
 32     }
 33     public function getBiography() {
 34         return $this->biography;
 35     }
 36     public function setBiography($v) {
 37         $this->biography = $v;
 38     }
 39 }

Through ReflectionClass, we can get the following information of the Person class:

• ConstantContants

• Property Property Names

• Method Names

• Static PropertiesStatic Properties

• NamespaceNamespace

• Whether the Person class is final or abstract

Just pass the class name "Person" to ReflectionClass :

1 $class = new ReflectionClass('Person');

* Get properties (Properties):

1 $properties = $class->getProperties();2 foreach($properties as $property) {
3     echo $property->getName()."\n";4 }
5 // 输出:6 // _allowDynamicAttributes7 // id8 // name9 // biography

By default, ReflectionClass will get all properties, including private and protected ones. If you only want to get the private attribute, you need to pass an additional parameter:

1 $private_properties = $class->getProperties(ReflectionProperty::IS_PRIVATE);

Available parameter list:

• ##ReflectionProperty::IS_STATIC

• ReflectionProperty::IS_PUBLIC

• ReflectionProperty::IS_PROTECTED

• ReflectionProperty::IS_PRIVATE

If you want to get both public and private properties at the same time, just write like this: ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED

You can get the property name through $property->getName(), and you can get the write address through getDocComment. Property comments.

 1 foreach($properties as $property) {
 2     if($property->isProtected()) { 
 3         $docblock = $property->getDocComment(); 
 4         preg_match('/ type\=([a-z_]*) /', $property->getDocComment(), $matches); 
 5         echo $matches[1]."\n"; 
 6     } 
 7 } 
 8 // Output: 
 9 // primary_autoincrement
 10 // varchar
 11 // text

It’s a bit incredible. You can even get comments.

* Get methods: Get all methods of the class through getMethods(). What is returned is an array of ReflectionMethod objects.

No more demonstration.

* Finally, call the method in the class through ReflectionMethod.

$data = array("id" => 1, "name" => "Chris", "biography" => "I am am a PHP developer");
foreach($data as $key => $value) {    
if(!$class->hasProperty($key)) {        
throw new Exception($key." is not a valid property");
    } 
    if(!$class->hasMethod("get".ucfirst($key))) {        
    throw new Exception($key." is missing a getter");
    } 
    if(!$class->hasMethod("set".ucfirst($key))) {        
    throw new Exception($key." is missing a setter");
    } 
    // Make a new object to interact with
    $object = new Person(); 
    // Get the getter method and invoke it with the value in our data array
    $setter = $class->getMethod("set".ucfirst($key));    
    $ok = $setter->invoke($object, $value); 
    // Get the setter method and invoke it
    $setter = $class->getMethod("get".ucfirst($key));    
    $objValue = $setter->invoke($object); 
    // Now compare
    if($value == $objValue) {        
    echo "Getter or Setter has modified the data.\n";
    } else {        
    echo "Getter and Setter does not modify the data.\n";
   }
}

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

php method of crawling web content and images

PHP import progress bar class

PHP scope

The above is the detailed content of Introduction to PHP's Reflection reflection mechanism. For more information, please follow other related articles on the PHP Chinese website!