PHP Design Patterns

1. Ce sunt Design Patterns ?

Design Patterns pot fi privite ca solutii propuse pentru a putea evita anumite probleme intalnite in programarea orientata pe obiecte, aceste solutii pot fi implementate in orice limbaj insa eu ma voi referi strict la PHP.

Obs. Sa nu credeti ca nu pot fi implementate aceste solutii si in programarea procedurala, insa avantajul major este observat in OOP

2. Ce probleme rezolva Desing Patterns ?

1. Consumul de resurse

2. Ordonarea si incapsularea codului

3. Separarea logici de output-ul site-ului

Acestea sunt doar cateva din avantajele accestor solutii.

3. Cele mai folosite Desing Paterns

Mai jos o prezint cele mai folosite solutii in oop, asadar voi incepe cu :

3.1 Singleton

Acest pattern este unul din cel mai simple iar conceptul sau spune ca permite acces la o singura resursa, iar aceasta nu va fi niciodata duplicata. Foarte important e ca aceasta resursa trebuie sa poata fi acesata oricand si oriunde.

De asemnea acesta solutie prevede o modalitate de a acesa clasa fara a crea un obiect al acesteia, toate astea referindu-ne la Singleton pur.

Pentru a putea crea o astfel de clasa va trebuie sa facem constructorul privat ( poate o sa vi se para aiurea dar este necesar), pentru a nu se putea crea o instanta a clasei prin new ceea ce e foarte important, deoarece vom folosi operatorul de rezolutie :: pentru a accesa continutul clasei, mai jos o sa dau un exemplu pentru o clasa masina.

 
<?php
 
class Masina {
    private static $_masina;
    private $motor, $putere, $masina;
 
    private function __construct() {
	$this->motor = 1.0;
	$this->putere = '20cp';
	$this->masina = 'golf';
    }
 
    public static function Instanta() {
	//Daca nu exista o instanta a clasei
        if(!self::$_masina) {
	    //creem una
            self::$_masina = new Masina();
		echo "__Instanta creata___<br />";
        } else {
		echo "__Instanta este deja creata___<br />";
	}
	//returnam instanta
        return self::$_masina;
    }
 
     public function daMasina() {
	echo  $this->motor. ' '.$this->putere.' '.$this->masina."<br />";
     }
 
}
 
Masina::Instanta()->daMasina();
Masina::Instanta()->daMasina();
Masina::Instanta()->daMasina();
 
?>

Iar outputul este :

 
__Instanta creata___
1 20cp golf
__Instanta este deja creata___
1 20cp golf
__Instanta este deja creata___
1 20cp golf

Ce e important sa integeti e ca daca clasa nu este instantiata se creaza o instanta daca are una va fi folosita(codul important este in metoda Instanta), probabil o sa intrebati si la ce bun, ei bine uneori doriti sa existe o singura instanta de exemplu daca ar fi o clasa de conexiune la o baza de date, si in contructor ar fi conexiunea, nu ar fi ok sa existe o singura conexiune? nu 100 de conexiuni la baza de date?

Cu toate ca e cel mai simplu cred ca deja ati realizat cat e de folositor, un exemplu e mai sus cel cu baza de date + de asta uneori nu e nevoie de 10 instantieri sau obiecte, iar daca scriem mult cod apar si erorile in logica astfel ne salvam pe noi de la a consuma memorie in plus, doarece fiecare instantiere este tinuta in memorie.

3.2 Registry

Mai sus am discutat despre Singleton, dar ce se intampla daca am nevoie sa imi instantiez de mai multe ori clasa? stiu ca cu Singleton se poate o singura data, daca vreau 2 conexiuni catre 2 baze de date diferite de exemplu? Atunci vine modelul Registry in ajutorul vostru, el fiind un "Singleton " ce permite instantiere multipla, dar controlata.

 
<?php
 
class Masina {
 
     private static $_masina = array();
     private $motor, $putere, $masina;
 
     private function __construct() {
 
     }
 
     public static function creazaInstanta($nume){
        if (isset(self::$_masina[$nume])) {
	    throw new Exception("Exista deja o instatiere pe acest nume");
	} else {
	    self::$_masina[$nume] = new Masina();
	}
    }	
 
    public static function daInstanta($nume) {
        //Daca nu exista o instanta a clasei
        if(!isset(self::$_masina[$nume])) {
	    throw new Exception("Acceasta instanta nu exista");
        } else {
	    echo "__Instanta ".$nume." este returnata___<br />";
	    return self::$_masina[$nume];
	}
    }
}
 
Masina::creazaInstanta("Golf");
Masina::creazaInstanta("Passat");
Masina::daInstanta("Golf");
Masina::daInstanta("Passat");
 
?>

Rezultatul fiind :

 
__Instanta Golf este returnata___
__Instanta Passat este returnata___

Accest model poate fi imbunatatit, de exemplu sa stocheze instante ale altor clase, daca aveti intrebari va rog sa lasati comentarii.

3.3 Factory

