login  Naam:   Wachtwoord: 
Registreer je!
 Tutorials

Tutorials > PHP


Gegevens:
Geschreven door:
Wave6
Moeilijkheidsgraad:
Moeilijk
Hits:
11299
Punten:
Aantal punten:
 (4.5)
Aantal stemmen:
2
Stem:
Niet ingelogd
Nota's:
 Lees de nota's (10)
 



Tutorial:

Design Pattern "Factory"

1. Inleiding
2. Een blik op factory
3. Factory, een mooie oplossing
4. Andere patronen

1. Inleiding


Hallo allemaal!
Namens mij(Wesley van der Meer A.K.A D_O) Welkom op SiteMasters!
Vandaag wilde ik het gaan hebben over het ontwerp patroon Factory.
Ik denk dat er nog vele zijn in PHP land die nog nooit van Factory gehoord hebben of zelfs nog nooit gehoord hebben van ontwerppatronen.
Als jullie er wel van gehoord hebben dan klinkt MVC (model, view, controller) of Singleton waarschijnlijk wel bekend in de oren
Factory heeft het zelfde princiepe als MVC en Singleton.
Namenlijk orde en structuur in een applicatie brengen!
Als je net pas met PHP begonnen bent dan raad ik je echter eerst aan de andere tutorials te volgen
Niet dat ik kwaliteiten van beginnende programmeurs onderschat maar ontwerp patronen zijn complexe zaken en als je van plan bent verder te gaan met deze tutorial
dan is een stukje kennis van OOP (Object Orientated Programming) geen overbodige luxe!
OOP is eigenlijk wel het minste waar je wat van moet begrijpen om uberhaubt verder te kunnen!
Goed genoeg over de eisen die nodig zijn om hier mee door te kunnen!
PHP heeft verschillende ontwerp patronen.
Enkele mooie zijn MVC, Singleton, Registry, Factory, Delegation, Proxy, Facade, Builder, Adapter, Composit, Command, Iterator, Observer,
Visitor, Monitor, Scheduler, Threadpool object en het Read-Write lock.
Deze patronen zijn in te delen in de volgende categorieen:

  • Fundamental (fundamenteel) Patterns
    • Delegation
    • Proxy
    • Facade
  • Structural (structureel) Patterns
    • Adapter
    • Composit
    • Proxy
    • Facade
    • MVC
  • Creational (creŽrend) Patterns
    • Singleton
    • Registery
    • Factory
    • Builder
  • Behavorial (gedrag) Patterns
    • Iterator
    • Command
    • Observer
    • Registery
    • Visitor
  • Concurrency (gelijktijdiheid) Patterns
    • Monitor
    • Scheduler
    • Threadpool object
    • Read-Write lock

Zoals je ziet zijn er 5 categorieŽn waar allemaal patronen in staan. Soms zit een patroon in meerde categoriŽn zoals je ziet met Proxy en Facade.
Ik zou graag over deze patronen meer willen schrijven maar helaas is dit te veel om te verwerken in 1 duidelijke tutorial!
Je ziet dat Factory een creerend patroon is, lijkt mij ook wel logisch de naam zegt het al "Factory" (fabriek).
Ik had ook een tutorial kunnen schrijven over de patroon "Monitor of Adapter" maar in de toekomst zul je echter vaker Factory gebruiken.
Dan Monitor of Adapter.

Let op! Design Patterns zijn geen programmeertalen, frameworks, packages of dergelijke
Het is enkel maar een denkwijze die men hanteert om zo orde en structuur in een applicatie te krijgen

Je bent dus niet verplict om een Design pattern te gebruiken maar het kan verrekte handig zijn!


TIP: Probeer goed te bedenken wanneer je een ontwerp patroon gebruikt, het is niet altijd nodig
Gebruik dus geen ontwerp patroon voor je website waarin jij verteld hoeveel postzegels je al wel niet verzameld hebt!
Niet dat er iets mis is met postzegels verzamelen, ik probeer alleen duidelijk te maken dat je het niet hoeft te gebruiken bij kleine zaken zoals een simpele website!

Nu zul je vast en zeker de vraag stellen "Ja okay leuk en aardig maar what the hack kun je nu met Factory?!?"
Zoals ik al zei is factory een creeren patroon wat dus inhoudt dat het iets gaat creeren.
Wat gaat het creeren? Objecten!
Iedereen die wel is een class geschreven heeft, heeft hier vast en zeker ook een object van gemaakt ook wel een instantie genoemt.
Stel je eens voor jij bent bezig met een Form (formulier) class.
En je gaat het gebruiken voor een CMS of Forum of een willekeurig ander iets met veel form data.
Ga er van uit dat je bijvoorbeeld 1000 text veldjes nodig heb. Heb je dan zin om 1000 keer deze actie uit te voeren

  1. <input type="text" name="textfieldname" id="textfieldid" value="Value">

