[PHP] pobierz, plaintext 
<?php
/**
 * Rozszerzalny singleton.
 *
 * <b>Użycie</b>
 * <ul><li>W każdej klasie pochodnej utwórz protected static $instance</li>
 * <li>Konstruktor kazdej klasy pochodnej musi byc chroniony lub prywatny</li></ul>
 */
class Singleton
{
   /** To jest do celow testowych */
   protected $nazwa;
   protected static $instance;
   protected function __construct()
   {
   }
   public static function get()
   {
      if (!(static::$instance))
      {
         $className = get_called_class();
         $className::$instance = new $className;
      }
      return static::$instance;
   }
   public function identify()
   {
      echo $this->nazwa;
   }
}
class Pierwsza extends Singleton
{
   public static $instance;
   protected function __construct()
   {
      $this->nazwa = "pierwsza";
   }
}
class Druga extends Singleton
{
   public static $instance;
   protected function __construct()
   {
      $this->nazwa = "druga";
   }
}
class Trzecia extends Druga
{
   public static $instance;
   protected function __construct()
   {
      $this->nazwa = "trzecia";
   }
}
$pierwsza = Pierwsza::get();
$druga = Druga::get();
$trzecia = Trzecia::get();
$trzecia->identify();
$pierwsza->identify();
$druga->identify();
?>
[PHP] pobierz, plaintext 

Jak go ulepszyc bym nie musial deklarowac w kazdej klasie public static $instance?

jesli usune deklaracje tych zmiennych statycznych z klas to wtedy tworzy mi singleton zamiast klasy tej co trzeba (ew w przypadku klasy trzecia utworzy mi klase druga).

Hmm no nie dziwne - jeśli nie dasz w każdej klasie $instance to będziesz się z każdej odwoływał zawsze do tego samego oto w sumie chodzi w staticach

Moim zdaniem powinno się dawać statyczne $intance dla każdej klasy - sama funkcja typu "getInstance" może być dziedziczona. To i tak mniej a na bank będzie działać.

Drugim rozwiązaniem jest zrobienie statycznej tablicy "instancji" - wtedy w get() odwołuj się do $instance[self::$nazwa] - To powinno troszkę pomóc i nie byłoby potrzeby dawać $instance w tych klasach.

ALBO:

Zupełnie inne podejście Po co robić rozszerzalny singleton, z którego musiała będzie dziedziczyć każda klasa by była singletonem...

Można zrobić inaczej Zróbmy tak by dowolna klasa mogła być traktowana jako singleton ;P Zróbmy fabrykę singletonów

[PHP] pobierz, plaintext 
class singleton
{
	protected static $instance = array();
 
        private function __construct() {}
 
	public static function getInstance($className)
	{
		if(!isset(self::$instance[$className]))
			self::$instance[$className] = new $className;
 
		return self::$instance[$className];
	}
}
 
 
class a
{
	public function identify() { echo 'jestem A!'; }
}
 
class b 
{
	public function identify() { echo 'jestem B!'; }
}
 
class c 
{
	public function identify() { echo 'jestem C!'; }
}
 
$a = singleton::getInstance('a');
$b = singleton::getInstance('b');
$c = singleton::getInstance('c');
 
$a->identify();
$b->identify();
$c->identify();
[PHP] pobierz, plaintext 

Zamiast używać wtedy a::getInstance(); używamy singleton::getInstance('a'); - to daje nawet więcej możliwości ;P

Co Ty na to?

Fabryka singletonow chyba nie zapewnia ze te klasy tworzone jako singletony maja tylko jedna instancje? wciaz mozna je utworzyc konstruktorem.

fabryki singletonow uzywam :] dla klas gdzie musi byc np. po jednej instancji singletona dla kazdego ID, wtedy tez robie taka tablice jak ty. Tylko ze wtedy ta fabryka singletonow jest definiowana w ciele tej samej klasy ktorą zwraca wiec moge zrobic chroniony konstruktor.

Myslalem nad czyms zeby tworzyc static protected $instance zaraz przed wywolaniem konstruktora w singletonie, jakos dynamicznie, ale z tego co widze nie da się.

tablica statyczna $instance chyba jeszcze bardziej spowolni ten singleton bo za kazdym razem trzeba bedzie wywołac funkcje get_called_class.

skoro nie ma lepszego rozwiazania to bede dodawal singletony recznie