Wszystkie znaki na niebie i ziemi wskazywały, że przyda się jakiś w miarę przystępny autoloader. Uratuje to moje palce jak i psychikę od pisania co chwile require_once... 

Co ma robić? Ładować klasy automatycznie po utworzeniu instancji czy przy statycznym wywołaniu. Będzie ustawiać suffixy, foldery które będzie przeszukiwał w poszukiwaniu klas, interfejsów, czego tam chcecie i tworzył z nich mapę. Zaczynamy.

Na początek zmienne:

protected $filesSuffix = array("class");
protected $filesDir = array();
protected static $cacheFile = null;

filesSuffix będzie tablicą która będzie trzymała jak sama nazwa wskazuje sufiksy. Jako podstawowy damy 'class', co będzie z góry szukać plików o nazwach foo.class.php

filesDir będzie przetrzymywać listę katalogów które będą skanowane w poszukiwaniu odpowiednich klas.

cacheFile - ścieżka do pliku z "mapą"

Stwórzmy te trochę mniej ważne metody, ale które będą nam pomagać i tworzyć loadera bardziej elastycznym:

public function addSuffix($suffix) {    if(is_string($suffix))       $this->filesSuffix = array_push($this->filesSuffix, $suffix);    if(is_array($suffix))       $this->filesSuffix = array_merge($this->filesSuffix, $suffix); } public function addSearchDir($dir) {    if(is_string($dir))        $this->filesDir = array_push($this->filesDir, $dir);    if(is_array($dir))        $this->filesDir = array_merge($this->filesDir, $dir); } public static function setCacheFile($path) {    self::$cacheFile = $path; }  

No i trochę objaśnień:
addSuffix() - metoda odpowiedzialna za dodawanie sufiksów do tablicy. Czyli jeżeli wywołamy ją w taki sposób
$foo->addSuffix("interface");
parser będzie tworzył mapę z wszystkich plików które mają postać: foo.class.php i foo.interface.php (bo sufiks class jest już standardowo dodany). Można też jako argument dać oczywiście tablicę.
$foo->addSuffix(array("interface","foo","bar"));

addSearchDir() - tą metodą ustawiamy wszystkie katalogi, które mają być przeszukiwane. Przykład:
$foo->addSearchDir("/lib"); // lub tablica $foo->addSearch(array("/lib", "/classes"));

setCacheFile() - ustawianie ścieżki do zserializowanego pliku z 'mapą' wszystkich klas.
$foo->setCacheFile("/config/classespath.txt");  

No i przechodzimy do dwóch najważniejszych metod, odpowiedzialnych za parsowanie i ładowanie klas. Na początek parser:
public function parse() {    if(file_exists(self::$cacheFile)) {       unlink(self::$cacheFile);    }    foreach($this->filesDir as $dir) {       $dirs = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));       foreach($dirs as $file) {          $name = explode('.', $file->getFilename());          if(in_array($name[1], $this->filesSuffix) && !$file->isDir()) {             $data = $name[0] . "|" . $file->getPathname();             $handle = fopen(self::$cacheFile, "a");             fwrite($handle, serialize($data));          }       }    } }  
Na początku usuwamy plik z mapą jeżeli istnieje. Idziemy po elementach tablicy $filesDir i dla każdego z nich wywołuje iteratory:
$dirs = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
I znów pętelka, tym razem już z niej mamy poszczególne pliki, które trzeba sprawdzić czy pasują do 'wzoru' :) Najpierw przez explode rozkładamy nazwę pliku na części pierwsze i sprawdzamy czy sufiks pliku znajduje się w tablicy $filesSuffix i czy bieżąca lokalizacja nie jest katalogiem. Do tego wykorzystujemy metodę DirectoryIterator zwącą się isDir()
 $name = explode('.', $file->getFilename());     if(in_array($name[1], $this->filesSuffix) && !$file->isDir()) {

Jeżeli wszystko jest tak jak chcemy, składamy dane do zapisania do kupy:
$data = $name[0] . "|" . $file->getPathname();

$name[0] jest to nazwa klasy bez sufiksu. $file->getPathname(), która jest znów metodą DirectoryIterator'a zwraca nam pełną ścieżkę do pliku. Potem oczywiście zapisujemy to w postaci zserializowanej:
            $handle = fopen(self::$cacheFile, "a");             fwrite($handle, serialize($data));          }       }    } }

Metoda load() jako druga najważniejsza, będzie ładować nam wszystkie klasy, interfejsy, itd.
public static function load($className) {    $handle = fopen(self::$cacheFile, "r");    $read = fread($handle, filesize(self::$cacheFile));    $files = explode(";", $read);    foreach($files as $file) {       $file = unserialize($file);       $file = explode("|", $file);       if($className == $file[0]) {          require_once"$file[1]";       }    } }

Na początku oczywiście otwieramy plik z mapą i wkładamy zawartość do zmiennej. Dalej 'wypakowujemy' wszystko tablicy i za pomocą pętli foreach 'idziemy' po kolejnych elementach. W pętli stosujemy unserialize() i rozkładamy string do tablicy, w której $file[0] to nazwa klasy a $file[1] to ścieżka do niej.
   foreach($files as $file) {       $file = unserialize($file);       $file = explode("|", $file)
i sprawdzając czy nazwa klasy podanej jako argument metody jest równa nazwie klasy w kolejnej iteracji pętli, ładujemy plik:
      if($className == $file[0]) {          require_once"$file[1]";       }    } }

Na końcu jeszcze tylko
spl_autoload_register("smAutoloader::load");

I mamy działającą klasę Autoloadera :)

W takim rozwiązaniu, wszystkie pliki będą musiały mieć nazwę taką samą jak klasa wewnątrz nich, czyli plik o nazwie np: smRouter.class.php, będzie musiał zawierać klasę o nazwie smRouter. W tej wersji brakuje też wyrzucania wyjątków przy błędach czy chociażby metody, która będzie pomijać podane katalogi za pomocą wyrażenia regularnego (np katalogi SVNa), ale to już każdy z Was może dopisać samemu.

Teraz przykładowe wywołanie parsera, które trzeba będzie robić za każdym razem, kiedy do systemu wejdą nowe klasy, tak, aby mapa była aktualna:
$foo = new smAutoloader; $foo->setCacheFile("./config/classespath.txt"); $foo->addSearchDir("./lib"); $foo->addSuffix("interface"); $foo->parse()

Permalink | Leave a comment  »