Analyze the application of reflection in php
1 The use of reflection:
<?php class Person{ public $name; function __construct($name){ $this->name=$name; } } interface Module{ function execute(); } class FtpModule implements Module{ function setHost($host){ print "FtpModule::setHost():$host\n"; } function setUser($user){ print "FtpModule::setUser():$user\n"; } function execute(){ //something } } class PersonModule implements Module{ function setPerson(Person $person){ print "PersonModule::setPerson:{$person->name}\n"; } function execute(){ //something } } class ModuleRunner{ private $configData =array( "PersonModule"=>array('person'=>'bob'), "FtpModule"=>array('host'=>'example.com','user'=>'anon') ); private $modules=array(); function init(){ $interface=new ReflectionClass('Module'); foreach($this->configData as $modulename=>$params){ $module_class=new ReflectionClass($modulename);//根据配置configData的名称,实例化ReflectionClass if(!$module_class->isSubclassOf($interface)){//检查反射得到了类是否是$interface的子类 throw new Exception("unknown module type:$modulename");//不是Module子类则抛出异常 } $module=$module_class->newInstance();//实例化一个FtpModule或者PersonModule对象 foreach($module_class->getMethods() as $method){//获得类中的方法 $this->handleMethod($module,$method,$params); } array_push($this->modules,$module);//将实例化的module对象放入$modules数组中 } } function handleMethod(Module $module,ReflectionMethod $method,$params){ $name=$method->getName();//获得方法名称 $args=$method->getParameters();//获得方法中的参数 if(count($args)!=1||substr($name,0,3)!="set"){//检查方法必须是以set开头,且只有一个参数 return false; } $property=strtolower(substr($name,3));//讲方法名去掉set三个字母,作为参数 if(!isset($params[$property])){//如果$params数组不包含某个属性,就返回false return false; } $arg_class=@$args[0]->getClass;//检查setter方法的第一个参数(且唯一)的数据类型 if(empty($arg_class)){ $method->invoke($module,$params[$property]); }else{ $method->invoke($module,$arg_class->newInstance($params[$property])); } } } $test=new ModuleRunner(); $test->init(); ?>
2 Obtaining information in the class through reflection:
<PRE class=php name="code"><?php class ReflectionUtil{ static function getClassSource(ReflectionClass $class){ $path=$class->getFileName(); $lines=@file($path); $from=$class->getStartLine(); $to=$class->getEndLine(); $len=$to-$from+1; return implode(array_slice($lines,$from-1,$len)); } } $classname="Person"; $path="../practice/{$classname}.php"; if(!file_exists($path)){ throw new Exception("No such file as {$path}"); } require_once($path); if(!class_exists($classname)){ throw new Exception("No such class as {$classname}"); } print ReflectionUtil::getClassSource(new ReflectionClass('Person')); ?>
结果是:class Person{ public $age; public $name; function getName(){return "zjx";} function getAge(){return 12;} function __toString(){ $rs=$this->getName(); $rs.="(age".$this->getAge().")"; return $rs; } }
For more articles related to the application of reflection in PHP, please pay attention to the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

AI Hentai Generator
Generate AI Hentai for free.

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

The reflection mechanism allows programs to obtain and modify class information at runtime. It can be used to implement reflection of interfaces and abstract classes: Interface reflection: obtain the interface reflection object through Class.forName() and access its metadata (name, method and field) . Reflection of abstract classes: Similar to interfaces, you can obtain the reflection object of an abstract class and access its metadata and non-abstract methods. Practical case: The reflection mechanism can be used to implement dynamic proxies, intercepting calls to interface methods at runtime by dynamically creating proxy classes.

You can use reflection to access private fields and methods in Go language: To access private fields: obtain the reflection value of the value through reflect.ValueOf(), then use FieldByName() to obtain the reflection value of the field, and call the String() method to print the value of the field . Call a private method: also obtain the reflection value of the value through reflect.ValueOf(), then use MethodByName() to obtain the reflection value of the method, and finally call the Call() method to execute the method. Practical case: Modify private field values and call private methods through reflection to achieve object control and unit test coverage.

Methods to solve Java reflection exceptions (ReflectiveOperationException) In Java development, reflection (Reflection) is a powerful mechanism that allows programs to dynamically obtain and operate classes, objects, methods, properties, etc. at runtime. Through reflection, we can implement some flexible functions, such as dynamically creating objects, calling private methods, obtaining class annotations, etc. However, using reflection also brings some potential risks and problems, one of which is reflection anomalies (

Go language reflection allows you to manipulate variable values at runtime, including modifying Boolean values, integers, floating point numbers, and strings. By getting the Value of a variable, you can call the SetBool, SetInt, SetFloat and SetString methods to modify it. For example, you can parse a JSON string into a structure and then use reflection to modify the values of the structure fields. It should be noted that the reflection operation is slow and unmodifiable fields cannot be modified. When modifying the structure field value, the related fields may not be automatically updated.

The reflection feature in the Go language allows a program to inspect and modify the structure of a type at runtime. By using Type, Value and reflect.Kind, we can obtain the type information, field values and methods of the object, and we can also create and modify objects. Specific operation methods include: checking type (TypeOf()), obtaining field value (ValueOf(), FieldByName()), modifying field value (Set()), and creating object (New()).

Using reflection, Go allows the creation of new types. 1. Use reflect.TypeOf() to get the reflect.Type value of an existing type; 2. Use reflect.New() to create a pointer value of a new type; 3. Through *Ptr.Elem( ) to access the actual value; 4. Reflection can also dynamically create new types based on strings, which is used to build flexible and dynamic programs.

Reflection provides type checking and modification capabilities in Go, but it has security risks, including arbitrary code execution, type forgery, and data leakage. Best practices include limiting reflective permissions, operations, using whitelists or blacklists, validating input, and using security tools. In practice, reflection can be safely used to inspect type information.

The reflection mechanism is used in Java to implement method overloading: Obtain methods through reflection: Use the getMethod() method to obtain the method object and specify the method name and parameter type. Calling method: Use the invoke() method to call the method, specifying the caller object and parameter values.
