-
Un design patten creational care reprezinta o solutie pentru a genera obiecte fara sa se specifice clasa acestuia. In mod particular orice metoda care genereaza obiecte reprezinta o implementare de Factory Method pattern.
Motivatie:
O motivatie este ca, sarcina de a creea obiectul este delegata catre metoda factory.
Diagrama:
Implementare:
Clasele care genereaza obiecte prin factory, clasa comuna care va fi extinsa si clasa cu metoda fatory:1// clasa comuna care va fi extinsa 2abstract class OutputBase { 3 // output headerele necesare 4 abstract public function header(); 5 6 // corpul rezultat 7 abstract public function body($data); 8 9} 10 11// clasa pentru output xml 12class XMLOutput extends OutputBase { 13 14 // output header xml 15 public function header() { 16 header('content-type: text/xml'); 17 } 18 19 // document xml 20 public function body($data) { 21 $res = ''; 22 23 $res .= ''; 24 25 foreach ($data as $root => $item) { 26 27 $res .= ''; 28 29 foreach ($item as $key => $val) { 30 $res .= '<'.$key.'>'.$val.''; 31 } 32 33 $res .= ''; 34 } 35 36 $res .= ''; 37 38 return $res; 39 40 } 41 42} 43 44// clasa pentru output csv 45class CSVOutput extends OutputBase { 46 47 // output header csv 48 public function header() { 49 header("Content-type: text/plain"); 50 } 51 52 // corp csv 53 public function body($data) { 54 $res = ''; 55 56 $keys = array_keys($data[0]); 57 58 foreach ($keys as $key) { 59 $res .= '"'.$key.'";'; 60 } 61 $res .= "\r\n"; 62 63 foreach ($data as $item) { 64 foreach ($item as $val) { 65 $res .= '"'.$val.'";'; 66 } 67 68 $res .= "\r\n"; 69 } 70 71 return $res; 72 } 73} 74 75// clasa cu metoda factory 76// este abstracta pentru a nu fi instantiata 77abstract class OutputFactory { 78 79 // constanta pentru timpul xml 80 const XML = 1; 81 82 // constanta pentru tipul csv 83 const CSV = 2; 84 85 // metoda statica factory 86 public static function getInstance($type) { 87 // in functie de constanta primita ca parametru 88 // va intoarce unul din obiecte 89 switch ($type) { 90 case self::XML : 91 return new XMLOutput(); 92 break; 93 94 case self::CSV : 95 return new CSVOutput(); 96 break; 97 } 98 99 // daca valoarea primita ca parametru nu este una din constante 100 // se arunca o exceptie 101 throw new Exception('Invalid class type!'); 102 } 103 104}Exemplu:
1// se de date 2$data = array( 3 array( 4 'a' => 1, 5 'b' => 2, 6 'c' => 3 7 ), 8 array( 9 'a' => 4, 10 'b' => 5, 11 'c' => 6 12 ) 13 ); 14 15//Bloc try-catch pentru a prinde eventualele exceptii 16try { 17 // generare obiect 18 $obj = OutputFactory::getInstance(OutputFactory::XML); 19 20 // output headere 21 $obj->header(); 22 23 // afisare body 24 echo $obj->body($data); 25 26} catch (Exception $e) { 27 28 $e->getMessage(); 29 30} -
CodeIgniter este un framework open-source scris in PHP care se bazeaza pe principiul RAD. Popularitatea acestui framework este in continua crestere, probabil in special de cand lumea a descoperit ca e mult mai usor sa folosesti un framework open-source decat sa dezolti unul intern, dar asta este alta discutie. Cartea CodeIgniter 1.7 de la PacktPublishing, scrisa de Jose Argudo Blanco si David Upton urmareste formarea unei imagini de ansamblu asupra framework-ului CodeIgniter, venind in completarea manualului.
Pana la urma orice framework care se respecta are o referinta detaliata a acestuia, cu eventuale exemple, mai mult sau mai putin cuprinzatoare. Atunci cand vine vorba de invatarea unui framework (si nu numai), o referinta de cele mai multe ori nu este un punct bun de plecare, pentru ca nu poti cauta in aceasta solutii de ansamblu cand primesti explicatii atomice. De asta ajungem sa cumparam carti, pentru a avea o prezentare generala cu probleme si solutii. Si asa am ajuns la cartea CodeIgniter 1.7.
Initial cand am vazut ca titlul cuprinde numarul versiunii framework-ului pe care il analizeaza am fost putin pesimist, pentru ca atunci cand cumperi o carte nu o vrei neaparat legata de o versiune, nu? Nuprea… eu am avut problema asta cu Zend Framework de exemplu, majoritatea cartilor prezinta versiuni “mai vechi” (ex: 1.5-1.6) iar eu vroiam sa vad o abordare cu noile facilitati din versiunea 1.8 sau mai mare. Pana la urma atunci cand inveti vrei de obicei o versiune mai noua a framework-ului, iar cand vor aparea facilitati noi probabil va fi mai simplu sa le citesti doar in referinta.
artea se pare ca porneste de la nivelul de incepator si ataca progresiv atat elementele de baza cat si cele mai frecvente probleme cu care utilizatorul se poare intalni in dezoltarea de aplicatii folosind framework-ului CodeIgniter. Capitolul mostra, pare destul de bine structurat si usor de inteles, iar din cuprins pare sa atace toate subiectele importante, asa ca in speranta ca si restul cartii va fi la fel si ca va mai urma si o parte a doua la acest “review” astept cu nerabdare cartea.
Va urma…
-
Probabil cel mai cunoscut pattern de PHP si nu numai.
Motivatie:
Restrictionarea la o singura instanta a unei resurse in toata aplicatia, accesibila de oriunde.
Diagrama:
Implementare:
Exemplul clasic pentru PHP este resursa de conectare la baze de date. Conexiunea la baza de date trebuie sa fie unica in toata aplicatia pentru a nu stabili conexiuni multiple la baza de date si in consecinta sa fie consumate resurse inutil.
Pentru ca sa existe o singura instanta constructorul nu trebuie sa fie accesibil decat printr-o metoda statica, iar obiectul rezultatul nu trebuie sa aiba posibilitatea de clonare. De asemenea clasa nu trebuie sa aiba posibilitatea de a fi extinsa.
Exemplu:
1// date conectare db 2define ( 'DB_HOST', 'localhost' ); 3define ( 'DB_USER', 'user' ); 4define ( 'DB_PASS', 'pass' ); 5define ( 'DB_DATABASE', 'db' ); 6 7/** 8 * Clasa singleton pentru managementul conexiunii la baza de date folosind mysqli 9 */ 10final class SingletonDB { 11 12 /** 13 * Instanta singleton 14 * 15 * @var SingletonDB 16 */ 17 protected static $_instance = null; 18 19 /** 20 * Connection resource 21 * 22 * @var resource 23 */ 24 protected $_connection = null; 25 26 /** 27 * Constructor care realizeaza si conexiunea la baza de date 28 * 29 */ 30 protected function __construct() { 31 // conectare server baze de date 32 $this->_connection = new mysqli ( DB_HOST, DB_USER, DB_PASS ); 33 34 // in cazul in care conexiunea este nereusita se trimite o exceptie 35 if ($this->_connection->connect_error) { 36 throw new Exception ( 'Error connection to mysql server' ); 37 } 38 39 // selectare baza de date 40 $this->_connection->select_db ( DB_DATABASE ); 41 42 // in cazul in care selectarea este nereusita se trimite o exceptie 43 if ($this->_connection->error) { 44 throw new Exception ( 'Error selecting database' ); 45 } 46 47 } 48 49 /** 50 * Rulare interogare SQL 51 * 52 * @param string $query Interogare SQL 53 * @return mysqli_result 54 */ 55 public function query($query) { 56 return $this->_connection->query ( $query ); 57 } 58 59 /** 60 * Acces mesaj eroare 61 * 62 * @return string 63 */ 64 public function error() { 65 return $this->_connection->error; 66 } 67 68 /** 69 * Metoda care se apeleaza la clonare 70 * Este protected pentru ca obiectul nu trebuie clonat 71 * 72 */ 73 protected function __clone() { 74 } 75 76 /** 77 * Intrerupe conexiunea 78 * 79 */ 80 public function __destruct() { 81 $this->_connection->close (); 82 } 83 84 /** 85 * Metoda care va intoarce instanta singleton 86 * 87 * @return SingletonDB 88 */ 89 public static function getInstance() { 90 if (self::$_instance == null) { 91 self::$_instance = new SingletonDB ( ); 92 } 93 94 return self::$_instance; 95 } 96} 97 98try { 99 // Instanta SingletonDB 100 $db = SingletonDB::getInstance (); 101 102 // Interogare de executat 103 $q = 'SELECT * FROM test'; 104 105 // interogarea va returna un obiectu mysqli_result 106 $result = $db->query ( $q ); 107 108 // Se verifica daca exista erori si se afisaza 109 if ($db->error ()) { 110 111 echo $db->error (); 112 113 } else { 114 // se extrag rezultatele si se afisaza pe ecran 115 while ( $row = $result->fetch_assoc () ) { 116 var_dump ( $row ); 117 } 118 // se inchide obiectul de mysqli_result 119 $result->close (); 120 } 121// in cazul in care apar exceptii acestea se afisaza 122} catch ( Exception $e ) { 123 echo $e->getMessage (); 124} -
Iterator pattern este probabil cel mai popular pattern din SPL. Este un exemplu foarte simplu de a demonstra avantajele unei interfete si SPL.
Motivatie:
Posibilitatea de a itera structuri de tip obiect folosind functii precum foreach(), var_dump(), print_r() etc.Diagrama:
Structura Iterator:
In SPL se gasesc mai multe interfete si clase pentru iterator.
Structura de baza pentru interfata Iterator:
1/** 2 * Interfata Iterator din SPL 3 */ 4Iterator extends Traversable { 5 /** 6 * Intoarce elementul curent 7 */ 8 abstract public mixed current ( void ) 9 10 /** 11 * Cheia pentru elementul curent 12 */ 13 abstract public scalar key ( void ) 14 15 /** 16 * Trece la urmatorul element 17 */ 18 abstract public void next ( void ) 19 20 /** 21 * Reseteaza iterarea la pozitia initiala 22 */ 23 abstract public void rewind ( void ) 24 25 /** 26 * Verifica daca pozitia curenta este valida 27 */ 28 abstract public boolean valid ( void ) 29}Exemplu 1:
Un obiect iterabil simplu.
1/** 2 * Clasa care va genera un obiect interabil 3 */ 4class Iterabil implements Iterator { 5 6 /** 7 * Index pentru elementul iterabil 8 */ 9 private $_current = 0; 10 11 /** 12 * Array cu elementele de iterat 13 */ 14 private $_elements = array(); 15 16 /** 17 * Constructor 18 * 19 * @param array $elements Elementele de iterat 20 */ 21 public function __construct($elements) { 22 $this->_elements = $elements; 23 } 24 25 /** 26 * Elementul curent 27 * 28 * @return mixed Elementul curent 29 */ 30 public function current() { 31 return $this->_elements[$this->_current]; 32 } 33 34 /** 35 * Index curent 36 * 37 * @return integer Index curent 38 */ 39 public function key() { 40 return $this->_current; 41 } 42 43 /** 44 * Trecerea la index-ul urmator 45 */ 46 public function next() { 47 $this->_current++; 48 } 49 50 /** 51 * Resetare index 52 */ 53 public function rewind() { 54 $this->_current = 0; 55 } 56 57 /** 58 * Verifica daca elementul curent este setat 59 * 60 * @return boolean Daca elementu curent este setat 61 */ 62 public function valid() { 63 return isset($this->_elements[$this->_current]); 64 } 65} 66 67// instantiere clasa 68$obj = new Iterabil(array(1, 2, 3, 4, 5)); 69 70// iterare obiect 71foreach ($obj as $value) { 72 echo $value.PHP_EOL; 73} 74 75// output: 76// 1 77// 2 78// 3 79// 4 80// 5Exemplu 2:
Un exemplu putin mai complex, o clasa care permite iterarea prin proprietatile publice ale clasei care o extinde. Se folosesc Iterator si Reflection.
1/** 2 * Clasa care va genera un obiect cu proprietatile publice iterabile 3 */ 4class Iterabil implements Iterator { 5 6 /** 7 * Index pentru elementul iterabil 8 */ 9 private $_current = 0; 10 11 /** 12 * Array cu elementele de iterat 13 */ 14 private $_elements = array(); 15 16 /** 17 * Elementul curent 18 * 19 * @return mixed Proprietatea curenta in iteratie 20 */ 21 public function current() { 22 return $this->_elements[$this->_current]->name; 23 } 24 25 /** 26 * Index curent 27 * 28 * @return integer Index curent 29 */ 30 public function key() { 31 return $this->_current; 32 } 33 34 /** 35 * Trecerea la index-ul urmator 36 */ 37 public function next() { 38 $this->_current++; 39 } 40 41 /** 42 * Resetare index si preluare prorietari 43 */ 44 public function rewind() { 45 // rewind se apeleaza prima, 46 // deci aici ar trebui preluate prorprietatile obiectului 47 // se initializeaza obiectul de tip ReflectionClass 48 // cu parametru numele clasei curente 49 $reflection = new ReflectionClass(get_class($this)); 50 51 // se extrag metodele publice 52 $this->_elements = $reflection->getProperties(ReflectionMethod::IS_PUBLIC); 53 54 // se seteaza indexul curent 55 $this->_current = 0; 56 } 57 58 /** 59 * Verifica daca elementul curent este setat 60 * 61 * @return boolean Daca elementu curent este setat 62 */ 63 public function valid() { 64 return isset($this->_elements[$this->_current]); 65 } 66} 67 68/** 69 * O noua clasa care va avea proprietati publice 70 * 71 */ 72class Testing extends Iterabil { 73 public $proprietate1; 74 public $proprietate2; 75} 76 77// instantiere clasa 78$obj = new Testing(); 79 80// iterare obiect 81foreach ($obj as $value) { 82 echo $value.PHP_EOL; 83} 84 85// output: 86// proprietate1 87// proprietate2Iar daca vrem ca exemplu de mai sus sa fie si accesibil ca un array, nu trebuie decat sa mai implementam din SPL ArrayAccess.
Structura ArrayAccess:
1ArrayAccess { 2 /** 3 * Verifica daca un offset exista 4 */ 5 abstract public boolean offsetExists ( string $offset ); 6 7 /** 8 * Intoarce elementul unui offset sau NULL daca nu exista 9 */ 10 abstract public mixed offsetGet ( string $offset ); 11 12 /** 13 * Seteaza o valoare pentru un offset 14 */ 15 abstract public void offsetSet ( string $offset , string $value ); 16 17 /** 18 * Dezaloca o valoare pentru un offset 19 */ 20 abstract public void offsetUnset ( string $offset ) 21}Exemplu 3:
Un exemplu destul de dificil care are rolul de a evidentia puterea interfetelor din SPL. Obiect iterabil si accesibil ca un array.
Pentru a simplifica logica de acces am folosit chiar functiile pentru parcurgerea unui array (next(), reset()).
1/** 2 * Clasa care va genera un obiect interabil 3 */ 4class Iterabil implements Iterator, ArrayAccess, Countable { 5 6 /** 7 * Array cu elementele de iterat 8 */ 9 private $_elements = array(); 10 11 /** 12 * Constructor 13 * 14 * @param array $elements Elementele de iterat 15 */ 16 public function __construct($elements) { 17 $this->_elements = $elements; 18 } 19 20 /** 21 * Elementul curent 22 * 23 * @return mixed Elementul curent 24 */ 25 public function current() { 26 return current($this->_elements); 27 } 28 29 /** 30 * Index curent 31 * 32 * @return integer Index curent 33 */ 34 public function key() { 35 return key($this->_elements); 36 } 37 38 /** 39 * Trecerea la index-ul urmator 40 */ 41 public function next() { 42 next($this->_elements); 43 } 44 45 /** 46 * Resetare index 47 */ 48 public function rewind() { 49 reset($this->_elements); 50 } 51 52 /** 53 * Verifica daca elementul curent este setat 54 * 55 * @return boolean Daca elementu curent este setat 56 */ 57 public function valid() { 58 return current($this->_elements)?true:false; 59 } 60 /** 61 * Verifica daca un offset exista 62 * 63 * @param string $offset Element cautat 64 * @return boolean Daca elementul de la offset exista 65 */ 66 public function offsetExists($offset) { 67 return isset($this->_elements[$offset]); 68 } 69 70 /** 71 * Elementul de la un offset 72 * 73 * @param string $offset Offset array 74 * @return mixed 75 */ 76 public function offsetGet($offset) { 77 return $this->_elements[$offset]; 78 } 79 80 /** 81 * Setare element in array 82 * 83 * @param string $offset Offset element 84 * @param mixed $value Valoarea pentru elementul din array 85 */ 86 public function offsetSet($offset, $value) { 87 $this->_elements[$offset] = $value; 88 } 89 90 /** 91 * Dezalocare element in array 92 * 93 * @param string $offset Offset element 94 */ 95 public function offsetUnset($offset) { 96 unset($this->_elements[$offset]); 97 } 98 99 /** 100 * Numarul de elemente din array-ul curent 101 * 102 * @return integer Nr elemente array 103 */ 104 public function count() { 105 return count($this->_elements); 106 } 107} 108 109// instantiere clasa 110$obj = new Iterabil(array(1, 2, 3, 4, 5)); 111 112echo 'Iterare folosind "for":'.PHP_EOL; 113 114// iterare ca printr-un array simplu 115for($i = 0; $i < count($obj); $i++) { 116 echo $obj[$i].PHP_EOL; 117} 118 119echo 'Element de sters: '.$obj[1].PHP_EOL; 120 121unset($obj[1]); 122 123echo 'Iterare folosind "foreach":'.PHP_EOL; 124 125// iterare array folosind foreach 126foreach ($obj as $element) { 127 echo $element.PHP_EOL; 128} 129 130// Output: 131//Iterare folosind "for": 132//1 133//2 134//3 135//4 136//5 137//Element de sters: 2 138//Iterare folosind "foreach": 139//1 140//3 141//4 142//5