Let’s start with the Autoloader.
We will create two classes:
- Autoload.php
- vendor/Psr/PsrAutoloader.php
The first class registered the namespaces, so that the second class can find and load them.
In the PHP world, namespaces are designed to solve two problems that authors of libraries and applications encounter when creating re-usable code elements such as classes or functions:
- Name collisions between code you create, and internal PHP classes/functions/constants or third-party classes/functions/constants.
- Ability to alias (or shorten) Extra_Long_Names designed to alleviate the first problem, improving readability of source code.
PHP Namespaces provide a way in which to group related classes, interfaces, functions and constants.
Reference: php.net
1. PROJECT_ROOT/Autoload.php
As described we want to create two classes for our autoloading, so we need to import the second class in the first one:
|
1 |
use Psr\PsrAutoloader; |
Let’s declare the class itself and some variables:
|
1 2 3 4 5 6 |
class Autoload { private static $instance; public static $root; } |
Without a function, it is pretty empty here. Our autoloader should be a singleton, because we only want to have one instance.
|
1 2 3 4 5 6 7 8 |
final public static function getInstance() { if (self::$instance === null) { self::$instance = new self; } return self::$instance; } |
Now we need the constructor to create the instance we want to have in the code above.
|
1 2 3 4 5 6 7 8 9 10 11 |
final private function __construct() { self::$root = __DIR__ . DIRECTORY_SEPARATOR; // Load Autoloader Class require_once self::$root . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'Psr' . DIRECTORY_SEPARATOR . 'PsrAutoloader.php'; // Register Namespaces for Autoloader $loader = new PsrAutoloader; $loader->register(); $loader->addNamespace('PHPluz', self::$root . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'PHPluz'); $loader->addNamespace('Psr', self::$root . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'Psr'); } |
But all code needs some documentation. The final code looks like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
<?php use Psr\PsrAutoloader; /** * Class Autoload * * Register namespaces and declare standard vars * * @author Janis Jekabsons <php@pluz.de> * @copyright 2016 Janis Jekabsons * @license https://opensource.org/licenses/MIT (MIT) * @version 1.0 */ class Autoload { /** @var \PHPluz\Autoload $instance */ private static $instance; /** @var string $root Full path to root directory of the project */ public static $root; /** * If the single instance does not exist, create it. * Return the single instance then. * * @return \Autoload */ final public static function getInstance() { if (self::$instance === null) { self::$instance = new self; } return self::$instance; } /** * Private constructor to prevent creating a new instance from outside */ final private function __construct() { self::$root = __DIR__ . DIRECTORY_SEPARATOR; // Load Autoloader Class require_once self::$root . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'Psr' . DIRECTORY_SEPARATOR . 'PsrAutoloader.php'; // Register Namespaces for Autoloader $loader = new PsrAutoloader; $loader->register(); $loader->addNamespace('PHPluz', self::$root . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'PHPluz'); $loader->addNamespace('Psr', self::$root . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'Psr'); } /** * Prohibits the cloning of the instance from outside */ final private function __clone() { } } |
2. PROJECT_ROOT/vendor/Psr/PsrAutoloader.php
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 |
<?php namespace Psr; /** * Class PsrAutoloader * * An example of a general-purpose implementation that includes the optional * functionality of allowing multiple base directories for a single namespace * prefix. * * Given a foo-bar package of classes in the file system at the following * paths ... * * /path/to/packages/foo-bar/ * src/ * Baz.php # Foo\Bar\Baz * Qux/ * Quux.php # Foo\Bar\Qux\Quux * tests/ * BazTest.php # Foo\Bar\BazTest * Qux/ * QuuxTest.php # Foo\Bar\Qux\QuuxTest * * ... add the path to the class files for the \Foo\Bar\ namespace prefix * as follows: * * <?php * // instantiate the loader * $loader = new \Psr\PsrAutoloaderClass; * // register the autoloader * $loader->register(); * // register the base directories for the namespace prefix * $loader->addNamespace('Foo\Bar', '/path/to/packages/foo-bar/src'); * $loader->addNamespace('Foo\Bar', '/path/to/packages/foo-bar/tests'); * * The following line would cause the autoloader to attempt to load the * \Foo\Bar\Qux\Quux class from /path/to/packages/foo-bar/src/Qux/Quux.php: * * new \Foo\Bar\Qux\Quux; * * The following line would cause the autoloader to attempt to load the * \Foo\Bar\Qux\QuuxTest class from /path/to/packages/foo-bar/tests/Qux/QuuxTest.php: * * new \Foo\Bar\Qux\QuuxTest; * * @package Psr * * @author PHP Framework Interop Group * @author Janis Jekabsons <php@pluz.de> * @copyright 2015 PHP Framework Interop Group * @license https://opensource.org/licenses/MIT MIT * @version 1.0 */ class PsrAutoloader { /** * @var array $prefixes An associative array where the key is a namespace prefix * and the value is an array of base directories for classes in that namespace. */ protected $prefixes = array(); /** * Register loader with SPL autoloader stack. * * @return void */ public function register() { spl_autoload_register(array($this, 'loadClass')); } /** * Adds a base directory for a namespace prefix. * * @param string $prefix The namespace prefix. * @param string $baseDir A base directory for class files in the * namespace. * @param bool $prepend If true, prepend the base directory to the stack * instead of appending it; this causes it to be searched first rather * than last. * * @return void */ public function addNamespace($prefix, $baseDir, $prepend = false) { // normalize namespace prefix $prefix = trim($prefix, '\\') . '\\'; // normalize the base directory with a trailing separator $baseDir = rtrim($baseDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR; // initialize the namespace prefix array if (isset($this->prefixes[$prefix]) === false) { $this->prefixes[$prefix] = array(); } // retain the base directory for the namespace prefix if ($prepend) { array_unshift($this->prefixes[$prefix], $baseDir); } else { array_push($this->prefixes[$prefix], $baseDir); } } /** * Loads the class file for a given class name. * * @param string $class The fully-qualified class name. * * @return mixed The mapped file name on success, or bool false on failure. */ public function loadClass($class) { // the current namespace prefix $prefix = $class; // work backwards through the namespace names of the fully-qualified // class name to find a mapped file name while (false !== $pos = strrpos($prefix, '\\')) { // retain the trailing namespace separator in the prefix $prefix = substr($class, 0, $pos + 1); // the rest is the relative class name $relativeClass = substr($class, $pos + 1); // try to load a mapped file for the prefix and relative class $mappedFile = $this->loadMappedFile($prefix, $relativeClass); if ($mappedFile) { return $mappedFile; } // remove the trailing namespace separator for the next iteration // of strrpos() $prefix = rtrim($prefix, '\\'); } // never found a mapped file return false; } /** * Load the mapped file for a namespace prefix and relative class. * * @param string $prefix The namespace prefix. * @param string $relativeClass The relative class name. * * @return mixed bool false if no mapped file can be loaded, or the name of the mapped file that was loaded. */ protected function loadMappedFile($prefix, $relativeClass) { // are there any base directories for this namespace prefix? if (isset($this->prefixes[$prefix]) === false) { return false; } // look through base directories for this namespace prefix foreach ($this->prefixes[$prefix] as $baseDir) { // replace the namespace prefix with the base directory, // replace namespace separators with directory separators // in the relative class name, append with .php $file = $baseDir . str_replace('\\', DIRECTORY_SEPARATOR, $relativeClass) . '.php'; // if the mapped file exists, require it if ($this->requireFile($file)) { // yes, we're done return $file; } } // never found it return false; } /** * If a file exists, require it from the file system. * * @param string $file The file to require. * * @return bool True if the file exists, false if not. */ protected function requireFile($file) { if (file_exists($file)) { require_once $file; return true; } return false; } } |
Finally implement the autoloader into your project, but don’t forget to register your namespaces.
Folder structure:
PROJECT_ROOT/vendor/Psr/PsrAutoload.php
PROJECT_ROOT/Autoload.php
PROJECT_ROOT/test.php
PROJECT_ROOT/test.php
|
1 2 3 4 5 |
<?php require_once 'Autoload.php'; Autoload::getInstance(); ... your code here ... |
