Les Design Patterns (PHP) · Les design patterns : creation´ Factory Semantique´ Problematique et...

Les Design Patterns(PHP)

Achref El Mouelhi

02 Novembre 2017, POEC PHP 2017 1 / 34

Plan

1 Introduction

2 Les design patterns : creationSingletonFactory

3 Les design patterns : structureAdapter

4 Les design patterns : comportementObserver

5 Liens utiles


Introduction

C’est quoi en francais?

Plusieurs traductions possiblesMotifs de conceptionPatrons de conceptionMasques de conceptionModele de conception...


Introduction

C’est quoi exactement?

DefinitionChaque patron decrit un probleme qui se manifeste constammentdans notre environnement, et donc decrit le cœur de la solution a ceprobleme, d’une facon telle que l’on puisse reutiliser cette solution desmillions de fois, sans jamais le faire deux fois de la meme maniere.

L’architecte anglais Christopher Alexander(A Pattern Language 1977)

L’idee a ete reprise et detaillee par la suite dans le livre Elements ofReusable Object-Oriented Software en 1995 par le Gang of Four(GoF, la bande des quatre en francais) Erich Gamma, Richard Helm,Ralph Johnson et John Vlissides).


Introduction

Categories

Categories de Design Patterns

Creation (fabrication, construction...) : description de la facon dontun (ou plusieurs) objet(s) peu(ven)t etre cree(s), initialise(s), etconfigure(s)

Structure : description de la maniere dont doivent etre lies desobjets afin de rendre ces connections independantes desevolutions futures de l’application

Comportement : description de l’interconnexion entre objets


Introduction

C’est quoi?

23 Design patterns proposes

Creation : Singleton, Factory, Builder, Prototype...

Structure : Adapter, Bridge, Composite, Decorator...

Comportement : Iterator, Observer, Visitor, Strategy...


Introduction

C’est quoi?

Remarques

les design patterns ne sont pas relatifs a un langage deprogrammation

ils sont tres adaptes aux langages de programmationorientes-objets

ils offrent des solutions a des problematiques recurrentsrencontres par les developpeurs

certains motifs ont ete pris en charge par des langages deprogrammation (Java et Observable...)


Les design patterns : creation Singleton

Semantique

Problematique et solutionUne instance qu’on ne peut instancier qu’une seule fois

l’unicite de l’instance est completement controlee par la classeelle-meme

Mettre en prive le constructeur? ⇒ insuffisant car la classe n’estplus instanciable

Un traitement additionnel par une methode autre que leconstructeur


Singleton : principe

<?phpclass ClassSingleton{

private static $_instance; // l’instance singleton de laclasse

private function __construct() { } // constructeur privateprivate function __clone() { } // clonage privatepublic static function getInstance(){

if (!isset(self::$_instance)) // pas encore instanciee{

self::$_instance = new self; // instanciation}return self::$_instance;

}}?>


Singleton : exemple

class ClassSingleton{

private $_value;private static $_instance;private function __construct() { }private function __clone() { }public static function getInstance(){

if (!isset(self::$_instance)) // pas encoreinstanciee

{self::$_instance = new self; //

instanciation}return self::$_instance;

}02 Novembre 2017, POEC PHP 2017 10 / 34


Singleton : exemple

public function Value(){return $this->_value;

}public function setValue($value){

$this->_value = $value;}

}$a = ClassSingleton::getInstance();$a->setValue(5);$b = ClassSingleton::getInstance();echo $b->Value(); // affiche 5



Semantique

Remarque

Evidemment, ce motif peut facilement etre etendu pour permettre lacreation d’un nombre bien determine d’instances


Les design patterns : creation Factory

Semantique

Problematique et solutionOn veut automatiser par exemple l’instanciation d’une classe(creation d’objets)

ceci peut nous aider par exemple a remplir une table de notrebase de donnees avec des donnees aleatoires pour qu’on puissetester notre application

Deleguer la creation d’objets a une classe Factory qui fabriquerades objets en fonction de nos parametres



Factory : exemple

//classe abstraite Personneabstract class Personne{

private $_nom;private $_prenom;public function Nom(){

return $this->_nom;}public function Prenom(){

return $this->_prenom;}public function setNom($nom){

$this->_nom = $nom;}public function setPrenom($prenom){

$this->_prenom = $prenom;}abstract public function description();

}


