PHP's class automatic loading mechanism_PHP tutorial

During the PHP development process, if you want to introduce a class from the outside, you usually use the include and require methods to include the file that defines the class. When this is developed on a small scale, there is no big problem. However, in large-scale development projects, doing so will generate a large number of require or include method calls, which not only reduces efficiency, but also makes the code difficult to maintain, and require_once is very expensive.

Before PHP5, if each PHP framework wanted to implement automatic loading of classes, they usually implemented a class or function that traversed the directory and automatically loaded all files that conformed to the agreed rules according to a certain agreement. Of course, the object-oriented support before PHP5 was not very good, and the use of classes was not as frequent as it is now. After PHP5, when loading a PHP class, if the file where the class is located is not included, or the class name is wrong, the Zend engine will automatically call the __autoload function. This function requires users to implement the __autoload function themselves. After PHP5.1.2, you can use the spl_autoload_register function to customize the automatic loading processing function. When this function is not called, SPL's custom spl_autoload function will be used by default.

1. __autoload example:

function __autoload($class_name) {
echo '__autload class:', $class_name, '
';
}

new Demo();
The above code will output at the end: __autload class:Demo.
And after that, the error message is displayed: Fatal error: Class ‘Demo’ not found

We generally use _autoload to automatically load classes as follows:

function __autoload($class_name) {
　　 require_once ($class_name . “class.php”);
}
$memo= new Demo();
We can see that _autoload has to do at least three things. The first thing is to determine the class file name based on the class name. The second thing is to determine the disk path where the class file is located (in our example, in the simplest case, the class in the same folder as the PHP program files that call them), the third thing is to load the classes from the disk file into the system. The third step is the simplest, just use include/require. To realize the functions of the first and second steps, the mapping method between the class name and the disk file must be agreed upon during development. Only in this way can we find its corresponding disk file based on the class name.

Therefore, when there are a large number of class files to be included, we only need to determine the corresponding rules, and then in the __autoload() function, match the class name with the actual disk file to achieve the lazy loading effect . From here we can also see that the most important thing in the implementation of the __autoload() function is the implementation of the mapping rules between the class name and the actual disk file.

But now comes the problem. If you need to use many other class libraries in the implementation of a system, these class libraries may be developed by different development engineers, and the mapping rules between their class names and actual disk files are different. All the same. At this time, if you want to implement automatic loading of class library files, you must implement all mapping rules in the __autoload() function. Therefore, the __autoload() function may be very complicated or even impossible to implement. In the end, the __autoload() function may become very bloated. Even if it can be implemented, it will have a great negative impact on future maintenance and system efficiency. In this case, PHP5 introduces the SPL standard library, a new solution, the spl_autoload_register() function.

2. spl_autoload_register() function

The function of this function is to register the function into the __autoload function stack of SPL and remove the system default __autoload() function. This can be seen in the following example:

function __autoload($class_name) {
echo '__autload class:', $class_name, '
';
}
function classLoader($class_name) {
echo 'SPL load class:', $class_name, '
';
}
spl_autoload_register('classLoader');
new Test();//Result:SPL load class:Test
Syntax: bool spl_autoload_register ([callback $autoload_function]) Accepts two parameters: one is the function added to the autoloading stack, and the other is a flag indicating whether to throw an exception when the loader cannot find this class. The first parameter is optional and by default points to the spl_autoload() function, which automatically looks for any extension in the path that has a lowercase class name and a .php extension or .ini extension, or any other extension registered with the spl_autoload_extensions() function. named file.

class CalssLoader
{ 
Public static function loader($classname)
                                                     $class_file = strtolower($classname).".php";                                       If (file_exists($class_file)){
              require_once($class_file);                                                                                                  }  
} 
// The method is a static method
spl_autoload_register('CalssLoader::loader'); 
$test = new Test();
Once the spl_autoload_register() function is called, when an undefined class is called, the system will call all functions registered to the spl_autoload_register() function in sequence instead of automatically calling the __autoload() function. If you want to avoid this situation, you need to use a safer initialization calling method of spl_autoload_register() function:

if(false === spl_autoload_functions()){ 
if(function_exists('__autoload')){
spl_autoload_registe('__autoload',false);

} 
The spl_autoload_functions() function will return an array of registered functions. If the SPL autoload stack has not been initialized, it will return a Boolean value of false. Then, check whether a function named __autoload() exists. If it exists, you can register it as the first function in the autoload stack, thus retaining its functionality. After that, you can continue to register the autoload function.

You can also call the spl_autoload_register() function to register a callback function instead of providing a string name for the function. For example, providing an array such as array('class','method') allows you to use the method of an object.

Next, by calling the spl_autoload_call('className') function, you can manually call the loader without trying to use that class. This function can be used in combination with class_exists('className', false) to attempt to load a class and fail if all autoloaders cannot find the class.

f(spl_autoload_call('className') && class_exists('className',false)){  

} else {  

The SPL autoloading function is provided by the spl_autoload(), spl_autoload_register(), spl_autoload_functions(), spl_autoload_extensions() and spl_autoload_call() functions.
(Summary of network content)



Excerpted from Programming Life, guisu column

www.bkjia.com