Metody magiczne

W każdej klasie możemy utworzyć szereg metod, które będą traktowane w specjalny sposób przez PHP. Zwyczajowo nazywa się je metodami magicznymi, gdyż wywołuje je interpreter w odpowiedzi na różne zdarzenia, a nie programista. Można je poznać po tym, że ich nazwy zaczynają się od dwóch podkreśleń, co oznacza, że dwie takie metody powinniśmy już kojarzyć. Są to __construct() oraz __destruct() wywoływane automatycznie przy tworzeniu i niszczeniu obiektu. To jednak tylko czubek góry lodowej.

Dostęp do pól obiektu

Gdy próbujemy odwołać się do nieistniejącego pola klasy, PHP zazwyczaj generuje komunikat E_NOTICE. Dzięki metodom __get() oraz __set() możemy zaprogramować własną akcję i wykorzystać to do swoich celów.

Przyjrzyjmy się naszemu stale ulepszanemu systemowi konfiguracji. Odwoływanie się do opcji konfiguracyjnych przez $config->get('nazwa') jest odrobinę niewygodne. Dlatego zasymulujemy, że poszczególne opcje są dostępne jako pola klasy. Poniżej pokazany jest fragment klasy Config z nową metodą:

get($name); } // end __get();

// pozostała część klasy } // end Config;

$config = new Config; $config->addLoader(new FileConfigLoader('./config.ini.php')); echo $config->websiteTitle;

Metoda __get wywoływana jest w podświetlonej linijce, gdy próbujemy dostać się do nieistniejącego pola. PHP pobiera jej wynik i zwraca skryptowi jako jego wartość. Jednocześnie ponieważ nie chcemy, aby ktoś modyfikował konfigurację, nie udostępniamy metody __set() wywoływanej przy próbie przypisania nieistniejącemu polu jakiejś wartości.

Wywoływanie metod

Magiczne metody potrafią także przechwytywać wywołania metod. Zasada działania jest analogiczna - jeśli PHP stwierdzi, że nie istnieje metoda o podanej nazwie, ale w klasie zdefiniowana jest operacja __call(), zrzuca całą robotę na nią. __call() dostaje dwa argumenty: nazwę metody oraz tablicę argumentów, z którymi programista próbował ją wywołać. Wykorzystajmy to do stworzenia mechanizmu zdarzeń. Zasada działania jest bardzo prosta. Jak pamiętamy, klasy posiadają pewne zachowania reprezentowane poprzez metody. Chcielibyśmy mieć możliwość rejestrowania dodatkowych czynności do wykonania, gdy zajdzie określone zdarzenie. Możemy dodatkowe czynności zapisać w postaci specjalnej klasy, której obiekt "wstrzykniemy" do właściwego obiektu. Znajdujący się tam kod sam zadba o to, aby czynności zostały wykonane.

Opis ten brzmi nieco abstrakcyjnie, ale spójrzmy na przykładowe zastosowanie. Mamy klasę User, która m.in. potrafi dodawać nowych użytkowników do naszej aplikacji. Chcemy, aby dodanie użytkownika z poziomu panelu administracyjnego zostało odnotowane w logach. Nic prostszego - piszemy klasę, w której implementujemy metodę onAdd(), która będzie zapisywać informację do logów, a utworzony od niej obiekt dodamy do obiektu User już w trakcie działania skryptu, gdy zorientujemy się, że wyświetlamy panel administracyjny. Nie musimy modyfikować kodu oryginalnej klasy. Co więcej, gdybyśmy chcieli wykonać przy tej okazji jeszcze inne czynności, wystarczy że napiszemy jeszcze więcej klas zdarzeń i podepniemy je pod User.

Najpierw zapoznajmy się z interfejsem EventDispatcher. Musi go implementować każda klasa, która będzie chciała obsługiwać zdarzenia. Przy okazji napiszemy też korzystającą z niego klasę User:

_handlers[] = $handler; } // end addEventHandler();

public function addUser($login, $password)

foreach($this->_handlers as $handler)

$handler->onAdd($login, $password);

echo 'Użytkownik '.$login.' został dodany'; } // end addUser(); } // end User;

Teraz pora na klasę EventHandler tworzącą podstawę dla wszystkich klas obsługi zdarzeń, jakie będziemy chcieli stworzyć. Zauważmy, że nie zawsze będziemy chcieli implementować wszystkie możliwe zdarzenia. Klasa User na razie obsługuje jedynie onAdd(), ale przecież w rzeczywistej aplikacji może tez posiadać zdarzenia onEdit(), onDelete() i inne. Po co tworzyć puste implementacje, kiedy można wszystko elegancko przechwycić poprzez __call() i odpowiednio przetworzyć przed użyciem? Ponadto, przed wywołaniem zdarzenia warto sprawdzić, czy spełnione są wszystkie warunki. EventHandler będzie zawierać dodatkową metodę _checkConditions(), która musi zwrócić true, aby wyrazić zgodę na wykonanie zdarzenia.