Factory : exemple

// classe Etudiant heritant de Personneclass Etudiant extends Personne{

private $_niveau;public function __construct($nom,$prenom,$niveau){

parent::setNom($nom);parent::setPrenom($prenom);$this->setNiveau($niveau);

}public function Niveau(){

return $this->_niveau;}public function setNiveau($niveau){

$this->_niveau = $niveau;}public function description(){

echo ’ Je suis Etudiant et je suis en ’ .$this->Niveau();

}}02 Novembre 2017, POEC PHP 2017 15 / 34


Factory : exemple

// classe Enseignant heritant de Personneclass Enseignant extends Personne{

private $_salaire;...public function description(){

echo "Je suis Enseignant et je touche " . $this->Salaire();

}}// classe Administratif heritant de Personneclass Administratif extends Personne{

private $_affectation;...public function description(){

echo "Je suis Administratif et je suis affecte a" . $this->Affectation();

}}



Factory : exemple

include ’Personne.php’;include ’Enseignant.php’;include ’Etudiant.php’;include ’Administratif.php’;// classe de fabricationclass FactoryPersonne{

public static function build($nom,$prenom,$valeur,$type){if (class_exists($type)){

$instance = new $type($nom,$prenom,$valeur);return $instance;

}else{

throw new Exception(" classe $typeinexistante ");

}}

}



Factory : exemple

try {$etudiant = FactoryPersonne::build(’bob’,’joe’,’1er

annee licence’,’Etudiant’);$etudiant->description();// affiche Je suis Etudiant et je suis en 1er annee

licence$agriculteur = FactoryPersonne::build(’jack’,’dalton’

,’raisin’, ’Agriculteur’);// affiche classe Agriculteur inexistante

}catch (Exception $e){

echo $e->getMessage();}


Factory : exemple

// classe qui controle la generation des instancesclass ControllerPersonne{

// methode pour generer les valeurs de mes attributspublic static function buildRandomString($length=5){

$myDB = ’abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

$ch=’’;for ($i = 0; $i< $length ; $i++){

$ch .= $myDB[rand(0, strlen($myDB)-1)];}return $ch;

}}// selon nos besoins, on peut definir d’autres methodes

comme buildRandomInteger, buildRandomKey...

Factory : exemple

// exploitation des classes FactoryPersonne etControllerPersonne

for($j=0; $j<5;$j++){$tab[$j] = FactoryPersonne::build(ControllerPersonne

::buildRandomString(),ControllerPersonne::buildRandomString(),ControllerPersonne::buildRandomString(),’Etudiant’);

$tab[$j]->description();}/* le resultat sembleraitJe suis Etudiant et je suis en uPPRCJe suis Etudiant et je suis en nQVORJe suis Etudiant et je suis en YwqmEJe suis Etudiant et je suis en lSdVPJe suis Etudiant et je suis en KteiF*/


Semantique

Remarque

Evidemment, ces classes peuvent etre utilisees avec des classesmanager pour alimenter une base de donnees


Les design patterns : structure Adapter

Semantique

Problematique et solutionOn veut utiliser une classe existante mais sa structure ne coıncidepas avec celle attendue

nom des methodesnombre d’attributs ou leurs types

utiliser un adaptateur de cette classe sans avoir besoin de lamodifier


Adapter : principe

// une interface IPersonneinterface IPersonne{

public function descriptionPersonne();}// une classe Enseignant qui implemente IPersonneclass Enseignant implements IPersonne{

private $_nom;public function __construct($nom){

$this->_nom = $nom;}public function Nom(){

return $this->_nom;}public function setNom($nom){

$this->_nom = $nom;}public function descriptionPersonne(){

echo " Je m’appelle " . $this->Nom();}


Adapter : principe

//classe Etudiant ne contenant pas la methodedescriptionPersonne

class Etudiant{private $_nom;private $_niveau;public function __construct($nom,$niveau){

$this->setNom($nom);$this->setNiveau($niveau);

}public function Nom(){

return $this->_nom;}public function setNom($nom){

$this->_nom = $nom;}public function Niveau(){

return $this->_niveau;}


Adapter : principe

public function setNiveau($niveau){$this->_niveau = $niveau;

}// cette classe a deux methodes une qui affiche le nom et

une deuxieme qui affiche le niveaupublic function descriptionNom() {

echo " Je m’appelle " . $this->Nom();}public function descriptionNiveau(){

echo " Je suis en " . $this->Niveau();}

}


