przykład pierwszy

Poniżej prezentuję prostą klasę ImplementAction, która korzysta z omawianego przeze mnie wzorca (klasa abstrakcyjna Action). Popatrzmy na jej kod:

abstract class Action {

	abstract public function BeforeAction();

	abstract public function AfterAction();

	public function __construct () {
		$this->BeforeAction ();
	}

	public function __destruct() {
		$this->AfterAction ();
	}

}

class ImplementAction extends Action {

	public function BeforeAction() {
		echo __METHOD__;
	}

	public function AfterAction() {
		echo __METHOD__;
	}

	public function A () {
		echo __METHOD__;
	}

	public function B () {
		echo __METHOD__;
	}

}

$obj = new ImplementAction();
$obj->A();
$obj->b();

Na wyjściu otrzymamy:

Jak widać przy tworzeniu obiektu wywoływana jest metoda BeforeAction(), a w destruktorze AfterAction(). Oczywiście powyższy kod ma swoje wady i zalety. Zależą one jednak od wymogów tworzonego oprogramowania, zatem coś co dla jednych może być dużym plusem, dla innych staje się rozwiązaniem nie do przyjęcia. Najwyższy czas na przyjrzenie się bardziej zaawansowanemu modelowi użycia Intercepting Filter, dzięki któremu zwiększymy jego elastyczność i możliwości.

przykład drugi

// iterfejs dla filtrow
interface InterceptingFilter {

	public function doBefore();
	public function doAfter();

}

// klasa filtra
class FirstFilter implements InterceptingFilter {

	public function doBefore() {

		echo __METHOD__;

	}

	public function doAfter() {

		echo __METHOD__;

	}

}
// klasa filtra
class SecondFilter implements InterceptingFilter {

	public function doBefore() {

		echo __METHOD__;

	}

	public function doAfter() {

		echo __METHOD__;

	}

}
// klasa filtra
class AnotherFilter implements InterceptingFilter {

	public function doBefore() {

		echo __METHOD__;

	}

	public function doAfter() {

		echo __METHOD__;

	}

}
// abstrakcyjna klasa zajmujaca sie odpowiednim wywolywaniem
// filtrow
abstract class UseInterceptingFilter {

	private $filters = array();

	private function doBeforeActions() {

		foreach ($this->filters as $do)
			$do->doBefore();

	}

	private function doAfterActions() {

		foreach ($this->filters as $do)
			$do->doAfter();

	}

	public function __construct (array $filters = array()) {

		$this->filters = $filters;

		$this->doBeforeActions();

	}

	public function __destruct () {
		$this->doAfterActions();
	}

}

// klasa korzystajaca z filtrow
class Example extends UseInterceptingFilter {

	public function A() {

		echo __METHOD__;

	}

	public function B() {

		echo __METHOD__;

	}

}

// tworzymy przykladowe filtry
$filter1 = new FirstFilter();
$filter2 = new SecondFilter();
$filter3 = new AnotherFilter();

// filtry przekazywane w konstruktorze
$obj = new Example(array($filter1,$filter2,$filter3));
$obj->A();
$obj->B();

Na wyjściu dostajemy:

Aby dodać nowy filtr wystarczy napisać klasę implementującą interfejs InterceptingFilter. Natomiast klasy z nich korzystające dziedziczą po UseInterceptingFilter , a ów filtry są przekazywane jako tablica w konstruktorze.

Zachęcam więc do własnych eksperymentów, które doprowadzą do rozwiązań w pełni dostosowanych do stawianych przez Was wymagań.

praktyka

W PHP namespaces można tworzyć na dwa sposoby i oba zostały zaprezentowane poniżej:

namespace A;

function ShowMsg() {

	echo __FUNCTION__;

}

Albo tak:

namespace A {

function ShowMsg() {

	echo __FUNCTION__;

}

}

Jak widać na powyższych przykładach, przestrzeń konstruuje się z użyciem słowa kluczowego namespace, po czym określana jest jej nazwę (w tym wypadku A). Należy pamiętać, aby deklaracja ta znajdowała się na początku skryptu (przed nią może wystąpić tylko declare). Dozwolone jest też tworzenie kilku przestrzeni w jednym pliku, aczkolwiek rozwiązanie to nie jest zalecane:

namespace A ;

function ShowMsg() {

	echo __FUNCTION__;

}

namespace B ;

function ShowMsg() {

	echo __FUNCTION__;

}

Można również organizować pewnego rodzaju hierarchię, formując poziomy (sub-namespaces):

namespace Main\First ;

function ShowMsg() {

	echo __FUNCTION__;

}

namespace Main\First\One ;

function ShowMsg() {

	echo __FUNCTION__;

}

namespace Main\First\Two ;

function ShowMsg() {

	echo __FUNCTION__;

}

Zapewne zastanawiacie się jak wywoływać klasy, funkcje i stałe z różnych przestrzeni. Przełączanie się między nimi przypomina proces poruszania się po strukturze katalogów. Występuje tutaj pojęcie ścieżek względnych i bezwzględnych. Najprościej będzie to zrozumieć analizując prosty kod, zamieszczony poniżej:

// przestrzen A\First
namespace A\First {

	function ShowMsg () {
		// specjalna stala predefiniowana zawiera
		// przestrzen w ktorym sie znajduje struktura
		echo __NAMESPACE__;

	}
}

// przestrzen A\Second
namespace A\Second {

	function ShowMsg () {

		echo __NAMESPACE__;

	}
}

// przestrzen A
namespace A {

	// sciezki bezwzgledne
	\A\First\ShowMsg();
	\A\Second\ShowMsg();

	// sciezki wzgledne (wzgledem obecnej przestrzeni)
	First\ShowMSg();
	Second\ShowMSg();

	// jeszcze jeden sposob namespace to odwolanie
	// do aktualnej przestrzeni
	namespace\First\ShowMsg();
	namespace\Second\ShowMsg();

	// wywolywanie globalnych funkcji, klas i stalych
	echo \count(array(1,2,3));

}

// przestrzen "globalna"
namespace {

}

Oczywiście nie opisałem wszystkich możliwości namespaces w PHP. Zainteresowanych odsyłam TUTAJ.

Introspekcja w PHP

Po krótkim wstępie teoretycznym przechodzimy do praktycznego przykładu, wykorzystującego introspekcję. Na początku przykładowa klasa pełniąca rolę królika doświadczalnego.

class Rabbit {

	public $name;

	public function PrintClassName () {

		echo __CLASS__;

	}

	public function PrintRabbitName () {

		echo $this->name;

	}

}

Pobierzmy podstawowe informacje o tej klasie. Sposób pierwszy - na podstawie nazwy klasy:

var_dump (class_exists('Rabbit'));
var_dump (get_class_methods('Rabbit'));
var_dump (method_exists('Rabbit','PrintRabbitName'));
var_dump (property_exists('Rabbit','name'));

Sposób drugi - korzystając z instancji klasy:

$obj = new Rabbit();
var_dump (get_class_methods($obj));
var_dump (method_exists($obj,'PrintRabbitName'));
var_dump (property_exists($obj,'name'));

Omówmy użyte powyżej funkcje:

• class_exists(string $name) - zwraca bool informując czy klasa została zdefiniowana czy też nie. UWAGA! Funkcja posiada opcjonalny parametr, o którym można przeczytać w dokumentacji.
• get_class_methods(mixed $class) - zwraca array zawierającą wszystkie metody klasy przekazanej w parametrze (instancja lub jej nazwa). Jeśli wystąpił błąd funkcja zwróci NULL.
• method_exists(mixed $class, string $method) - zwraca bool informując czy istnieje metoda $method dla klasy przekazanej w parametrze $class (instancja lub jej nazwa).
• property_exists(mixed $class, string $property) - zwraca bool informując czy istnieje właściwość $property dla klasy przekazanej w parametrze $class (instancja lub jej nazwa).

Oczywiście to tylko wybrane funkcje. Zainteresowanych zapraszam TUTAJ. Źródło przykładu zamieszczonego w tym poście znajdziecie TUTAJ. O refleksji pisałem już trochę TUTAJ.

stan w praktyce

Przyjmijmy następujące założenie. Chcemy uzależnić wywoływanie kolejnych metod na obiekcie, na podstawie typu zmiennej (integer,boolean,itp.) wcześniej do niego przekazanej. Zatem chciałbym, aby do “obsługi” integer’a,boolean’a został delegowany odpowiedni, dedykowany obiekt. Spójrzmy na poniższy przykład:

