{"id":271,"date":"2015-07-22T08:43:16","date_gmt":"2015-07-22T06:43:16","guid":{"rendered":"http:\/\/staratnight.de\/blog\/?p=271"},"modified":"2018-12-02T16:44:20","modified_gmt":"2018-12-02T14:44:20","slug":"autoload-in-php","status":"publish","type":"post","link":"https:\/\/staratnight.de\/blog\/autoload-in-php\/","title":{"rendered":"Autoload in PHP"},"content":{"rendered":"

Wie man meinen Artikeln in den letzten Wochen entnehmen kann, befasse ich mich derzeit mit der Entwicklung von PHP. PHP habe ich schon fr\u00fcher programmiert, sei es Erweiterungen f\u00fcr das von Wikipedia bekannte Mediawiki oder diverse Webseiten, etwa die des Unternehmens, in dem ich arbeite oder meine eigene.<\/p>\n

Zuletzt verwendete ich PHP haupts\u00e4chlich dazu, Daten in einer MySQL-Datenbank, auf meinem Web-Space nach au\u00dfen hin zug\u00e4nglich zu machen. Z.B. habe ich ein C#-Programm, mit dem ich Koch-Rezepte verwalten kann. Die Daten liegen in einer MySQL-Datenbank und ich rufe sie \u00fcber einen Rest-Service ab.<\/p>\n

 <\/p>\n

Sch\u00f6ner Code mit PHP?<\/h1>\n

Diese Schnittstelle galt es nun noch einmal neu zu machen, da ich den Code so wie er war nicht mehr zum laufen bekommen hatte (das lag an einer Dritthersteller-Komponente, dessen Funktionsweise ich wohl vergessen hatte).<\/p>\n

Diesmal wollte ich aber nicht wieder einfach PHP-Seiten erstellen und tonnenweise Funktionen da rein packen. Funktionsorientierte Programmierung gef\u00e4llt mir mittlerweile gar nicht mehr. Das muss doch besser gehen!<\/p>\n

Auf den richtigen Weg hat mich die Seite PHP: the right way<\/a> gebracht. Hier wird erkl\u00e4rt, wie man eine PHP-Anwendung sauber und objektorientiert strukturiert. Hier hat mir insbesondere der Abschnitt Namespaces<\/a> gefallen. Die l\u00e4stig langen Listen von include <\/em>oder require <\/em>am Anfang von Quellcode-Dateien geh\u00f6ren damit der Vergangenheit an, wir arbeiten jetzt nur noch mit use<\/em> auf Basis von Namespaces, was im Grunde einem import<\/em> in Java oder using<\/em> in .Net entspricht.<\/p>\n

 <\/p>\n

Was ist Autoload?<\/h1>\n

Autoload ist im Grunde ein Konzept, mit dessen Hilfe es m\u00f6glich ist, PHP-Dateien aus einem Namespace automatisch zu laden, wenn diese zur Laufzeit noch unbekannt sind. Das entspricht in etwa dem Konzept der Dependency Injection. Wir m\u00fcssen uns nicht mehr darum k\u00fcmmern, woher eine Klasse kommt, sie ist einfach da. Der Unterschied ist nur, dass wir sie hier noch selbst instanzieren m\u00fcssen.<\/p>\n

 <\/p>\n

Wie funktioniert Autoload?<\/h1>\n

Seit PHP5 gibt es die sogenannte Autoload-Funktion<\/a>. Hier\u00fcber lassen sich Klassen laden, wenn PHP diese zum Zeitpunkt der Verwendung noch nicht kennt.<\/p>\n

In PHP 5.1.2 ist nun eine Regsitrierung f\u00fcr Autoloader dazugekommen (spl_autoload_register<\/a>). Dadurch ist man nicht mehr darauf beschr\u00e4nkt, einen Autoloader zu nutzen, sondern kann verschiedene Autoloader registrieren, die dann alle verwendet werden, wenn eine Klasse geladen werden soll.<\/p>\n

Durch diese Erweiterung ist Autoload ein m\u00e4chtiges Werkzeug, um Ordnung in das Chaos der PHP-Dateien zu bekommen. Dadurch lassen sich nun z.B. f\u00fcr alle verwendeten Bibliotheken eigene Autoloader registrieren (welche diese in aller Regel mitbringen) und man muss sich darum schon nicht mehr selbst k\u00fcmmen.<\/p>\n

Wir brauchen also nur noch einen Autoloader f\u00fcr unsere eigenen Klassen. Aber auch das hat mich einige Zeit gekostet, dahinter zu kommen, wie dies sauber funktioniert. Eine sehr gro\u00dfe Hilfe war der Artikel von Jess Telford<\/a> in seinem Blog. Auf diesem Artikel basiert auch das folgende Beispiel.<\/p>\n

 <\/p>\n

Beispiel<\/h1>\n

Nehmen wir als Beispiel das oben genannte Projekt, in dem Kochrezepte gespeichert werden. Wir haben eine Klasse EntityRepository<\/em> (das sind Messeinheiten, etwa Liter oder Gramm, f\u00fcr die Angabe zu einer Zutat) in einer eigenen PHP-Datei. Diese ben\u00f6tigt das Model Entity <\/em>und die Klasse PDO<\/em> f\u00fcr den Zugriff auf die Datenbank (darauf kommt ich sp\u00e4ter in einem anderen Artikel nochmal drauf zur\u00fcck).<\/p>\n

<\/h2>\n

Fr\u00fcher war alles Besser?<\/h2>\n

Nach dem alten Verfahren w\u00fcrde die Datei in etwa so aussehen:<\/p>\n

<?php\r\n\r\ninclude \"model\\Entity.php\"\r\n\r\nclass EntityRepository\r\n{\r\n\r\n    \/**\r\n     * Retrieves the entity from the database by id.\r\n     *\r\n     * @param PDO $con connection to the database\r\n     * @param int $id The id of the Entity\r\n     *\r\n     * @return Entity The Entity found.\r\n     *\/\r\n    public function findEntityById(PDO $con, $id)\r\n    {\r\n        [...]\r\n    }\r\n[...]<\/pre>\n
W\u00fcrden wir nun ein paar Klassen in einer anderen ben\u00f6tigen, m\u00fcssten wir all diese in include-Anweisungen angeben. Die Liste kann mitunter sehr lang werden.<\/p>\n
 <\/p>\n
Der AutoLoader<\/h2>\n
Schreiben und registrieren wir nun also einen Autoloader.<\/p>\n
<?php\r\n\r\nclass AutoLoader\r\n{\r\n\r\n    static private $classNames = array();\r\n\r\n    \/**\r\n     * Store the filename (without extension) & full path of all \".php\" files found\r\n     *\/\r\n    public static function registerDirectory($dirName)\r\n    {\r\n\r\n        $di = new DirectoryIterator($dirName);\r\n        foreach ($di as $file) {\r\n\r\n            if ($file->isDir() && !$file->isLink() && !$file->isDot()) {\r\n                \/\/ recurse into directories other than a few special ones\r\n                self::registerDirectory($file->getPathname());\r\n            } elseif (substr($file->getFilename(), -4) === '.php') {\r\n                \/\/ save the class name \/ path of a .php file found\r\n                $className = substr($file->getPathname(), 0, -4);\r\n                AutoLoader::registerClass($className, $file->getPathname());\r\n            }\r\n        }\r\n    }\r\n\r\n    private static function registerClass($className, $fileName)\r\n    {\r\n        AutoLoader::$classNames[$className] = $fileName;\r\n    }\r\n\r\n    public static function loadClass($className)\r\n    {\r\n        if (isset(AutoLoader::$classNames[$className])) {\r\n            require_once(AutoLoader::$classNames[$className]);\r\n        }\r\n    }\r\n}\r\n\r\n\/\/ Register auto loader\r\nspl_autoload_register(array('AutoLoader', 'loadClass'));<\/pre>\n
 <\/p>\n
\u00dcber die Methode registerDirectory(…)<\/em> k\u00f6nnen wir dem Autoloader Verzeichnisse \u00fcbergeben, in denen er zur Laufzeit nach neuen Klassen suchen soll. Zur Laufzeit selbst wird dann, wenn PHP eine Klasse noch nicht kennt, die Methode loadClass(…)<\/em> aufgerufen, um die Klasse zu laden.<\/p>\n
Die Klasse AutoLoader speichert alle registrierten Klassen in einem assoziativen Array<\/a> ab. Dabei wird der vollqualifizierte Name der Klasse registriert.<\/p>\n
 <\/p>\n
Den Autoloader konfigurieren<\/h2>\n
Als n\u00e4chstes m\u00fcssen wir den AutoLoader noch mit den Verzeichnissen f\u00fcttern, in denen unsere Klassen liegen. Das erfolgt ganz klassisch \u00fcber einen PHP-include:<\/p>\n
 <\/p>\n
<?php\r\nrequire 'AutoLoader.php';\r\n\r\nAutoLoader::registerDirectory('dispatcher');\r\nAutoLoader::registerDirectory('json');\r\nAutoLoader::registerDirectory('model');\r\nAutoLoader::registerDirectory('repository');\r\n<\/pre>\n
Ich habe in meinem Beispiel also vier Verzeichnisse, in denen der Autoloader nach Klassen suchen soll. Der Autoloader merkt sich dann alle PHP-Dateien aus allen angegebenen Verzeichnisse.<\/p>\n
Kommt ein neues Verzeichnis hinzu, muss dies ebenfalls einmalig registriert werden.<\/p>\n
Diese Konfigurationsdatei muss nat\u00fcrlich auch einmal per include<\/em> eingebunden werden, etwa in der index.php<\/em>.<\/p>\n
 <\/p>\n
Der AutoLoader in Aktion<\/h2>\n
Habe ich den AutoLoader einmalig konfiguriert, stehen mir alle Klassen unter dem vollqualifizierten Namen zur Verf\u00fcgung. Um diese festzulegen, nutze ich Namespaces.<\/p>\n
Als Beispiel die Entity-Klasse von oben:<\/p>\n
<?php namespace model;\r\n\r\nclass Entity\r\n{\r\n    [...]\r\n}<\/pre>\n
Die Klasse Entity<\/em> liegt im Verzeichnis model<\/em>. Durch die Angabe des Namespace model<\/em> ist die Klasse nun unter dem vollqualifizierten Namen model\\Entity<\/em> zu finden. Verwenden wir in PHP Namespaces, verwendet PHP bei der Suche nach der Klasse immer die vollqualifizierten Namen.<\/p>\n
 <\/p>\n
Unsere Klasse EntityRepository<\/em> sieht also nun so aus:<\/p>\n
<?php namespace repository;\r\n\r\nuse model\\Entity;\r\n\r\nclass EntityRepository\r\n{\r\n\r\n    \/**\r\n     * Retrieves the entity from the database by id.\r\n     *\r\n     * @param PDO $con connection to the database\r\n     * @param int $id The id of the Entity\r\n     *\r\n     * @return Entity The Entity found.\r\n     *\/\r\n    public function findEntityById(PDO $con, $id)\r\n    {\r\n        [...]\r\n    }\r\n[...]<\/pre>\n
Ich kann das include weglassen, ich muss nicht wissen, wo sich die Klasse befindet. Verschiebe ich die Klasse, findet der AutoLoader sie trotzdem und ich muss nicht alle include-Anweisungen korrigieren.<\/p>\n
Hinweis:<\/em> Ich verwende hier noch use f\u00fcr die Entity<\/em>-Klasse. Der Grund ist dabei nicht, dass PHP die Klasse nicht auch so finden w\u00fcrde. Der Grund ist, dass mir IntelliJ dann sehr viel Unterst\u00fctzung bietet, was Code-Vervollst\u00e4ndigung und Pr\u00fcfung angeht.<\/p>\n
 <\/p>\n
Verzeichnisstruktur<\/h1>\n
Ein Problem das ich bei der Besch\u00e4ftigung mit dem Thema noch hatte ist der der Verzeichnisstruktur. Wir baue ich die Verzeichnisse sauber auf, so, dass nachher auch noch alles funktioniert?<\/p>\n
Hier mal ein Beispiel:<\/p>\n