How to implement lazy loading in PHP, implement loading in PHP_PHP tutorial

How to implement lazy loading in PHP, how to implement loading in php

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:

Usual PHP loading is to load external files through include(), require() and other methods, and then call methods through instances or directly call static methods. It is really troublesome to write import statements in this way. Some frameworks will All files with a specific path are imported and can be used by direct instantiation. However, some class packages may not be used in this way. When more class packages are written, a lot of things will be loaded, which affects the performance of the program.

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

The test.php file is as follows:

<&#63;php
 class test{
   public function showName(){
     var_dump(__CLASS__);
   }
 }
&#63;>

The index.php file is as follows:

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

Instantiate a ReflectionClass and pass the class name in, and 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)

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

In the newAutoload method, every time the execution is successful, the sentence 'require success' is printed. It is only printed once, which shows that although ReflectionClass('test') has been instantiated three times, because the test class has been loaded once, it will not The automatic loading method will be executed again. 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 overridden automatic loading method can define different file paths by judging the class name as needed. getInstance can use static variables to save instances, which also uses the singleton pattern in the design pattern.

I hope this article will be helpful to everyone’s PHP programming design.

http://www.bkjia.com/PHPjc/963826.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/963826.htmlTechArticleHow to implement lazy loading in PHP, PHP implements loading. This article describes the method of implementing lazy loading in PHP. Share it with everyone for your reference. The specific analysis is as follows: Normal php is loaded through i...