interface Stan {

	public function CheckIt ($value);
	public function WriteMessage ();

}

Powyżej znajduje się interfejs dla klas (ich implementacja znajduje się poniżej), które będą obsługiwać poszczególne typy zmiennych. Metoda CheckIt($value) sprawdza typ przekazanego parametru a metoda WriteMessage() wypisze go na wyjściu.

class NoStan implements Stan {

	private $stan;

	public function __construct (UseStan $usestan) { 

		$this->stan = $usestan;

	}

	public function CheckIt ($value) {

		if (is_int($value))
			$this->stan->ChangeStan($this->stan->GetIntegerStan());
		elseif (is_bool($value))
			$this->stan->ChangeStan($this->stan->GetBooleanStan());
		elseif (is_string($value))
			$this->stan->ChangeStan($this->stan->GetStringStan());
	}

	public function WriteMessage () {

		echo 'Nie wywolano metody CheckIt()!';

	}

}

class IntegerStan implements Stan {

	private $stan;

	public function __construct (UseStan $usestan) { 

		$this->stan = $usestan;

	}

	public function CheckIt ($value) {

		echo 'Metoda CheckIt() byla juz wolana!';
	}

	public function WriteMessage () {

		$this->stan->ChangeStan($this->stan->GetNoStan());
		echo 'INTEGER';

	}

}

class StringStan implements Stan {

	private $stan;

	public function __construct (UseStan $usestan) { 

		$this->stan = $usestan;

	}

	public function CheckIt ($value) {

		echo 'Metoda CheckIt() byla juz wolana!';
	}

	public function WriteMessage () {

		$this->stan->ChangeStan($this->stan->GetNoStan());
		echo 'STRING';

	}

}

class BooleanStan implements Stan {

	private $stan;

	public function __construct (UseStan $usestan) { 

		$this->stan = $usestan;

	}

	public function CheckIt ($value) {

		echo 'Metoda CheckIt() byla juz wolana!';
	}

	public function WriteMessage () {

		$this->stan->ChangeStan($this->stan->GetNoStan());
		echo 'BOOLEAN';

	}

}

Jak widać każdy typ danych ma swoją klasę (string - StringStan, itd.). Wyjątek stanowi NoStan, której zadaniem jest określenie typu zmiennej $value przekazanej w metodzie CheckIt($value),a następnie wydelegowanie do dalszej obsługi metod interfejsu Stan instancji odpowiedniej klasy(StringStan,BooleanStan,itd.). Może zastanawiać do czego służy i czym jest prywatna właściwość $stan klasy UseStan. Zatem spójrzmy na jej implementację:

class UseStan {

	private $nostan;
	private $integerstan;
	private $stringstan;
	private $booleanstan;

	private $stan;

	public function __construct () {
                // przekazywanie w parametrze obiektu klasy UseStan ($this)
                // pozwoli na swobodna zmiane delegacji przez klasy stanow
                // z uzyciem setter'a stanu i getterow wszystkich stanow
		$this->nostan = new Nostan($this);
		$this->integerstan = new IntegerStan($this);
		$this->stringstan = new StringStan($this);
		$this->booleanstan = new BooleanStan($this);
                // na poczatku nie wiemy jaki typ zmiennej bedzie przekazany, zatem
                // inicjujemy wlasciwosc obiektem klasy NoStan
		$this->stan = $this->nostan;

	}

	//implementacja interfejsu obiektow - stanow

	public function CheckIt ($value) {

		$this->stan->CheckIt($value);

	}

	public function WriteMessage () {

		$this->stan->WriteMessage();

	}

	// metoda delegujaca nowy obiekt stanu do pracy

	public function ChangeStan (Stan $newstan) {

		$this->stan = $newstan;

	}

	// gettery stanów

	public function GetNoStan () {

		return $this->nostan;

	}

	public function GetIntegerStan () {

		return $this->integerstan;

	}

	public function GetStringStan () {

		return $this->stringstan;

	}

	public function GetBooleanStan () {

		return $this->booleanstan;

	}
}

