Singleton, Registry map

Ostatnio przeglądałem forum.php.pl i znalazłem kilka postów, które dały mi do zrozumienia, że część społeczności nie potrafi używać, lub w ogóle nie wie czym jest singleton. Jako, że staram się pomagać bliskim mi w mojej branży ludziom o ile pozwala mi na to czas i ochota, postaram się wyjaśnić prostymi słowami czym jest i jak uzywać singletona. W artykule poruszone jest wiele problemów, np dziedziczenie songletona wraz z przedstawianymi rezultatami działań (unikatowe identyfikatory instacji klas). Przedstawiłem wzorzec registry, zapraszam do lektury.

1. Czym jest singleton – teoria

Singleton to pojedyncza instacja klasy, mówiąc szerzej: dostępna w obrębie całej aplikacji w postaci jednego egemplarza, aby nie tworzyć cały czas nowej kopii obiektu operatorem new i korzystać z nej tak, jak ze zwykłej klasy (a nie z metod statycznych). Cały singleton opiera się na tym, że klasa przechowuje instancję samej siebie w prywatnym statycznym atrybucie, który jest tworzony i pobieranie w metodzie statycznej zastępującej konstruktor. No właśnie… jak zablokować nasz konstruktor, aby nie można było posłużyć się klasą poprzez operator z zewnątrz metody uruchamiającej ową instancję. Jeżeli klasa nie będzie dziedziczona, metodzie konstrukcyjnej nadajemy prawa dostępu na „private‿, lub jeżeli chcemy dziedziczyć klasę „protected‿.

Dobrze zablokowaliśmy dostęp do klasy, teraz trzeba jakoś przechować obiekt i wywołać go. Do przechowania instancji klasy będzie służył jej wbudowany mechanizm polegający na zapisie egzemplarza do własnego prywatnego/chronionego atrybutu i wywołaniu przez metodę statyczną klasy zwracającą ową instancję. Zapoznamy się ze słowem kluczowym „instanceof‿, który sprawdza, czy obiekt jest instancją danej klasy.

2. Piszemy singleton niedziedziczony i dziedziczony – praktyka

Teorię znamy, czas na przyklad. Napiszemy klasę HelloWorld, która wykona songletona sama siebie:

[php]< ?php

final class HelloWorld
{
private static $_oInstance = null;
private function __construct()
{
}
public static function Instance()
{
if(!self::$_oInstance instanceof self)
self::$_oInstance = new self;
return self::$_oInstance;
}
public function SayHello()
{
echo 'Hello World!';
}
}

$oHello = HelloWorld::Instance();
$oHello->SayHello();

?>[/php]

Aby udowodnić, że operujemy na wzorcu singleton i dane zawarte w atrybutach nie zmieniają się, dopiszemy do metody konstrukcyjnej generowanie hashu, który zostanie zwrócony razem z napisem Hello World!. Przykład pierwszy udowodni, że korzystamy z tego samego egzemplarza klasy zwracając ten sam identyfikator (wykonany jednorazowo). Przykladem wykonania takiego identyfikatora może być na przyklad połączenie z bazą danych.

[php]< ?php

final class HelloWorld
{
private static $_oInstance = null;
private $_sUniqueIdentyficator = null;

private function __construct()
{
$this->_sUniqueIdentyficator = md5( sha1( time() * rand(1, 999) ) );
}
public static function Instance()
{
if(!self::$_oInstance instanceof self)
self::$_oInstance = new self;
return self::$_oInstance;
}
public function SayHello()
{
echo ‘Hello World! ID: ‘ . $this->_sUniqueIdentyficator;
}
}

$oHello1 = HelloWorld::Instance();
$oHello1->SayHello();

$oHello2 = HelloWorld::Instance();
$oHello2->SayHello();

$oHello3 = HelloWorld::Instance();
$oHello3->SayHello();

?>[/php]

Aby udowodnić, że identyfikator zmienia się bez użycia wzorca singleton, napisałem przykład bez uzycia singletona. Poniższy przykład zwróci różne klucze.

[php]< ?php

final class HelloWorld
{
private $_sUniqueIdentyficator = null;

public function __construct()
{
$this->_sUniqueIdentyficator = md5( sha1( time() * rand(1, 999) ) );
}
public function SayHello()
{
echo ‘Hello World! ID: ‘ . $this->_sUniqueIdentyficator;
}
}

$oHello1 = new HelloWorld;
$oHello1->SayHello();

