PHP reflection and automatic loading

This article mainly introduces PHP's reflection and automatic loading. It analyzes the principles of PHP loading and the implementation techniques of automatic loading with examples. I hope it will be helpful to everyone's understanding of PHP's reflection and automatic loading.

The example in this article describes how to implement lazy loading in PHP. Share it with everyone for your reference. The specific analysis is as follows:

Ordinary PHP loading is to load external files through include(), require() and other methods, and then call the method through the instance or directly call the static method, and it is really difficult to write the introduction statement in this way. Trouble, some frameworks will import all the files with a specific path, and they can be used by instantiating them directly. However, some class packages may not be used in this way. The more class packages you write, the more things you need to load. , affecting program performance.

You can directly obtain a reflection class of the corresponding class through PHP's reflection class ReflectionClass:

The test.php file is as follows:

<?php
 class test{
   public function showName(){
     var_dump(__CLASS__);
   }
 }
?>

index.php file is as follows:

##

<?php
var_dump(get_included_files()); 
$rf = new ReflectionClass(&#39;test&#39;);
var_dump(get_included_files());
$testObj = $rf->newInstance();
$testObj->showName();
function __autoload($classname){
  $classpath = &#39;./&#39; . $classname . &#39;.php&#39;;
  if (file_exists($classpath)) {
    require_once($classpath);
  }else {
    echo &#39;class file&#39;.$classpath.&#39;not found!&#39;;
  }
}
?>
//array
// 0 => string &#39;D:\code\www\test\index.php&#39;(length=26)
//array
// 0 => string &#39;D:\code\www\test\index.php&#39;(length=26)
// 1 => string &#39;D:\code\www\text\test.php&#39;(length=25)
//string &#39;test&#39; (length=4)

Instantiate a ReflectionClass , and pass the class name in, you will get a reflection class of the corresponding class. Calling newInstance with an instance will get an instance of the reflection class, thus completing the instantiation.

Through the get_included_files() method, we can see the files introduced by the current page. Before instantiating the reflection class, there is only the index.php file. After instantiating the reflection class, a test.php file is automatically introduced. Then look at the above code and find that there is a magic method named __autoload(). This method The automatic loading file is defined, and when ReflectionClass cannot find the class on the current page, it will call __autoload() to load the class. This is the process of automatic loading.

If you want to know whether the __autoload() method is enabled, you can check it through the method in the PHP standard library SPL:

var_dump(spl_autoload_functions());
spl_autoload_register('newAutoload');
var_dump(spl_autoload_functions());
$testObj1 = getInstance('test');
$testObj2 = getInstance('test');
$testObj3 = getInstance('test');
function getInstance($class, $returnInstance = false){
  $rf = new ReflectionClass($class);
  if ($returnInstance)
     return $rf->newInstance();
}
function newAutoload($classname){
  $classpath = './' . $classname . '.php';
  if (file_exists($classpath)) {
    var_dump('require success');
    require_once($classpath);
  } else {
    echo 'class file ' . $classpath . ' not found!';
  }
}
//array
// 0 => string '__autoload' (length=10)
//array
// 0 => string 'newAutoload' (length=11)
//string 'require success' (length=15)

sql_autoload_functions() method is used to view the current autoloading method. There is currently a __autoload magic method, so the function name is returned. If the autoloading method is not defined, false is returned, and spl_autoload_register() The method is to register a method to the autoloading method through the method name. Here, the newAutoload method is used to replace the __autoload method.

In the newAutoload method, every time the execution is successful, the sentence 'require success' is printed. This is only printed once, indicating that although ReflectionClass('test') has been instantiated 3 times, the test class has been loaded once. , the automatic loading method will no longer be executed. The method of loading classes through getInstance() is much more convenient than the previous include(). You only need to load the file with the getInstance() method written on it.

The rewritten automatic loading method can define different file paths by judging the name of the class as needed. getInstance can use static variables to save instances, which also uses the singleton pattern in the design pattern.

Related recommendations:

PHP automatically loads objects (take MVC framework as an example)

php automatic loading function __autoload()

php reflection mechanism

The above is the detailed content of PHP reflection and automatic loading. For more information, please follow other related articles on the PHP Chinese website!