Weblabor

Egyke (singleton) ősosztály írása PHP-ben nem is olyan egyszerű, mint elsőre gondolná az ember. Több buktatója is van az ilyen osztály létrehozásának, ezért gondoltam, hogy írok róla pár sort.

Elég sűrűn használom az egyke mintát a most leírt örökléssel. Jobb szeretem így, mint gyár (factory) mintával kombinálva, persze ízlések és pofonok. Az örökléses megoldásnak annyi a hátulütője, hogy nem lehet szabadon megválasztani az ősosztályt, mindig az egyke (vagy annak leszármazottja) kell, hogy legyen.

Az egyik buktató amibe beleütközik az ember az osztály létrehozásakor, hogy a ReflectionClass úgy működik, mintha mi írtuk volna PHP-ben. Ha például reflectionnel akarunk elérni osztályon belülről egy privát metódust, akkor hibát dob. Ez nem túl szerencsés, mert a call_user_func() és call_user_func_array() leváltására teljesen jó lenne a reflection, viszont ilyen jogkörökkel használhatatlan.

Konkrétan az új példány paraméterezésénél lenne a reflectionre szükség. A problémát sajnos nem lehet megoldani, a konstruktort meg nem lehet publicra tenni, mert akkor az instance osztályfüggvényen kívülről is lehetne példányosítani.

class A
{
	static public function instance()
	{
		$reflection=new ReflectionClass(__CLASS__);
		$reflection->newInstanceArgs(array());
	}
	protected function __construct(){}
}
A::instance(); //Fatal Error

A probléma sajnos megoldhatatlan, a PHP fejlesztői nem tartják hibának, így marad a paraméterek nélküli példányosítás.

A másik buktató a statikus tulajdonságok és függvények öröklésével kapcsolatos. Ha egy statikus függvényt a szülőből örököl egy osztály, akkor abban a statikus változók a szülő statikus változóira mutatnak. A PHP fejlesztői szerint ez teljesen rendben van, szerintem nem.

In fact static method calls are resolved at compile time. When using an explicit class name the method is already identified completely and no inheritance rules apply.

Itt sem érdemes meddő vitát folytatni, ez van, ezt kell szeretni.

class A
{
	static public $i=0;
	static public function i()
	{
		self::$i=1;
	}
}
class B extends A{}

A::i();
echo 'A::$i='.A::$i; //A::$i=1
echo '<br>';
echo 'B::$i='.B::$i; //B::$i=1 (0 helyett)

Ez a probléma hál' Istennek áthidalható úgy, hogy csinálunk egy mapet azokkal az osztályokkal és példányokkal, amiket vissza akarunk hívni az instance osztályfüggvény hívásakor. A leszármazottban az instance hívásakor a mapet az ősosztályból fogja lekérni az értelmező.

abstract class Singleton
{
	static protected $map=array();
	final static public function instance()
	{
		if (func_num_args())
		{
			throw new Exception('Singleton contructors cannot have arguments.');
		}
		$class=get_called_class();
		if (!isset(self::$map[$class]))
		{
			self::$map[$class]=new $class();
		}
		return self::$map[$class];
	}
	protected function __construct()
	{}
	final protected function __clone()
	{}
}

class A extends Singleton
{}

class B extends Singleton
{}

class C extends A
{}

var_dump(A::instance());
var_dump(B::instance());
var_dump(C::instance());

Akkor sincs nagy gond, ha a PHP fejlesztői megoldják a statikus öröklődést. Annyi történik majd, hogy minden leszármazott osztály kap egy saját tömböt, amiben csak a saját példánya lesz benne.