Obiekty stanów używają instancji klasy UseStan która je posiada, do zmiany delegacji (stąd gettery wszystkich stanów i setter ChangeStan($nowystan)). Na koniec użycie:

$obj = new UseStan();
// W zaleznosci od typu parametru, zostanie wydelegowana instancja
// odpowiednej klasy do dalszej obslugi metod interfejsu Stan.
$obj->CheckIt(true); 

// Stad tez metoda WriteMessage wywolana zostanie na obiekcie klasy
// BooleanStan a nie zadnym innym.
$obj->WriteMessage();

Powyższy przykład jest prosty i ma na celu zrozumienie wzorca Stan. Mam nadzieje, iż w jakimś stopniu Wam w tym pomogłem. Kod przykładu znajduje się TUTAJ

Co to jest?

Funkcja anonimowa, to funkcja jak każda inna z tym wyjątkiem, iż nie wymaga określania jej nazwy i może zostać przypisana do zmiennej, a następnie wywołana z jej poziomu. Najlepiej będzie to zobrazować na prostym przykładzie:

$zmienna = function () {
	echo 'a';
};

$zmienna();

Po wywołaniu powyższego skryptu, na wyjściu otrzymamy:

Prawda, że proste? W ten sposób możemy bezpośrednio definiować funkcje zwrotne w wywołaniach funkcji, które tego wymagają:

Dla PHP < 5.3

function echosomething () {

	echo 'callback';

}
// wolanie funkcji zdefiniowanej przez programiste
call_user_func('echosomething');

Dla PHP >= 5.3

call_user_func(function () { echo 'callback';});

Dodatkowo funkcja anonimowa może korzystać ze zmiennych “dziedziczonych” z przestrzeni, w której została zdefiniowana. Aby użyć tej opcji, w deklaracji funkcji stosuje się słowo kluczowe use. Spójrzmy na poniższy przykład:

class Przyklad {

	public static function Wypisz () {

		$a = 'in';

		// przestrzenia ponizszej funkcji jest metoda Wypisz()
		$zmienna = function () use ($a) {

			echo $a;

		};

		$zmienna();

	} 

}
$a = 'out';
Przyklad::Wypisz();

Na wyjściu ujrzymy napis:

Osoby zainteresowane odsyłam TUTAJ.

Prosty przykład

Wyobraźmy sobie abstrakcyjną klasę Information, której jedynym zadaniem jest wypisywanie na wyjście wiadomości przekazanej w parametrze metody Write($message). Spójrzmy na poniższy listing.

abstract class Information {

	abstract public function Write($message);

}

Zatem najprostsza implementacja powyższej klasy może wyglądać następująco:

// obiekty tej klasy beda dekorowane

class SimpleText extends Information {

	public function Write ($message) {

		echo $message;

	}

}

Nie chcemy jednak, by każdy łańcuch znaków mógł zostać wyświetlony. W związku z tym stworzymy teraz klasy, które zapewnią walidację parametru $message.

// klasa sprawdza dlugosc string'a.

class TextLength extends Information {

	// obiekt dekorowany
	private $decorate;

	public function __construct (Information $dec) {
                // korzystamy z kompozycji obiektow

		$this->decorate = $dec;

	}

	public function Write ($message) {
                // warunek wyswietlenia string'a
		if (isset($message{5}))
			$this->decorate->Write($message);

	}

}

// klasa sprawdza czy pierwsza litera wiadomosci jest A

class FirstLetter extends Information {

	// obiekt dekorowany
	private $decorate;

	public function __construct (Information $dec) {
                //korzystamy z kompozycji obiektow

		$this->decorate = $dec;

	}

	public function Write ($message) {
                //warunek walidacji
		if ($message{0}=='A')
			$this->decorate->Write($message);

	}

}

Jeśli chcemy zezwolić na wyświetlanie na wyjściu wiadomości, których długość przekracza pięć znaków wystarczy zapis:

$obj = new TextLength(new SimpleText());
$obj->Write('Napis');

Warunki mogą być łatwo dołączane jak zaprezentowano poniżej:

// wyswietli napis gdy bedzie on mial wiecej niz
// 5 znakow a pierwszym bedzie litera A.
$obj = new FirstLetter(new TextLength(new SimpleText()));
$obj->Write('Napis');