_checkConditions())

$name = '_'.$name.'Event'; if(method_exists($this, $name))

$this->$name($arguments);

} // end __call(); } // end EventHandler;

Zwróćmy uwagę na linijkę 17 - oto odpowiedź, dlaczego nazwa pola klasy nie jest poprzedzona znakiem dolara. W tym miejscu PHP odczytuje nazwę metody do wywołania wprost ze zmiennej, dzięki czemu możemy dynamicznie decydować, co wykonać! Oczywiście warto wcześniej upewnić się, że w ogóle posiadamy odpowiednią metodę do obsługi zdarzenia i temu służy funkcja method_exists(). Zauważmy, że jeśli nie chcemy obsługiwać zdarzenia, nie grozi to nam teraz żadnymi konsekwencjami w postaci Fatal error. Wszystko przechwyci __call() i jeśli stwierdzi, że nie potrafi zająć się zdarzeniem, po prostu je zignoruje.

Poniżej pokazujemy przykładowe zastosowanie. Stworzymy sobie dwie klasy do obsługi zdarzeń. Pierwsza będzie rejestrować fakt dodania nowego użytkownika, a druga pomoże nam w organizacji konkursu, gdzie pięciu losowo wybranych nowo zarejestrowanych użytkowników wygrywa nagrodę.

<?php class LoggingEvent extends EventHandler { protected function _onAddEvent($arguments)

$f = fopen('./logs/user_log.log', 'a'); fwrite($f, date('r').': '.$arguments.' zostal zarejestrowany.'); fclose($f); } // end _onAddEvent(); } // end LoggingEvent;

class CompetitionEvent extends EventHandler { protected $_winners = 0;

protected function _checkConditions()

// sprawdzmy, czy w ogole mozna jeszcze wygrywac. $this->_winners = trim(file_get_contents('./winner_count.txt')); return ($this->_winners '; file_put_contents('./winner_count.txt', ++$this->_winners);

} // end _onAddEvent(); } // end CompetitionEvent;

$user = new User;

// Tworzymy normalnie, bez zadnych bajerow. $user->addUser('wacek', 'foo');

// Teraz bedziemy rejestrowac fakt utworzenia w logach. $user->addEventHandler(new LoggingEvent); $user->addUser('franek', 'bar');

// A ten uzytkownik wezmie udzial w konkursie. $user->addEventHandler(new CompetitionEvent); $user->addUser('jacek', 'joe');

Oto potęga programowania obiektowego - przy odrobinie pomysłowości możemy rozszerzać istniejące klasy bez zmiany ani jednej linijki ich kodu. Wszystko odbywa się w pełni dynamicznie, a pomogła nam w tym magiczna metoda __call(). W ramach ćwiczenia przyjrzyj się dokładnie kodowi do losowania zwycięzców. W pewnej sytuacji nie zadziała on prawidłowo. Czy potrafisz powiedzieć kiedy i dlaczego?

Klonowanie obiektów

Jak pamiętamy, operator przypisania kopiuje jedynie referencję do obiektu. Są jednak sytuacje, gdy chcielibyśmy fizycznie skopiować cały obiekt. Najprostsze wyjście to wykorzystanie operatora clone:

$kopia = clone $obiekt;

Jednak nasz obiekt może mieć otwarte różne zasoby (np. pliki) lub przechowywać referencje do innych obiektów. Standardowe klonowanie po prostu skopiuje same referencje, dlatego musimy mieć możliwość "poprawienia" sklonowanej kopii tak, by była ona w pełni samodzielna wtedy, gdy tego potrzebujemy. Tu do akcji wkracza magiczna metoda __clone(). Gdy znajduje się ona w klasie, PHP wywołuje ją tuż po sklonowaniu obiektu, dzięki czemu ma ona możliwość wprowadzenia poprawek.