$oHello2 = new HelloWorld;
$oHello2->SayHello();

$oHello3 = new HelloWorld;
$oHello3->SayHello();

?>[/php]

Dobrze, teraz zajmiemy się dziedziczeniem metod oraz instancji singleton. Aby to zrobić, klasa zamiast słów kluyczowych private musi otrzymać uprawnienia protected. Stwórzmy pattern, który udowodni nam taką możliwość:

[php]< ?php

class HelloWorld
{
protected static $_oInstance = null;
protected $_sUniqueIdentyficator = null;

protected function __construct()
{
$this->_sUniqueIdentyficator = md5( sha1( time() * rand(1, 999) ) );
}
public static function Instance()
{
if(!self::$_oInstance instanceof self)
self::$_oInstance = new self;
return self::$_oInstance;
}
public function SayHello()
{
echo ‘Hello World! ID: ‘ . $this->_sUniqueIdentyficator;
}
}

class HelloWorldChildren extends HelloWorld
{
// …
}

$oHello1 = HelloWorld::Instance();
$oHello1->SayHello();

$oHello2 = HelloWorld::Instance();
$oHello2->SayHello();

$oHello3 = HelloWorldChildren::Instance();
$oHello3->SayHello();

$oHello4 = HelloWorldChildren::Instance();
$oHello4->SayHello();

?>[/php]

Jak widzimy dzieci otrzymały instncję wcześniej stworzonego rodzica. UWAGA: Jeżeli najpierw zadeklarujemy dziecko, wówczas rodzic nie będzie miał dostępu do jego instancji.

3. Registy – teoria

Registry to nic innego jak zbiór instancji klas w klasie. Mapa registry to zapisywanie instancji klasy pod pewnym identyfikatorem, po czym wybieranie DOKſADNIE takiej samej instacji jaka została zapisana w dowolnym momencie działania aplikacji. Co należy zrobić? Klasa registy mus posiadać atrybut statyczny prywatny, który będzie przechowywał tablicę o wzorze: Identyfikator => Obiekt klasy. Metoda Registry() będzie pobierała instancję zapisaną pod pewnym kluczem, a metoda Register() będzie rejestowała obiekty pod określonym identyfikatorem.

4. Zastosowanie Registry Map – praktyka:

Założenia znamy, są bardzo łatwe, zabierzmy się za sam kod:

[php]< ?php

final class MyRegistry
{
private static $_aRegistry = array();

public static function Register($sInstanceName, $oInstanceObject)
{
if(!is_object($oInstanceObject))
throw new Exception('Only objects may be in registry map!');
if(is_object(self::$_aRegistry[$sInstanceName]))
throw new Exception('Some object has been registered at name "' . $sInstanceName . '"!');
self::$_aRegistry[$sInstanceName] = $oInstanceObject;
return self::$_aRegistry[$sInstanceName];
}
public static function Registry($sInstanceName)
{
if(!is_object(self::$_aRegistry[$sInstanceName]))
throw new Exception('No object registered at name "' . $sInstanceName . '"!');
return self::$_aRegistry[$sInstanceName];
}
}

final class HelloWorld
{
private $_sUniqueIdentyficator = null;
public function __construct()
{
$this->_sUniqueIdentyficator = md5( sha1( time() * rand(1, 999) ) );
}
public function SayHello()
{
echo ‘Hello World! ID: ‘ . $this->_sUniqueIdentyficator;
}
}

$oHello1 = new HelloWorld;
MyRegistry::Register(‘MyHello1′, $oHello1);
$oHello1->SayHello();

unset($oHello1);

$oHello1 = MyRegistry::Registry(‘MyHello1′);
$oHello1->SayHello();

?>[/php]

W powyższym przykladzie użyliśmy naszej klasy HelloWorld bez użycia singletona. Stworzyliśmy egzemplarz klasy, wywołaliśmy ID, po czym zarejestrowaliśmy w Registry i usunęliśmy obiekt za pomocą unset(). Gdy wyciągamy instancję za pomocą naszego Regostry, okazuje się, że zawiera ona ten sam klucz, co instancja przed usunięciem. Stworzyliśmy coś w rodzaju „klona‿. Zamiast identyfikatora może być to wspomniane połączenie z bazą danych.

To by było na tyle, z tego miejsca pozdrawiam wszystkich programistów oraz ekipę php.pl, 3mcie się :), Athlan