W ten prosty sposób możemy dowolnie nakładać ograniczenia na parametr $message. Proszę zwrócić uwagę na fakt, iż gdy obiekt dekorowany jest tego samego typu co dekoratory jesteśmy w stanie “dekorować” również dekoratory - tak właśnie dzieje się w powyższym przykładzie. Zachęcam do korzystania z tego wzorca.

Asercja w praktyce

Na początek zasada działania funkcji assert().

// asercja z wyrażeniem logicznym które jest zawsze prawdziwe
assert ('12>1');

Wykonanie powyższego kodu zakończy się sukcesem, gdyż wyrażenie podane jako parametr funkcji będzie zawsze prawdziwe. Wprowadźmy więc małą zmianę:

// asercja z wyrażeniem logicznym które jest zawsze fałszywe
assert ('12<1');

Tym razem zostanie zgłoszony błąd, zgodnie z ustawieniami zdefiniowanymi przy użyciu assert_options(). U mnie na wyjściu otrzymałem następujący komunikat:

Nasuwa się więc prosty wniosek. Gdy warunek podany w asercji nie jest spełniony jesteśmy w stanie dostrzec i wyeliminować potencjalne błędy w kodzie. Popatrzmy na bardziej skomplikowany przykład:

function getnews ($id) {

	//sprawdzamy czy przekazano integer
	assert ('is_int($id)');
	echo $id;

}

getnews('3');

Powyższy skrypt zgłosi błąd, gdyż do funkcji przekazano string a nie integer. Asercja nie została spełniona.

Na koniec pozostało omówienie opcji, które pozwalają skonfigurować asercje w PHP. Do tego celu używa się funkcji assert_options($option,$value), gdzie pierwszym parametrem jest konkretna opcja, a drugim jej nowa wartość. Jeśli $value nie zostanie przekazana, to zwrócona zostanie bieżąca wartość opcji $option. Opcje konfiguracyjne przedstawiają się następująco:

• ASSERT_ACTIVE - asercja włączona lub nie. (true lub false)
• ASSERT_WARNING - asercja generuje ostrzeżenie PHP. (true lub false)
• ASSERT_QUIET_EVAL - generowanie komunikatu w przypadku, gdy w trakcie obliczania wyrażenia logicznego przekazanego w asercji wystąpi błąd. (true lub false)
• ASSERT_BAILE - niespełniona asercja zatrzymuje wykonywanie skryptu. (true lub false)
• ASSERT_CALLBACK - nazwa funkcji, która jest wywoływana w przypadku niespełnienia asercji.

To tylko zalążek możliwości jakie oferuje asercja, a zarazem wstęp do pisania testów jednostkowych. Zainteresowanych odsyłam TUTAJ. W przyszłości postaram się do tego tematu powrócić.

try {
	$dir = new DirectoryIterator ('./przykladowy_katalog');

	// $file jest rowniez obiektem klasy DirectoryIterator
	foreach ($dir as $file)
		echo $file->GetFilename();
}
catch (RuntimeException $e) {
	echo $e->getMessage();
}

Pragnę zwrócić uwagę, iż w powyższym skrypcie przechwytujemy wyjątek RuntimeException, który zostanie zgłoszony np. jeśli katalog przekazany w konstruktorze klasy nie istnieje.

Pozostaje mi omówić kilka podstawowych metod, które dostarcza DirectoryIterator. Zatem:

• bool isDir() - sprawdza czy bieżący element to katalog
• bool isFile() - sprawdza czy bieżący element to plik
• bool isDot() - sprawdza czy bieżący element to ‘.’ lub ‘..’
• string getFilename() - zwraca nazwę bieżącego elementu (pliku lub katalogu)
• int getSize() - zwraca rozmiar pliku
• bool isReadable() - sprawdza czy plik można odczytać
• bool isWritable() - sprawdza czy w pliku można zapisywać zmiany
• bool isExecutable() - sprawdza czy plik można wykonać
• string getType() - zwraca typ bieżącego elementu (dir,file) a nie MIME!

Prawda, że proste i przyjemne? Zainteresowanych odsyłam do oficjalnej dokumentacji, którą można znaleźć TUTAJ.

