Shulou(Shulou.com)06/02 Report--

This article mainly introduces what the composer automatic loading mechanism refers to, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let the editor take you to understand it.

Text 1. Get to know spl_autoload_register.

First, take a look at the php official manual:

(you can just look at the red part when you are lazy)

Do you seem to know a little about it?

Let's translate it in vernacular:

If we new a class, we must first require or include the file of the class, if it is not loaded in, it will report an error. This creates a problem: in that case, the header of the file is full of requies and include, which obviously does not conform to the need for programmers to be "lazy" to urinate.

In order to properly new a class without requiring require or include class files, an automatic loading mechanism has emerged. That's what the spl_autoload_register function does.

You can see from the screenshot that this function has three parameters:

Parameter details autoload_function. Fill in a * "function" name *, string or array. The function of this function is to use the file require or include that requires new as far as possible to avoid errors in new. To put it simply, it requires you to encapsulate a function that automatically loads files * throw. When the automatically loaded function cannot be registered, whether to throw an exception prepend whether to add the function to the first part of the function queue, and if it is true, the first, otherwise the tail

Let's take a wave of code and be impressed:

/ / file testClass.php, that is, new class class TestClass {public function _ _ construct () {echo 'you have successfully new me';}} / / file autoloadDemo.php file spl_autoload_register ('autoLoad_function', true, true); function autoLoad_function ($class_name) {echo "leave all the require or include file work to me! \ r\ n "; $class_filename =". / {$class_name} .php "; echo" I'll load the {$class_filename} file\ r\ n "; require_once (". / {$class_name} .php ");} $obj_demo = new TestClass ()

Output:

Leave all the require or include file work to me! I'll load the testClass.php file. You've successfully new me.

If you understand the principle of loading, it will be much easier to read the following text.

The story of what happened in 2.composer update

Before you load automatically, you have to talk about composer update, which carries the premise of automatic loading.

The composer project contains a configuration file for composer.json.

There is a key field "autoload" that contains two fields, psr-4 and files.

Psr-4: description is a class library based on psr-4 specification, all of which support automatic loading, as long as you write your own class library information in the way of * * "Namespace: path" * * in the following objects.

Files: this is even more straightforward, and the write path is automatically loaded.

According to the above configuration, after each composer update, a very important file is updated:. / vender/composer/autoload_psr4.php.

This file does only one thing: map the namespace to the file path so that subsequent automatic loading has a mapping basis.

3. Track the automatic loading of composer

Composer's story begins with the only require:

Require'.. / vendor/autoload.php'

This script executes a function:

ComposerAutoloaderInitd9b31141b114fcbee3cf55d0e97b7f87::getLoader ()

What did you continue to do with the getloader function?

