Włączanie plików + autoloader, chętnie bym posłuchał ciekawych pomysłów Opcje

[DjKermit]

Witam.
Ja wykombinowałem coś takiego:
Klasa:

[PHP] pobierz, plaintext 
<?php
class ClassLoader {
 
	/**
	 * Class file name sufix
	 *
	 * @var string
	 */
	private $file_sufix = '.class.php';
 
	/**
	 * Class map cache file name
	 *
	 * @var string
	 */
	private $cache_file_name = 'class_map_cache.ini.php';
 
	/**
	 * Path to cache file
	 *
	 * @var string
	 */
	private $cache_file_path = CONFIG_PATH;
 
	/**
	 * Root path of the project
	 *
	 * @var string
	 */
	private $base_path = BASE_PATH;
 
	/**
	 * Path to class files & packages
	 *
	 * @var string
	 */
	private $class_path = CLASS_PATH;
 
	/**
	 * All files paths from readed dir
	 *
	 * @var array
	 */
	private $readed_dir;
 
	/**
	 * Class map content
	 *
	 * @var array
	 */
	private $class_map;
 
	/**
	 * ClassLoader class instance
	 * 
	 * @var ClassLoader
	 */
	private static $instance;
 
 
 
 
	/**
	 * Constructor
	 * 
	 * @access private
	 */
	private function __construct() {
		$this->getClassMap();
	}
 
	/**
	 * Gets singleton instance of ClassLoader class
	 *
	 * @return ClassLoader
	 * @access public
	 */
	public static function getInstance() {
		if (is_null(self::$instance)) {
			self::$instance = new self;
		}//end if
		return self::$instance;
	}
 
 
 
 
	/**
	 * Loads single class or all class package 
	 *
	 * @param string $class_name - name of class to load
	 * @access public
	 */
	public function load($class_name) {
		$class_name = str_replace('.', DIRECTORY_SEPARATOR, $class_name);
		if (strstr($class_name, '*')) {	// load all class package
			$package_path = str_replace('*','', $class_name);
			$classes_arr = $this->getDirContents($this->class_path . $package_path);
			$this->loadClass($classes_arr);
		}else{	// load single class
			$path = $this->class_path . $class_name . $this->file_sufix;
			$this->loadClass(array($class_name => $path));
		}//end if
	}
 
 
	/**
	 * Serches for requested class in entire project and loads automaticly if found
	 *
	 * @param string $class_name
	 * @access public
	 */
	public function autoLoad($class_name) {
		if (array_key_exists($class_name, $this->class_map) && file_exists($this->class_map[$class_name])) {
			require_once($this->class_map[$class_name]);
		}else{
			$this->generateClassMap();
			if (array_key_exists($class_name, $this->class_map) && file_exists($this->class_map[$class_name])) {
				require_once($this->class_map[$class_name]);
			}else{
				throw new Exception('Class AutoLoad failed, file '. $class_name . $this->file_sufix .' not found');
			}//end if
		}//end if
	}
 
 
	/**
	 * Loads class
	 *
	 * @param array $path
	 * @access private
	 */
	private function loadClass($path) {
		foreach($path as $key => $val) {
			if (file_exists($val)) {
				require_once($val);
			}else{
				throw new Exception('Load class failed, file '. $key . $this->file_sufix .' not found');
			}//end if
		}//end foreach
	}
 
 
	/**
	 * Reads class map from cache
	 *
	 * @access private
	 */
	private function getClassMap() {
		if (file_exists($this->cache_file_path . $this->cache_file_name)) {
			$this->class_map = parse_ini_file($this->cache_file_path . $this->cache_file_name);
		}else{
			if (!is_dir($this->cache_file_path)) mkdir($this->cache_file_path);
		}//end if
		if (empty($this->class_map)) $this->generateClassMap();
	}
 
 
	/**
	 * Generates new class map
	 *
	 * @access private
	 */
	private function generateClassMap() {
		$this->getDirContents($this->base_path);
		$this->class_map = $this->readed_dir;
		$this->saveClassMap();
	}
 
 
 