Adapter : principe

// creation d’une classe adaptateur qui permettra d’avoir lamethode descriptionPersonne sans rien modifier dans laclasse Etudiant

class EtudiantAdapter implements IPersonne{private $_etudiant;public function __construct(Etudiant $etudiant){

$this->_etudiant= $etudiant;}public function Etudiant(){

return $this->_etudiant;}public function descriptionPersonne(){

$this->Etudiant()->descriptionNom();$this->Etudiant()->descriptionNiveau();

}}



Adapter : principe

// pour tester$personne[0]= new Enseignant(’bob’);$personne[1]= new Enseignant(’joe’);$personne[2]= new EtudiantAdapter(new Etudiant(’mickael’,’1ere

annee licence’));$personne[3]= new EtudiantAdapter(new Etudiant(’jack’,’2eme

annee master’));foreach ($personne as $value){

$value->descriptionPersonne();}/*le resultat est :Je m’appelle bobJe m’appelle joeJe m’appelle mickael Je suis en 1ere annee licenceJe m’appelle jack Je suis en 2eme annee master*/


Les design patterns : comportement Observer

Semantique

Problematique et solution

on veut assurer la coherence entre des classes cooperant entreelles tout en maintenant leur independance

l’objet, dont on veut suivre le changement de ses etats, doitimplementer une interface qui offre trois methodes permettant des’abonner (s’attacher, s’inscrire...), se desabonner et notifier lesabonnes

les objets qui veulent etre informes doivent implementer uneinterface qui offre une methode update()



Observer : exemple

// l’interface observer qui definit la methode update qui serautiliser pour informer les abonnes

interface Observer{public function update(Subject $subject);

}// l’interface sujet qui permet de s’inscrire a un sujet, se

desinscrire et notifier les abonnesinterface Subject{

public function subscribe(Observer $o);public function unsubscribe(Observer $o);public function notify();

}



Observer : exemple

class Match implements Subject{private $_score;private $_observers = array();public function __construct($score){

$this->setScore($score);}public function Score(){

return $this->_score;}public function setScore($score){

$this->_score = $score;$this->notify();

}


Observer : exemple

public function subscribe(Observer $o){$this->_observers[] = $o;

echo " une inscription : " . $o->Name();}public function unsubscribe(Observer $o){

$hint = array_search($o,$this->_observers,true);if ($hint){

echo " une desinscription " . $this->_observers[$hint]->Name();

unset($this->_observers[$hint]);}

}public function notify(){

for ($i=0;$i<count($this->_observers);$i++){if (isset($this->_observers[$i])){

$this->_observers[$i]->update($this);}

}}

Observer : exemple

class Footeux implements Observer{private $_name;public function __construct($name){

$this->setName($name);}public function Name(){

return $this->_name;}public function setName($name){

$this->_name = $name;}public function update(Subject $sujet){

echo ’ changement de score OM - PSG ’ . $sujet->Score();

}}


Observer : exemple$m13 = new Footeux(’Marseillais’);$p75 = new Footeux(’Parisien’);$l69 = new Footeux(’Lyonnais’);$om_psg = new Match(’0-0’);$om_psg->subscribe($m13);$om_psg->setScore(’1-0’);$om_psg->subscribe($p75);$om_psg->subscribe($l69);$om_psg->setScore(’2-0’);$om_psg->unsubscribe($p75);$om_psg->setScore(’3-0’);/* le resultat est : une inscription : Marseillaischangement de score OM - PSG 1-0une inscription : Parisienune inscription : Lyonnaischangement de score OM - PSG 2-0changement de score OM - PSG 2-0changement de score OM - PSG 2-0une desinscription Parisienchangement de score OM - PSG 3-0 */


Liens utiles

Liens utiles

Autres details et exempleshttp://design-patterns.fr/

https://fr.wikipedia.org/wiki/Patron de conception


Les Design Patterns (PHP) · Les design patterns : creation´ Factory Semantique´ Problematique et...

Documents

Transcript of Les Design Patterns (PHP) · Les design patterns : creation´ Factory Semantique´ Problematique et...