PHP Reflection Class Reflectionclass, Reflectionmethod Use example, reflectionmethod_php tutorial

PHP's Reflection class Reflectionclass, Reflectionmethod use instance, Reflectionmethod

The PHP5 has a complete reflection API that adds the ability to reverse engineer classes, interfaces, functions, methods, and extensions.

What is reflection?

It refers to the PHP running state, extending the parsing PHP program, exporting or extracting details about classes, methods, properties, parameters, etc., including comments. This dynamic acquisition of information and the ability to dynamically invoke an object's methods is called the Reflection API. Reflection is an API that manipulates the meta-model of an object-oriented paradigm and is powerful in helping us to build complex, scalable applications.

The purpose is to automatically load plugins, automatically generate documents, and even to augment the PHP language.

The PHP reflection API consists of several classes that help us to access the program's metadata or to interact with the related annotations. With reflection we can obtain methods such as class implementations, create an instance of a class (unlike the one created with new), Invoke a method (also different from a regular call), pass a parameter, and invoke the static method of the class dynamically.
The Reflection API is a PHP built-in OOP technology extension that includes classes, exceptions, and interfaces that are used in combination to help us analyze other classes, interfaces, methods, properties, methods, and extensions. These OOP extensions are known as reflections.

Usually we use more of the Reflectionclass class and the Reflectionmethod class, for example:
Copy the Code code as follows:
<?php
Class Person {

/**
* For the sake of demonstration, we ' re setting this private
*/
Private $_allowdynamicattributes = false;

/**
* Type=primary_autoincrement
*/
protected $id = 0;

/**
* Type=varchar length=255 NULL
*/
protected $name;

/**
* Type=text NULL
*/
protected $biography;

Public Function getId () {
return $this->id;
}

Public Function SetId ($v) {
$this->id = $v;
}

Public Function GetName () {
return $this->name;
}

Public Function SetName ($v) {
$this->name = $v;
}

Public Function getbiography () {
return $this->biography;
}

Public Function setbiography ($v) {
$this->biography = $v;
}
}

First, through Reflectionclass, we can get the following information of the person class:

1. Constant contants
2. Property Names
3. Method names static
4. Property Static Properties
5. Namespace Namespace
Whether the 6.Person class is final or abstract
Does the 7.Person class have a method

Next reflect it, as long as the class name "person" is passed to Reflectionclass, you can:
Copy the Code code as follows:
$class = new Reflectionclass (' person '); Create a reflection class for the person class
$instance = $class->newinstanceargs ($args); The equivalent of instantiating the person class

1) Get Attributes (properties):

Copy the Code code as follows:
$properties = $class->getproperties ();
foreach ($properties as $property) {
echo $property->getname (). "\ n";
}
Output:
_allowdynamicattributes
Id
Name
Biography

By default, Reflectionclass will get all of the properties, private and protected can also. If you want to get only the private property, you need to pass an additional parameter:

Copy the Code code as follows:
$private _properties = $class->getproperties (reflectionproperty::is_private);

List of available parameters:

Copy the Code code as follows:
Reflectionproperty::is_static
Reflectionproperty::is_public
reflectionproperty::is_protected
Reflectionproperty::is_private

The property name can be obtained by $property->getname ().

2) Get Comments:

A note to the property can be obtained by getdoccomment.

Copy the Code code as follows:
foreach ($properties as $property) {
if ($property->isprotected ()) {
$docblock = $property->getdoccomment ();
Preg_match ('/type\= ([a-z_]*)/', $property->getdoccomment (), $matches);
echo $matches [1]. "\ n";
}
}
Output:
Primary_autoincrement
varchar
Text

3) methods to get classes

Copy the Code code as follows:
GetMethods () to get all the methods to the class.
Hasmethod (string) whether there is a method
GetMethod (String) Get method

4) Method of executing the class:
Copy the Code code as follows:
$instance->getname (); Execute the method in person GetName
Or:
$method = $class->getmethod (' getName '); Get the GetName method in the person class
$method->invoke ($instance); Execute the GetName method
Or:
$method = $class->getmethod (' setName '); Get the SetName method in the person class
$method->invokeargs ($instance, Array (' snsgou.com '));

Second, through Reflectionmethod, we can get information about a method of the person class:

1. Whether "public", "protected", "private", "static" type
2. Parameter list of the method
3. Number of parameters for the method
4. Methods of sung using classes
Copy the Code code as follows:
Execute the Detail method
$method = new Reflectionmethod (' person ', ' test ');

if ($method->ispublic () &&! $method->isstatic ()) {
Echo ' Action is right ';
}
echo $method->getnumberofparameters (); Number of parameters
echo $method->getparameters (); Array of Parameter objects

PHP reflection Gets the comment of the class

Array_push ($_files[

PHP Code issues

is a reference, and the argument is a class that conforms to the Reflectionmethod class definition.

http://www.bkjia.com/PHPjc/858747.html www.bkjia.com true http://www.bkjia.com/PHPjc/858747.html techarticle PHP's Reflection class Reflectionclass, Reflectionmethod use instances, Reflectionmethod PHP5 has a complete reflection API, add to the class, interface, functions, methods and extensions of reverse engineering ...

