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

[hawk]

Problem stary jak świat: system wymaga włączenia sporej liczby plików i zarządzanie tym jest upierdliwe. Do tego nie należy włączać więcej kodu niż potrzeba, a najlepiej zrobić jakieś lazy load.

Oczywiście, technik jest wiele:

1) require_once rozsiane po plikach, najlepiej poprzedzone jakąś stałą, np. require_once ROOT_DIR . '/foo/Foo.class.php';

2) Prado: deklarujemy namespacy - np. za pomocą funkcji using(), co dodaje nam ścieżki do include_path, a potem niech php znajdzie klasę.

3) Autoloader + mapa (nazwa klasy => ścieżka do pliku); autoloader wczytuje mapę i na jej podstawie jest w stanie znaleźć każdą klasę

Są jeszcze jakieś inteligentne sposoby? Dobry mechanizm powinien być odporny na "przemeblowanie" struktury plików (np. chcemy połączyć kilka klas w jeden plik).

BTW, włączanie plików bez klas (tylko funkcje i kod) jest gorsze, bo nie ma tego czegoś, czego można szukać po plikach... kolejna zaleta OOP? (IMG:http://forum.php.pl/style_emoticons/default/winksmiley.jpg)

[chmolu]

Rozwiązanie z generowaniem mapy przez skanowanie katalogów wydaje się najlepsze. Jednak sposób Vengeance'a nie jest zbyt efektywny. Wymaga wczytania zawartości każdego pliku z osobna i sprawdzania, czy zawiera on jakieś klasy. Może jest to bardziej elastyczne, gdy mamy po kilka klas w jednym pliku, ale ja to zrobiłem inaczej.

U mnie każda klasa jest w osobnym pliku. Nazwa pliku zawierającego definicję klasy lub interfejsu kończy się na .class.php lub interface.php. I tylko takie pliki są ładowany do mapy.

Wycinki kodu z mojego frameworka:

[PHP] pobierz, plaintext 
<?
  /**
   * Checks whether the specified path exists.
   * If the directory is not found, it'll try to create one.
   *
   * @param  string $dirname 
   * @return void
   */
  function ensure_directory_exists($dirname)
  {
	  $dirname = substr($dirname, strlen(APP_DIR));
 
	  $sub_dirs = explode('/', $dirname);
	  $path = '';
	  foreach ($sub_dirs as $dir)
	  {
		  $path .= $dir . '/';
		  if (!file_exists($path))
		  {
			  if (!@mkdir($path, 0777))
			  {
				  throw new DaeronException('Could not create a directory \"' . $path . '\"');
			  }   
		  }
	  }
  }  
 
  /**
   * Writes the supplied content to a file.
   *
   * @param  string $filename Name of a file to write to.
   * @param  mixed  $content  Data to write to a file.
   * @return void
   */  
  function file_write($filename, $content)
  {
	  ensure_directory_exists(dirname($filename));
	  $fp = @fopen($filename, 'w');
	  if($fp)
	  {
		  @fputs($fp, $content, strlen($content));
	  }
	  @fclose($fp);	  
  }  
 
  class Autoloader
  {
	  /**
	   * Map of class names and their localization. 
	   *
	   * @var array
	   * @static 
	   */
	  private static $map = null;
 
	  /**
	   * Loads specified class.
	   *
	   * @param  string $class_name
	   * @return void 
	   */	  
	  public static function load($class_name)
	  {
		  $cached_map = APP_DIR . '/var/cache/autoload.php';
		  if (!is_readable($cached_map))
		  {
			  self::generateMap();
		  }
 
		  if (!isset(self::$map)) require_once $cached_map;
 
		  $class_name = strtolower($class_name);
		  if (!isset(self::$map[$class_name]))
		  {
			  throw new Exception('Unknown class ' . $class_name);
		  }
 
		  require_once self::$map[$class_name];
	  }
 
	  /**
	   * 
	   * 
	   *	 
	   */
	  private static function generateMap()
	  {
		  self::$map = array();
 
		  $cached_map = APP_DIR . '/var/cache/autoload.php';
 
		  self::scan(DAERON_DIR);
		  self::scan(APP_DIR);
 
		  $compiled = &#092;"<?phpn\";
		  $compiled .= 'self::$map = ' . var_export(self::$map, true) . &#092;"n?>\";
 
		  file_write($cached_map, $compiled);		   
	  }	  
 
	  /**
	   * 
	   * 
	   *	 
	   */
	  private static function scan($dir)
	  {
		  $match = array();
		 
		  $rd = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir), true);
		  foreach ($rd as $file)
		  {
			  if(!is_file($file->getPathname())) continue;
 
			  if (preg_match('/([a-z0-9_]+).(class|interface).php$/i', $file->getPathName(), $match))
			  {
				  self::$map[strtolower($match[1])] = $file->getPathName();	
			  }
		  }		 
	  }
  }
   
  function __autoload($class_name)
  {
	  Autoloader::load($class_name);	
  }
?>
[PHP] pobierz, plaintext 

Porównanie szybkości (dla stosunkowo małej liczby plików):
- czytanie mapy z generowaniem: 35,67 ms
- czytanie z cache'owanej mapy: 00,57 ms

Kod Vengeance'a:
- czytanie mapy z generowaniem: 129.35 ms

A czytanie z cache wygląda identycznie (IMG:http://forum.php.pl/style_emoticons/default/smile.gif)

Ten post edytował chmolu 13.03.2005, 12:41:45