Public static function getLoader () {if (null! = = self::$loader) {return self::$loader;} spl_autoload_register (array ('ComposerAutoloaderInitd9b31141b114fcbee3cf55d0e97b7f87',' loadClassLoader'), true, true); self::$loader = $loader = new\ Composer\ Autoload\ ClassLoader (); spl_autoload_unregister (array ('ComposerAutoloaderInitd9b31141b114fcbee3cf55d0e97b7f87',' loadClassLoader')) $useStaticLoader = PHP_VERSION_ID > = 50600 & &! defined ('HHVM_VERSION') & &! function_exists (' zend_loader_file_encoded') | |! zend_loader_file_encoded (); if ($useStaticLoader) {require_once _ _ DIR__. / autoload_static.php'; call_user_func (\ Composer\ Autoload\ ComposerStaticInitd9b31141b114fcbee3cf55d0e97b7f87::getInitializer ($loader));} else {$map = require _ _ DIR__. / autoload_namespaces.php'; foreach ($map as $namespace = > $path) {$loader- > set ($namespace, $path);} $map = require _ _ DIR__. / autoload_psr4.php'; foreach ($map as $namespace = > $path) {$loader- > setPsr4 ($namespace, $path);} $classMap = require _ _ DIR__. '/ autoload_classmap.php'; if ($classMap) {$loader- > addClassMap ($classMap);}} $loader- > register (true); if ($useStaticLoader) {$includeFiles = Composer\ Autoload\ ComposerStaticInitd9b31141b114fcbee3cf55d0e97b7f87::$files;} else {$includeFiles = require _ DIR__. '/ autoload_files.php';} foreach ($includeFiles as $fileIdentifier = > $file) {composerRequired9b31141b114fcbee3cf55d0e97b7f87 ($fileIdentifier, $file);} return $loader;}

This function does two main things:

1. Load various files with namespaces and file mappings in autoload_xxx.php and do some processing (for example: setPsr4 loads the relevant mappings, which will be echoed below. ).

two。 The function register is registered

Keep track of what register did:

Public function register ($prepend = false) {spl_autoload_register (array ($this, 'loadClass'), true, $prepend);}

The spl_autoload_register function was originally called, and loadClass was used to load the class when the class was not loaded. (the previous article is very clear and should be familiar with it.)

Continue to track the loadClass implementation:

Public function loadClass ($class) {if ($file = $this- > findFile ($class)) {includeFile ($file); return true;}}

As you can probably see, it is the include that has made the file.

To keep track of how to find files, look at the findFile function:

Public function findFile ($class) {/ / class map lookup if (isset ($this- > classMap [$class]) {return $this- > classMap [$class];} if ($this- > classMapAuthoritative | | isset ($this- > missingClasses [$class])) {return false;} if (null! = = $this- > apcuPrefix) {$file = apcu_fetch ($this- > apcuPrefix.$class, $hit); if ($hit) {return $file } $file = $this- > findFileWithExtension ($class, '.php'); / / Search for Hack files if we are running on HHVM if (false = $file & & defined ('HHVM_VERSION')) {$file = $this- > findFileWithExtension ($class,' .hh');} if (null! = = $this- > apcuPrefix) {apcu_add ($this- > apcuPrefix.$class, $file) } if (false = = $file) {/ / Remember that this class does not exist. $this- > missingClasses [$class] = true;} return $file;}

This function does one thing: it looks for the class to find the file path of the mapping from the data initialized by autoload_xxx.php above.

Among them, this function findFileWithExtension is suitable for finding the mapping information of the file of psr-4 specification.

Continue to track findFileWithExtension:

Private function findFileWithExtension ($class, $ext) {/ / PSR-4 lookup $logicalPathPsr4 = strtr ($class,'\', DIRECTORY_SEPARATOR). $ext; $first = $class [0]; if (isset ($this- > prefixLengthsPsr4 [$first])) {$subPath = $class; while (false! = = $lastPos = strrpos ($subPath,'\')) {$subPath = substr ($subPath, 0, $lastPos); $search = $subPath.'\'; if (isset ($this- > prefixDirsPsr4 [$search])) {$pathEnd = DIRECTORY_SEPARATOR. Substr ($logicalPathPsr4, $lastPos + 1); foreach ($this- > prefixDirsPsr4 [$search] as $dir) {if (file_exists ($file = $dir. $pathEnd) {return $file;}} / / PSR-4 fallback dirs foreach ($this- > fallbackDirsPsr4 as $dir) {if (file_exists ($file = $dir. DIRECTORY_SEPARATOR. $logicalPathPsr4) {return $file;}} / / PSR-0 lookup if (false! = = $pos = strrpos ($class,'\')) {/ / namespaced class name $logicalPathPsr0 = substr ($logicalPathPsr4, 0, $pos + 1). Strtr (substr ($logicalPathPsr4, $pos + 1),'_', DIRECTORY_SEPARATOR);} else {/ / PEAR-like class name $logicalPathPsr0 = strtr ($class,'_', DIRECTORY_SEPARATOR). $ext;} if (isset ($this- > prefixesPsr0 [$first])) {foreach ($this- > prefixesPsr0 [$first] as $prefix = > $dirs) {if (0 = strpos ($class, $prefix)) {foreach ($dirs as $dir) {if (file_exists ($file = $dir. DIRECTORY_SEPARATOR. $logicalPathPsr0) {return $file;}} / / PSR-0 fallback dirs foreach ($this- > fallbackDirsPsr0 as $dir) {if (file_exists ($file = $dir. DIRECTORY_SEPARATOR. $logicalPathPsr0) {return $file;}} / / PSR-0 include paths. If ($this- > useIncludePath & & $file = stream_resolve_include_path ($logicalPathPsr0)) {return $file;} return false;}

This function does one thing: convert a class name such as namespace\ class to a path such as directory name / class name .php, find the mapping information from the mapping information set in the previous setPsr4, and then complete the return path.

Thank you for reading this article carefully. I hope the article "what is the composer automatic loading mechanism" shared by the editor will be helpful to everyone? at the same time, I also hope that you will support and pay attention to the industry information channel, and more related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.