The following composer command uses the tutorial column to introduce to you about composer automatic loader optimization. I hope it will be helpful to friends in need!
Autoloader optimization
Normally, Composer’s autoloader runs relatively fast. However, due to the autoloading rules of PSR-4 and PSR-0, the file system needs to be checked before finally parsing a class. This will cause the speed of automatic loading to become quite slow, but in a development environment, this will be a very convenient way of loading, because when you create a new class, the loader will immediately discover and use the class without You are required to rebuild the autoloader configuration.
The problems caused by this kind of loading rule are really reflected in the production environment. In the production environment, you can easily rebuild the configuration before each deployment, and new configurations will not randomly appear between deployments. class, so you don't need it to check the file system all the time, you generally want the autoload to complete as quickly as possible.
For the above reasons, Composer provides some optimization strategies for autoloaders.
Note: You should not use any of the optimization strategies described in this article in a development environment, as this will cause various problems when you add or remove classes. In fact, the performance gain from applying these settings in a development environment is far outweighed by the problems it causes.
Optimization level 1: Class map generation
How to run it?
There are several options to enable this feature:
Set "optimize-autoloader": true in the configuration of composer.json
Use -o / - -optimize-autoloader calls installation or update
Use -o / --optimize to call dump-autoload
What does it do?
Class mapping generation essentially converts PSR-4/PSR-0 rules into class mapping rules. This makes everything a lot faster, since a known class map returns the path immediately, and Composer can guarantee the class is there, so no file system checks are needed.
In PHP 5.6, classmaps are also cached in opcache, which greatly improves initialization time. If you make sure opcache is enabled, the classmap should load immediately and the classes will load quickly.
Tradeoffs
There are no real tradeoffs with this approach. It should always be enabled in production.
The only problem is that it doesn't track autoloading (i.e. when it can't find a given class), so it's still possible that those rules that fall back to PSR-4 will cause filesystem checks to be slower . To solve this problem, there are two secondary optimization options that you can decide to enable if you perform a lot of class_exists checks for classes that do not exist in your project.
Optimization level 2/A: Authoritative class mapping
How to enable it?
There are several options to enable this feature:
Set "classmap-authoritative": true in the config key of composer.json
Use -a / --classmap-authoritative Call to install or update
Use -a / --classmap-authoritative to call dump-autoload
What does it do?
Enabling this option automatically enables level 1 class map optimization.
This option is simple, it says that if something is not found in the class diagram, then it does not exist and the autoloader should not try to look at the file system according to PSR-4 rules.
tradeoff
This option enables the autoloader to always return quickly. On the other hand, it also means that if the class is generated at runtime for some reason, autoloading is not allowed. If your project or any of its dependencies do this then you may run into "class not found" issues in production. Be careful to enable it.
Note: This cannot be used in conjunction with Level 2/B optimization. You have to choose one because they solve the same problem in different ways.
Optimization Level 2/B: APCu Cache
How to enable it?
There is an option to enable this feature:
Set "apcu-autoloader": true in the configuration key of composer.json
Use --apcu- Autoloader calls installation or update
Use --apcu to call dump-autoload
What does it do?
This option adds the APCu cache as a fallback to the class map. It does not automatically generate classmaps, so you still need to manually enable level 1 optimization if you wish.
Whether the class is found or not, this fact is always cached in APCu so it can be returned quickly on the next request.
Weigh-offs
This option requires APCu, which may or may not work for you. It also uses APCu memory for autoloading, but it is safe to use and does not cause classes not to be found, like the authoritative classmap optimization above.
Note: This cannot be used in conjunction with Level 2/A optimization. You have to choose one because they solve the same problem in different ways.
The above is the detailed content of composer autoloader optimization. For more information, please follow other related articles on the PHP Chinese website!