fasada

Z założenia tworzy zunifikowany i uproszczony interfejs wysokiego poziomu dla podsystemu, który korzysta z własnych interfejsów. Wyobraźmy sobie taką sytuację. Wracamy zmęczeni do domu i chcemy się odprężyć. W tym celu włączamy telewizor, potem odtwarzacz dvd, nastawiamy odpowiednią temperaturę w mieszkaniu i przygaszamy światło. Dużo pracy? Nie prościej byłoby posiadać pilot, gdzie za sprawą naciśnięcia jednego przycisku wszystkie te czynności zostałyby wykonane? Rozwiązanie wydaje się być idealne! W programowaniu możemy stosować takie uproszczenie do obsługi zazwyczaj wielu obiektów różnych klas. Na początek prezentuje bardzo abstrakcyjne klasy odzwierciedlające opisaną przeze mnie sytuację.

class Telewizor {

	public function WlaczTV () {

		echo 'Wlaczony TV';

	}

	public function WylaczTV () {

		echo 'Wylaczony TV';

	}

}

class OdtwarzaczDVD {

	public function WlaczDVD () {

		echo 'Wlaczone DVD';

	}

	public function PuscFilm () {

		echo 'Film puszczony';

	}

	public function WylaczDVD () {

		echo 'Wylaczone DVD';

	}

}

class Oswietlenie {

	public function Rozjasnij () {

		echo 'Rozjasnij oswietlenie';

	}

	public function Przygas () {

		echo 'Przygas oswietlenie';

	}

}

class Klimatyzacja {

	private $temp = 20;

	public function UstawTemp ($temp) {

		$this->temp = $temp;
		echo 'Ustawiono temperature '.$temp;

	}

}

Teraz zastosujemy omawiany wzorzec w praktyce:

class Obsluga {

	private $tv;
	private $dvd;
	private $light;
	private $aircon;

	public function __construct (Telewizor $a,OdtwarzaczDVD $b,Oswietlenie $c,Klimatyzacja $d) {

		$this->tv = $a;
		$this->dvd = $b;
		$this->light = $c;
		$this->aircon = $d;

	}

	public function Ustaw ($temp) {

		$this->tv->WlaczTV();
		$this->dvd->WlaczDVD();
		$this->dvd->PuscFilm();
		$this->light->Przygas();
		$this->aircon->UstawTemp($temp);

	}

}

Oraz użycie:

$fasada = new Obsluga (new Telewizor(),new OdtwarzaczDVD(),new Oswietlenie(),new Klimatyzacja());
$fasada->Ustaw(18);

Jak widać jedna metoda wykonuje za nas całą “brudną” robotę.

fasada a adapter

Różnica tkwi nie w ilości obsługiwanych klas przez oba wzorce! Zapamiętajmy, iż Adapter zmienia interfejs, by dostosować się do wymagań klienta, a Fasada stara się go uprościć.

interface Serializable   {
	abstract public string serialize ( void )
	abstract public mixed unserialize ( string $serialized )
}

Tak więc:

• serialize() - wywoływana przy serializacji obiektu klasy. Zwraca string, z danymi które poddaliśmy temu procesowi.
• unserialize($data) - wywoływana przy deserializacji. Przesłania konstruktor klasy.

Pozostaje napisanie przykładowej klasy korzystającej z możliwości przedstawionego przeze mnie interfejsu. Spójrzmy:

class Example implements Serializable {

	public $a;
	public $b;

	public function __construct () {

		$this->a = 122;
		$this->b = 12;

	}

	public function serialize () {

		return serialize($this->a);

	}

	public function unserialize ($data) {

		$this->a = unserialize($data);

	}

	public function Seta ($setme) {

		$this->a = $setme;

	}

}

Oraz użycie:

$obj = new Example();
$obj->Seta(1);
$se = serialize($obj);
var_dump($se);
$un = unserialize($se);
var_dump($un);

Zwróćmy uwagę na fakt, iż używając serialize() serializujemy tylko właściwość $this->a. Notomiast wywołanie unserialize() przywraca nam obiekt, ale atrybut $this->b ma wartość NULL, bo nie jest wywoływany konstruktor klasy. Warto o tym pamiętać.