	/**
	 * Saves class map into a cache file
	 *
	 * @access private
	 */
	private function saveClassMap() {
		$str = ";<?php die('Configuration file, all data confidential'); ?>rnrn";
		foreach($this->class_map as $key => $val) {
			$str .= $key .' = '. $val . "rn";
		}//end foreach
		file_put_contents($this->cache_file_path . $this->cache_file_name, $str);
	}
 
 
	/**
	 * Gets specified directory contents recursively
	 *
	 * @param string $path
	 * @return array
	 * @access private
	 */
	private function getDirContents($path) {
		$this->readed_dir = array();
		$this->readDir($path);
		return $this->readed_dir;
	}
 
 
	/**
	 * Reads specified directory & if file name contains "class" substring adds path to $readed_dir array
	 *
	 * @param string $path
	 * @access private
	 */
	private function readDir($path) {
		if ($handle = opendir($path)) {
			while (($file = readdir($handle)) !== false) { 
				if (is_file($path . $file) && strstr($file, 'class') && !strstr($file, 'ClassLoader')) {
					$this->readed_dir[str_replace('.class.php', '', $file)] = $path . $file;
				}else if (is_dir($path . $file) && $file != '.' && $file != '..') {
					$this->readDir($path . $file . DIRECTORY_SEPARATOR);
				}//end if
			}//end while
			closedir($handle);
		}//end if
	}
 
}
 
 
 
/**
 * Class auto loader
 * 
 * @param string $class_name
 */
function __autoload($class_name) {
	$cloader = ClassLoader::getInstance();
	$cloader->autoLoad($class_name);
}
 
?>
[PHP] pobierz, plaintext 

config.php

[PHP] pobierz, plaintext 
<?php
/** Base path */
define('BASE_PATH', dirname(__FILE__) .'/');
/** Path to config files */
define('CONFIG_PATH', BASE_PATH . 'config/');
/** Path to class and interface files */
define('CLASS_PATH', BASE_PATH .'classes/');
?>
[PHP] pobierz, plaintext 

możliwość ładowania klas trochę IMO przyjemniej niż require_once i klepanie ścieżki
możliwość ładowania paczek klas
autoloader
mapa klas keszowana w pliku ini
gdy w keszu nie ma żądanej klasy jest odświeżany i ponowna próba załadowania klasy, jeśli brak - wyjątek

Przykładowe wywołanie:

[PHP] pobierz, plaintext 
<?php
require_once('config.php');
require_once(CLASS_PATH .'core/ClassLoader.class.php');
$c_loader = ClassLoader::getInstance();
$c_loader->load('core.JakasKlasa'); // ładuje wskazaną klasę w "paczce" core
$c_loader->load('core.*'); // ładuje całą "paczkę" core
$c_loader->autoLoad('Smarty'); // odszukuje w całym projekcie wskazanej klasy i ładuje jeśli znajdzie
?>
[PHP] pobierz, plaintext 

metoda "load" ładduje klasy tylko ze zdefiniowanego w klasie ClassLoader katalogu i podżędnych
metoda "autoLoad" odszukuje żądaną klasę w całym projekcie

Ciekawi mnie co mądrzejsi będą mieli do powiedzenia.
Jeśli będzie się to do czegoś nadawało to można wrzucić do gotowych skryptów.

PS
Różnic przy tej klasie w porównaniu do ręcznego klepania require nie zauważyłem (ładowanie ok 20 klas).
//edit, no dobra tu troche przesadziłem, różnica jest
PS2
Jedyne wymaganie to nazwa pliku klasy powinna kończyć się ".class.php"

I co, nikt nic ?
Czyżby to było tak beznadziejne że nie warto się wypowiadać ?

Ten post edytował DjKermit 18.01.2007, 23:23:11

[hwao]

Bardzo ładna klasa, mi się podoba - jakbym stosował autoload to bym mógł ją spokojnie użyć.

Paser ini jest szybszy od serialize to też dodatkowy plus.