Aby zademonstrować działanie wspomnianej funkcji, napiszemy implementację struktury danych zwanej kolejką. Struktury danych są jednym z filarów algorytmiki. Służą do przechowywania dowolnie dużej liczby informacji ograniczonej wyłącznie rozmiarami pamięci, oferując dostęp do nich w pewien ściśle określony sposób. Działanie kolejki jest podobne do kolejek w sklepie - klienci przychodzą z jednej strony, a z drugiej są obsługiwani. W informatyce klientów zastępują dane dodawane z jednej strony, a zdejmowane z drugiej. Będziemy potrzebować dwóch klas: pierwszej do reprezentowania pojedynczego elementu kolejki oraz drugiej do zarządzania całą strukturą. Nas szczególnie będzie interesować proces klonowania. Klonując kolejkę, musimy także sklonować wszystkie obiekty reprezentujące jej elementy, dlatego musimy skorzystać z magicznej metody __clone().

Zaczynamy od napisania klasy pojedynczego elementu kolejki. Będzie on przechowywać informację oraz referencję do następnego elementu w kolejce. Następny element może mieć namiary na kolejny i tak dalej, aż do końca - tworzy się w ten sposób łańcuch elementów prowadzących od pierwszego do ostatniego czekającego elementu.

_data = $data; } // end __construct();

public function getData()

return $this->_data; } // end getData();

public function setNext(QueueElement $next)

$this->_next = $next; } // end setNext();

public function getNext()

return $this->_next; } // end getNext(); } // end QueueElement;

Nasza klasa składa się praktycznie wyłącznie z getterów i setterów. Nie ma tutaj jeszcze operacji klonowania, ponieważ na tym poziomie nie mamy jeszcze nic do zrobienia. Dopiero główna klasa kolejki zawierać będzie całe sterowanie. Znajdować się tu będą namiary na pierwszy i ostatni element kolejki tak, aby można było się do nich szybko dostać podczas odczytu lub zapisu.

_first === null)

$this->_first = $this->_last = new QueueElement($data);

else // Coś jest w kolejce, doklejamy się do ostatniego.

$element = new QueueElement($data); $this->_last->setNext($element); $this->_last = $element;

} // end enqueue();

public function dequeue()

if($this->_first === null)

throw new UnderflowException('Nie można pobrać elementu z pustej kolejki.');

$dequeued = $this->_first; $this->_first = $this->_first->getNext();

if($this->_first === null)

$this->_last = null;

return $dequeued->getData(); } // end dequeue();

public function __clone()

// Zalozmy, ze sklonowana kolejka jest pusta $top = $this->_first; $this->_first = $this->_last = null;

// Przejedźmy się po dotychczasowej kolejce i skopiujmy // wszystkie jej elementy while($top != null)

$this->enqueue($top->getData()); $top = $top->getNext();

} // end __clone(); } // end Queue;

Przykładowe działanie:

enqueue(5); $queue->enqueue(4); $queue->enqueue(3);

$cloned = clone $queue; $cloned->enqueue(2);

try { while(true)

echo $queue->dequeue().'';

catch(UnderflowException $exception) { // pusto }

W przykładzie dodajemy do kolejki trzy elementy, a następnie ją klonujemy i dorzucamy do kopii jeszcze jeden element. Na końcu wyświetlamy elementy oryginału. Gdyby podczas klonowania pozostawić niezmienione elementy, wyświetliłyby nam się cztery liczby. Elementy kolejki są obiektami, zatem w skrypcie dostępne są jedynie referencje do nich. Operacja enqueue() sprawiłaby, że czwarta liczba zostałaby doczepiona do wspólnego elementu, a co gorsza - oryginał wcale by o tym nie wiedział! Mogłoby to doprowadzić do poważnych błędów w działaniu obu list. Zakomentuj operację __clone() i prześledź wszystko samodzielnie.

Przy implementowaniu własnej wersji __clone() musimy pamiętać, że operuje ona na już sklonowanym obiekcie, a nie na oryginale. Innymi słowy, PHP najpierw wykonuje dokładną kopię całego obiektu, a dopiero później wykonuje na niej __clone(), by pozwolić jej pozmieniać te rzeczy, które powinny być zmodyfikowane.

Serializacja obiektów

Pisząc w PHP nie musimy przejmować się, jak interpreter reprezentuje tablice i obiekty w pamięci komputera. Jednak zdarza się, że chcielibyśmy zapisać je w całości do pliku lub przesłać komuś przez sieć. Za przetłumaczenie złożonego typu do postaci tekstowej i złożenie z niej z powrotem oryginału po drugiej stronie odpowiada tzw. serializacja. Spróbujmy zobaczyć, jak ten proces przebiega:

'foo', 'bar' => 'bar', 'joe' => 'joe' );

// Sprawdźmy, jak wygląda tablica normalnie var_dump($array);

// Zserializujmy ją $serialized = serialize($array); echo $serialized.'';

// A teraz przywracamy oryginał