Ik niet in ieder geval. En bovendien de gene die al is met MVC gewerkt hebben weten dat het niet netjes is om HTML en PHP door elkaar te gebruiken;)
Nu zou je het kunnen doen door een mooi PHP formuliertje neer te zetten die dit voor je invult...Het idee is goed. Maar je code lijkt mij op die manier wat minder netjes
Nu moet ik eerlijk zeggen dat ik ook niet altijd volgens een patroon werk hoor! Maar als je een eigen bedrijfje hebt en je krijgt grote dure klanten.
dan wil je deze ook wat kunnen bieden! Een professionele, structurele applicatie!:D
Goed jullie begrijpen onderhand wel wat het doel is van deze tutorial het wordt nu is tijd voor een mooi voorbeeld!

pijl top
2. Een blik op factory!


  1. <?php
  2.  
  3. /**
  4. * File: FormFactory.class.php
  5. *@author: Wesley van der Meer
  6. *@date: 30 - 05 - 2009
  7. *@desc: Factory pattern for creating form elements
  8. *@pattern: Factory
  9. */
  10.  
  11. //Ik maak hier een abstract class zodat ik hem niet kan of hoef te instantieren!
  12. abstract class FormFactory {
  13.    
  14.     /*
  15.      * classe constanten
  16.      * Deze gebruik ik om te controleren wat voor een Veld ik wil genereren!
  17.      */
  18.     const TEXT = "TEXT";
  19.     const TEL = "TEL";
  20.     const MAIL = "MAIL";
  21.     const PASS = "PASS";
  22.     const BIGTEXT = "BIGTEXT";
  23.     const CHECKBOX = "CHECKBOX";
  24.  
  25.    
  26.     /*
  27.      * static function createFormObject
  28.      * Deze functie is static gedefinieerd! Dus let op de $this operator zal niet tot onze beschikking zijn
  29.      * in plaats daarvan gebruiken we self::
  30.      */
  31.    
  32.     public static function createFormObject($p_sProperty, $p_sFieldName, $p_sLabel, $p_sOptions = null) {
  33.         $oResult = null;
  34.         /*
  35.          * $oResult word ons object! Textveld, Wachtwoord veld etc..
  36.          */
  37.        
  38.         switch($p_sProperty) {
  39.             /*
  40.              * Wat willen we maken?
  41.              * Onze switch en case statement loopt hier door heen om te kijken welke waarde we hebben ingevoerd!
  42.              */
  43.             case self::TEXT :
  44.                 require_once("TextField.class.php");
  45.                 $oResult = new TextField($p_sFieldName, $p_sLabel);
  46.             break;
  47.             case self::TEL :
  48.                 require_once("PhoneField.class.php");
  49.                 $oResult = new PhoneField($p_sFieldName, $p_sLabel);
  50.             break;
  51.             case self::MAIL :
  52.                 require_once("MailField.class.php");
  53.                 $oResult = new MailField($p_sFieldName, $p_sLabel);
  54.             break;
  55.             case self::PASS :
  56.                 require_once("PasswordField.class.php");
  57.                 $oResult = new PasswordField($p_sFieldName, $p_sLabel);
  58.             break;
  59.             case self::BIGTEXT :
  60.                 require_once("BigTextField.class.php");
  61.                 $oResult = new BigTextField($p_sFieldName, $p_sLabel);
  62.             break;
  63.             case self::CHECKBOX :
  64.                 require_once("Checkbox.class.php");
  65.                 $oResult = new Checbox($p_sFieldName, $p_sLabel, $p_sOptions);
  66.                
  67.             default :
  68.                 //Exceptions is iets voor later je zou hier eventueel neer kunnen zetten
  69.                 /*
  70.                  * echo "Property is onjuist!";
  71.                  */
  72.                 throw new InvalidArgumentException("Property is onjuist".$p_sProperty.", ".$p_sFieldName);
  73.            
  74.         }
  75.         /*
  76.          * Return ons object.
  77.          */
  78.         return $oResult;
  79.     }
  80. }      
  81.        
  82. ?>

Hier boven zag je zojuist een factory class! Bestudeer deze class goed en je zult zelf de logica er van in zien!
Je ziet dat ik require_once() gebruik! Je ziet dat ik TextField.class.php etc.. gebruik. Deze classes kun je aan het einde van deze tutorial terug vinden! Let op deze classes zijn niet netjes uitgewerkt! Ik gebruik deze enkel als voorbeeld!
om het nut te laten zien van Factory!
Maar goed nu hebben we de factory class klaar maar we willen deze natuurlijk wel kunnnen gebruiken! Dat via de onderstaande methode!

  1. <?php
  2.   require("FormFactory.class.php");
  3.   FormFactory::createFormObject("TEXT","textbox1", "Naam");
  4.   FormFactory::createFormObject("TEL", "telefoon", "Telefoon");
  5.   FormFactory::createFormObject("MAIL","mail", "Mail");
  6.   FormFactory::createFormObject("PASS", "password", "Wachtwoord");
  7.   FormFactory::createFormObject("BIGTEXT", "opmerking", "Opmerking");
  8.   FormFactory::createFormObject("CHECKBOX", "checkbox", "", "optie1;optie2;optie3;optie4");
  9. ?>