[PHP] pobierz, plaintext 
<?php
if (strstr($class_name, '*')) {	// load all class package
			$package_path = str_replace('*','', $class_name);
			$classes_arr = $this->getDirContents($this->class_path . $package_path);
?>
[PHP] pobierz, plaintext 

Czy w tym momencie nie było by lepiej użyć glob" title="Zobacz w manualu php" target="_manual() ?

[DjKermit]

Dzięki bardzo.

Czy w tym momencie nie było by lepiej użyć glob" title="Zobacz w manualu php" target="_manual() ?

Gdybym ładował pliki tylko ze wskazanego folderu to napewno tak, natomiast moim zamiarem było załadowanie plików/klas ze wskazanego folderu i wszystkich w nim zagłębionych.

[Turgon]

Hmm... Klasa ciekawa i sporo wyjaśnia Dzięki. ale ja mam odmienny problem. Jak się ma sprawa z autoloadem interfejsów? Jak nie ma jest uruchamiana funkcja autoload?

Ten post edytował Turgon 23.01.2007, 21:37:19

[bigZbig]

Ja nazywam swoje klasy zgodnie z konwencją przyjętą w Zend Frameworku. Oczywiście zamiast prefixu Zend daje swój. DjKermit - narzucając obowiązek nadawania klasom sufixu class.php ograniczasz swojego autoloadera jedynie do klas swojego autorstwa i klas, które zawarte są w plikach o nazwach stosujących tę konwencję. Gdzieś na początku tego tematu jest przykład bardziej uniwersalnego skanera.

Dlaczego serializujecie swoje mapy albo tez parsujecie do postaci pliku ini? Nie lepiej zapisywać je od razu jako tablicę i na dzień dobry tę tablicę includować?

[Turgon]

bigZbig: Podobno szybsze jest Ale zastanowię się nad tabliczką .

[DjKermit]

DjKermit - narzucając obowiązek nadawania klasom sufixu class.php ograniczasz swojego autoloadera jedynie do klas swojego autorstwa i klas, które zawarte są w plikach o nazwach stosujących tę konwencję. Gdzieś na początku tego tematu jest przykład bardziej uniwersalnego skanera.

No tak, ale nie piszę publicznego FW tylko pewien systemik, którego częścią jest ten loader, i nawet jeśli korzystam z cudzych klas to przerabiam je do swoich konwencji.

Dlaczego serializujecie swoje mapy albo tez parsujecie do postaci pliku ini? Nie lepiej zapisywać je od razu jako tablicę i na dzień dobry tę tablicę includować?

IMO gryzie się to z ideą OOP bo inkludująć tablicę masz ją w globalu a nie w klasie czy metodzie klasy, pozatym podobno ini jest najszybsze, no i jakoś tak czytelniej.

[bigZbig]

Jak init może być szybsze od tablicy skoro parsując plik init zmieniasz go właśnie w tablicę. Tablicę możesz wczytywać do klasy poprzez pobranie zawartości pliku, a nie poprzez includa. Możesz też wygenerować mapę w postaci instancji klasy implementującego interfejs ArrayAccess i wtedy includujesz gotowy obiekt. Myślę, że powinno zadziałać choć nie testowałem.

[LBO]

hmmm, parsowanie to parsowanie... i "na oko" parsowanie kodu php jest bardziej czasochłonne od pliku ini, który jest prostszy

[Turgon]

Ja zapisuje zserializowaną tablicę i działa sprawnie.

[Strzałek]

O autoloadzie oraz przykładowa klasa generująca mapę opublikowałem post na moim blogu: http://strzalek.net/blog/8/autoload-automa...-ladowanie-klas

[Sh4dow]

Mnie zastanawia ile samo odwolanie sie do funkcji autoload zajmuje czasu, Bo to jak zbudujesz ta funkcje tak bedzie ona sprawna.
Jesli autoload ma szukac po wszystkich katalogach to tak, bedzie to wolne. Ale jesli podzielic pliki na grupy, uzyc odpowiednich schematow w budowaniu nazw klas to powinno byc to sprawne.
Chyba ciekawszym sposobem to kozystanie z magazynu obiektow polaczonego z autoloaderem. Odwolujesz sie do magazynu po obiekt jakiegos modelu, ktory ma miec zawsze jedna instancje aby powiedzmy nie powielac polaczen z baza danych. Magazyn sprawdza czy istnieje juz taka instancja, jesli nie sprawsza czy istnieje taka klasa, jesli nie szuka w odpowiednim katalogu pliku o odpowiedniej nazwie, po czym ładuje plik, tworzy instancje i ja zwraca.
Czy to jest wygodne czy nie to juz inna sprawa ale mozna takie rozwiazanie zmodyfikowac i poszerzyc o inne funkcjonalnosci dostosowane do swoich potrzeb.

[Jarod]

Mnie zastanawia ile samo odwolanie sie do funkcji autoload zajmuje czasu,

Przyłączam się do pytania. Dzisiaj zauważyłem (i nie wiem dlaczego), że zaincludowanie klasy w głównym pliku/kontrolerze jest prawie 2x szybsze niż zainkludowanie w klasie statycznej. To tak przy okazji..

[athabus]

Wydaje mi się, że troszeczkę dochodzimy do granic abstrakcji :-)

90% wykonania funkcji autload to includowanie pliku i tego się nie ominie, niezależnie od tego czy includować będziemy za pomocą autoload czy ręcznie. Samo wywołanie tej funkcji zapewne "kosztuje" tyle co wywołanie każdej innej funkcji. Jest tak jak mówi Sh4adow - wszystko zależy od tego jak funkcja będzie napisana.