Daca o luam babeste dupa nume, din start ne dam sema ca acest pattern "fabrica" ceva, o clasa care "fabrica" alte clase, e aiurea spus dar chiar asta face, Factory este gandit ca o clasa generala care instantiaza alte clase in interioriul ei, dar nu orice clase ci clase care se ocupa de acelasi lucru, sa zicem ca primim de la un api date atat in format json cat si xml, iar noi avem o singura clasa numita Interpretare, in interiorul ei instantiem alte doua clase pasrseXml si parseJson, partea frumoasa aici este ca noi defapt creem si returnam un obiect, dar asta o sa intelegeti mai bine din exemplele urmatoare.

 
 
 
 
class parseazaJson {}
class parseazaXml {}
class Interpreteaza {
 
    const JSON = 1 ; 
    const XML = 2 ;
 
    public static function parseRes($type = self::JSON) {
	switch (trim((int)$type)) {
            case 1:
		return new parseazaJson();
	    break;
	    case 2:
		return new parseazaXml();
	    break;
	    default:
		throw new Exception('Clasa poate parsa doar xml si json');
	}
    }
}
 
$parse = Interpreteaza::parseRes(Interpreteaza::XML);
var_export($parse);

Iar rezultatul va fi

 
parseazaXml::__set_state(array( ))

De aici ne putem da seama ce inseamna modelul Factory prin clasa noastra am initializat alta clasa, spre deosebire de singleton nu am fost nevoiti sa face constructorul privat. Ce trebuie sa intelegeti voi e ca prin modelul Factory o clasa generala initializeaza alte clase care se ocupa cu acelasi lucru, acum o sa va prezint cateva trucuri frumoase in Factory:

ex: 1.

In mod normal noi creem un obiect apoi apelam o metoda care dorim prin urmatorul set de instructiuni

 
<?php
$ob = new NumeClasa();
$ob->metoda();
?>

In factory putem sa facem totul cu o singura line :

 
<?php
class NumeClasa {
    public static function factory() {
        return new NumeClasa(); 
    }
    public function metoda() { 
        echo 'Apelare metoda prin factory pattern';
    }
}
 
NumeClasa::factory()->metoda();
?>

ex 2 :

Avand in vedere ca Factory initializeaza alte clase prin clasa noastra generala, am putea sa dam noi clasa care dorim sa o initializam ca un parametru pentru o metoda Factory.

 
<?php
class WebSite {};
class Factory
{
    public static function instance($nameClass = null)
    {   
        if($nameClass)
			return new $nameClass;
		else 
			return false;
    }
}
 
$web = Factory::instance("WebSite");
var_export($web);
?>

Iar outputul este

 
WebSite::__set_state(array( ))

Asadar am creat o instanta a clasei WebSite prin clasa Factory

3.4 MVC

Sunt sigur ca majoritatea ati auzit de MVC, majoritatea framework-urilor si CMS-urilor actuale sunt scrise in MVC.

MVC-ul este cu mult mai complex decat modelele anterioare, el prevede 3 parti un model un controller si un view.

1. Controller-ul sau partea decizionala este prima apelata si va decide ce va face cu requestul primit

2. Model-ul, este apelat de catre controller, si se ocupa de logica adica interogari din baza de date, care le va returna controller-ului.

3. View primeste datele prelucrate de controller care pot fi afisate utilizatorului.

Aplicatiile pe acest model sunt foarte organizate, se pot exinde si se poate face debug-ing foarte usor pe ele. Mai jos o sa dau un scurt exemplu de MVC

 
<?php
//controller 
 
Class Controller {
	private $model,$view;
	public function decide( $info = null ) {
		$this->model = new Model();
		$this->view = new View(); 
		if ($this->model->get($info)) {
			$this->view->afiseaza("Bun venit pe micul-programator, Username");
		} else {
			$this->view->eroare(array(
				'cod' => 1 ,
				'mesaj' => 'Acest utilizator nu exista',
			));
		}
	}
 
}
 
Class Model {
 
	public function get( $id ) {
		//aici ar trebui sa fie un query 
		if( $id == 1 ) 
			return true;
		else 
			return false;
	}
 
}
 
Class View {
 
	public function afiseaza ($date) {
		echo "Controllerul zice ca trebuie sa afisez ".$date;
	}
 
	public function eroare($date) {
		print_r($date);
	}
 
}
 
$obj = new Controller();
$obj->decide($_GET['user']);
 
?>

Daca : index?user=1

 
Controllerul zice ca trebuie sa afisez Bun venit pe micul-programator, Username

Daca : index?user=2

 
Array ( [cod] => 1 [mesaj] => Acest utilizator nu exista )

Modelul este mult mai complex decat ce am prezentat eu mai sus, eu am incercat sa fac ceva cat se poate de simplu, acest model trebuie privit la nivel de fisiere si directore, pentru a va da mai bine seama va recomand sa va uitati in core la un framework sau un cms MVC.

Mai sunt si alte design patterns insa acceste sunt cele mai folosite sau cel putin asa ma gasit eu, ar ma fi

1 . Strategy

2. Observer

3. chain-of-command

Aici se termina acest tutorial, sper sa va fie de folos, un an nou cu bine