Zoals je ziet roep ik onze Factory aan met FormFactory gevolgd door onze creerende methode createFormObject dus FormFactory::createFormObject(TEXTFIELD, "textbox1", "naam_en_id_van_de_txtbox");
Bestudeer dit goed en uiteindelijk zal het kwartje van zelf wel vallen!:D
Jou zou het wat kunnen opfleuren door bijvoorbeeld de parameters van FormFactory::createFormObject(TEXTFIELD, "textbox1", "naam_en_id_van_de_txtbox"); te laten vullen door een HTML formuliertje;); Die we al hebben gemaakt met onze factory;) Zo bouw je ook nog een grappige recursie op!
Dus dan zou je dit kunnen krijgen

  1. <?php
  2. if(isset($_POST['formulier_1'])) {
  3.    FormFactory::createFormObject($_POST['sField_Type'], $_POST['textbox_name_1'], $_POST['name_id']);
  4. } else {
  5.    //enkel een klein voorbeeld van wat je zou kunnen doen;)
  6.    $oHtmlForm->drawForm();
  7. }
  8. ?>
pijl top
3. Factory een mooie oplossing!


Zoals ik jullie heb uitgelegd zijn ontwerp patronen een complexe zaak! Er valt echt onwijs veel te vertellen over Factory.
Ik wil echt graag meer voorbeelden laten zien! Maar ik denk dat dit voorlopig genoeg materie is om over na te denken
Als deze tutorial een succes wordt, dan zal ik in de toekomst proberen om meerdere patronen uit te leggen!
Factory is echt geen rocket science maar wel een leuk iets om je is in te verdiepen en onthoud goed dat het geen verplicht iets is!
Maar als je echt netjes wilt programmeren en vooral voor je zelf de zaken in orde wilt hebben dan is een goed ontwerp patroon een must!
Als jullie vinden dat er iets ontbreekt hoor ik het graag!
Met opbouwende kritiek komen we samen een heel eind! Dus met afkrakende berichten doe ik niks!
Er is altijd iemand die het beter weet, en ik leer graag dus als iemand met goede aanvullingen komt
Ben ik bereid om te luisteren!
Ik hoop dat ik jullie iets heb kunnen bijpraten met deze tutorial!
Hier onder kun je alsnog even kijken naar de classes die onze factory gebruikt;)

pijl top
4. De classes!

TextField.class.php
  1. <?php
  2.  
  3. class TextField {
  4.    
  5.     private $m_sName;
  6.     private $m_sId;
  7.     private $m_sType;
  8.     private $m_sHtml;
  9.     private $m_sLabel;
  10.     private $m_sClass;
  11.    
  12.     public function __construct($p_sName, $p_sLabel) {
  13.         $this->m_sName = $p_sName;
  14.         $this->m_sId = $p_sName;
  15.         $this->m_sConfig = "string";
  16.         $this->m_sType = "text";
  17.         $this->m_sClass = "textbox";
  18.         $this->m_sLabel = $p_sLabel;
  19.         return $this->drawField();
  20.     }
  21.    
  22.     public function createField() {
  23.         $this->m_sHtml = '<span class="label">'.$this->m_sLabel.'</span>: <input type="'.$this->m_sType.'" name="'.$this->m_sName.'" id="'.$this->m_sId.'" class="'.$this->m_sClass.'" />';
  24.         $this->m_sConfig = "string";
  25.         return true;
  26.     }
  27.    
  28.    
  29.     public function drawField() {
  30.         $this->createField();
  31.         echo $this->m_sHtml;
  32.         return true;
  33.     }
  34. }
  35.  
  36. ?>

PasswordField.class.php
  1. <?php
  2.  
  3. class PasswordField {
  4.    
  5.     private $m_sName;
  6.     private $m_sId;
  7.     private $m_sType;
  8.     private $m_sHtml;
  9.     private $m_sLabel;
  10.     private $m_sClass;
  11.    
  12.     public function __construct($p_sName, $p_sLabel) {
  13.         $this->m_sName = $p_sName;
  14.         $this->m_sId = $p_sName;
  15.         $this->m_sConfig = "string";
  16.         $this->m_sType = "password";
  17.         $this->m_sClass = "textbox";
  18.         $this->m_sLabel = $p_sLabel;
  19.         return $this->drawField();
  20.     }
  21.    
  22.     public function createField() {
  23.         $this->m_sHtml = '<span class="label">'.$this->m_sLabel.'</span>: <input type="'.$this->m_sType.'" name="'.$this->m_sName.'" id="'.$this->m_sId.'" class="'.$this->m_sClass.'" />';
  24.         $this->m_sConfig = "string";
  25.         return true;
  26.     }
  27.    
  28.    
  29.     public function drawField() {
  30.         $this->createField();
  31.         echo $this->m_sHtml;
  32.         return true;
  33.     }
  34. }
  35.  
  36. ?>

PhoneField.class.php en MailField.class.php zijn gewoon de TextField.class.php met een paar controles er in.
Ik neem aan dat iedereen dat zelf ook kan verzinnen;)
Voor alsnog! Veel plezier!
pijl top

« Vorige tutorial : [OOP] Een begin maken met OOP Volgende tutorial : Pagina navigatie in PHP en MySQL »

© 2002-2022 Sitemasters.be - Regels - Laadtijd: 0.011s