Ja osobiście robiłem testy na ZF - dopisałem do niego prosty autoloader dla własnych klas z mapą w pliku. Cóż mogę powiedzieć - funkcja zachowała się jak funkcja ;-) Wywołanie było dość kosztowne - ok 10-20% czasu wykonania skryptu jeśli dobrze pamiętam, ale to było spowodowane nie tyle samą funkcją co includowaniem samych plików. Wyników dokładnie nie pamiętam i nie mam ich już zapisanych, ale mój wniosek był mniej więcej taki:
- funkcja __autoload to dobre rozwiązanie i nie przynosi specjalnie dużych kosztów. Problem jaki się może pojawić to złe napisanie tej funkcji - np. brak mapy (czy jakiegoś jasnego układu) i każdorazowe przeszukiwanie folderów.

Ogólnie pytanie nie brzmi więc czy pisać autoloader tylko jak go napisać ;-) Ja z mojej metody jestem zadowolony. Dalsza optymalizacja, choć pewnie jest możliwa przy zwykłym projekcie nie ma większego sensu. Po prostu wzrost wydajności samego mechanizmu nawet o 100% nic konkretnego mi nie da, gdyż są to marginalne wartości.

[grzegorzr]

uuu, temat trochę się zakurzył postanowiłem go rozruszać poprzez YAML:
YAML = mapa
wymyśliłem sobie że w __autoloadzie mamy (fragmenty):

[PHP] pobierz, plaintext 
<?php
function __autoload($sClassName) {
  $Autoload = Autoload::getInstance();
  //podajemy sciezke do pliku .yml
  $Autoload->setMapFile($map_file);
  //  importujemy mape z formatu YAML do przyjaznej tablicy
  $Autoload->importMapFile();
  [...]
  //  w strategicznym miejscu pilnujemy swiezosc mapy
  //  jako argument podajemy czas unixowy $t
  //  jesli wartosc $t>$tobecny-$t_ostaniaAktualizacja->akutalizuj()
  if(!$Autoload->isFileMapFresh(100))
  {
	$Autoload->addDir($ib_dir);
	$Autoload->addDir($data_dir);
   // ta metoda najpierw przeszukuje wskazane katalogi
   // wybiera pliki z rozszerzeniem .php
   //  zapisuje do tablicy['map'][nazwaklasy] = sciezka pelna do klasy
   //  nastepnie robimy export do pliku .yml
	$Autoload->setClassMap();
  }
  [...]
  //  require teraz to juz przyjemnosc
  if (!require_once $Autoload->getClassPath($sClassName);)
	{
	  //jakis blad
	};
}
?>
[PHP] pobierz, plaintext 

w YAML pieknie to wyglada

[SQL] pobierz, plaintext 
map:
  [nazwaklasy]:
    path: [sciezka do klasy]
[SQL] pobierz, plaintext 

Ten post edytował grzegorzr 15.07.2007, 18:15:05

[Ludvik]

Chce Ci się pisać te mapy w YAML? Bo nie widzę sensu, żeby generować je automatycznie - parser YAML będzie wolniejszy od wczytania zserializowanej tablicy... A to, że ładniej wygląda, to drugorzędna sprawa w przypadku autoloadera. Z resztą, czy zaimportowanie folderów do przeszukania jest brzydkie? Moim zdaniem nie...

[deirathe]

[PHP] pobierz, plaintext 
<?php
function __autoload($classname){
	$path = "library".DIRECTORY_SEPARATOR."classes".DIRECTORY_SEPARATOR.str_replace("_", DIRECTORY_SEPARATOR , $classname).".class.php";
	if(!file_exists($path)){
		exit("Brak pliku: ".$path);
	}
	require_once($path);
	if(!class_exists($classname)){
		exit("Brak klasy: ".$classname);
	}
}
?>
[PHP] pobierz, plaintext 

A ja zawsze wykorzystywałem to:P kod nie jest długi, co o tym myślicie?

Ten post edytował deirathe 19.07.2007, 18:36:36

[athabus]

Ta funkcja wymaga aby wszystkie klasy były w jednym katalogu. Wydaje mi się, że w dyskusji chodzi raczej o rozwiązanie, które działa dla całej aplikacji. Gdy masz np. 20 katalogów z różnymi klasami to raczej nie ma sensu wykonywać tylu akcji plikowych i szukać w każdym katalogu danej klasy, także w średniej aplikacji to się raczej by nie sprawdziło.

[Turgon]

athabus: W takim przypadku mapy się wydają być jedynym sensownym wyjściem, z punktu estetyki i także wydajności.

[athabus]

wiem i sam właśnie map używam