Design Patterns in PHP

1,622 views
1,570 views

Published on

Design patterns in PHP

0 Comments
9 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
1,622
On SlideShare
0
From Embeds
0
Number of Embeds
10
Actions
Shares
0
Downloads
137
Comments
0
Likes
9
Embeds 0
No embeds

No notes for slide

Design Patterns in PHP

  1. 1.     PHP Design Patterns By,         Biju T    
  2. 2. ­ What are design patterns and what it's not ­ Common design patterns ­ Sample cases    
  3. 3. What are Design Patterns? ­ Is a reusable solution to a commonly occurring problem in  software design. ­ Design patterns deal specifically with problems at the level of  software design. Other kinds of patterns, such as architectural  patterns, describe problems and solutions that have alternative  scopes. ­ It's like patterns for architects designing building. ­ These patterns evolved as solutions to commonly occurring  problems in S/W design. ­ They are developed by experts who has years of experience in  designing systems.  
  4. 4. What it's not? ­ Design patterns are for Java Developers. ­ It's exclusive to software architectures. ­ It's for larger applications.
  5. 5. What it for? ­ Design patterns provides useful ways for developing  robust software faster. ­ Helps in encapsulating large ideas in friendly terms. ­ In small examples they look like overkill. They really  come into play in large code bases. ­ Most good applications start small and becoming big, so  start with solid coding practices.   ­ Patterns are great ideas you can use in any  programming language and at any skill level.
  6. 6. Patterns • The factory pattern • The singleton pattern • The observer pattern • The chain­of­command pattern • The strategy pattern
  7. 7. 1. Factory Pattern Case :  You change one part of the code and code breaks  on other parts of the system. Problem : Tight coupling Functions and classes in one part of the system rely too  heavily on behaviours and structures in other functions and  classes in other parts of the system. Solution : You need patterns that let these classes talk  each other.
  8. 8. .. Eg Case:  Suppose you have a User class that reads from a file. You  want to change it to a different class that reads from the  database, but all the code references the original class that  reads from a file.  ­ Factory pattern will be handy in case. ­ The factory pattern is a class that has some methods that  create objects for you.
  9. 9. <?php interface IUser {   function getName(); } class User implements IUser {   public function __construct( $id ) { }   public function getName()   {     return quot;Jackquot;;   } } class UserFactory {   public static function Create( $id )   {     return new User( $id );   } } $uo = UserFactory::Create( 1 ); echo( $uo­>getName().quot;nquot; ); ?>
  10. 10. .. UML for the above code:
  11. 11. 2. Singleton Pattern Case : Some application resources are exclusive in that  there is one and only one of this type of resource to  minimize resource use. Eg, the connection to a database through the database  handle is exclusive Problem : You want to share the database handle in an  application because it's an overhead to keep opening  and closing connections, particularly during a single  page fetch.
  12. 12. <?php require_once(quot;DB.phpquot;); class DatabaseConnection {   public static function get()   {     static $db = null;     if ( $db == null )       $db = new DatabaseConnection();     return $db;   }   private $_handle = null;   private function __construct()   {     $dsn = 'mysql://root:password@localhost/photos';     $this­>_handle =& DB::Connect( $dsn, array() );   }      public function handle()   {     return $this­>_handle;   } } print( quot;Handle = quot;.DatabaseConnection::get()­>handle().quot;nquot; ); print( quot;Handle = quot;.DatabaseConnection::get()­>handle().quot;nquot; ); ?> Output : % php singleton.php  Handle = Object id #3 Handle = Object id #3 %
  13. 13. 3. Observer Pattern ­ Another pattern to avoid tight coupling ­ One object makes itself observable by adding a method that  allows another object, the observer, to register itself. When  the observable object changes, it sends a message to the  registered observers. ­ Observable object is doesn't know what the observer object  is going to do.
  14. 14. <?php interface IObserver {   function onChanged( $sender, $args ); } interface IObservable {   function addObserver( $observer ); } class UserList implements IObservable {   private $_observers = array();   public function addCustomer( $name )   {     foreach( $this­>_observers as $obs )       $obs­>onChanged( $this, $name );   }   public function addObserver( $observer )   {     $this­>_observers []= $observer;   } } class UserListLogger implements IObserver {   public function onChanged( $sender, $args )   {     echo( quot;'$args' added to user listnquot; );   } } $ul = new UserList(); $ul­>addObserver( new UserListLogger() ); $ul­>addCustomer( quot;Jackquot; ); ?>
  15. 15. .. UML for the code: ­ This pattern isn't limited to objects in memory. It's the      underpinning of the database­driven message queuing       systems used in larger applications.
  16. 16. 4. Chain­of­command Pattern ­ Building on the loose­coupling theme, the chain­of­ command pattern routes a message, command, request,  or whatever you like through a set of handlers.  ­ Each handler decides for itself whether it can handle the  request.
  17. 17. <?php interface ICommand {   function onCommand( $name, $args ); } class CommandChain {   private $_commands = array();   public function addCommand( $cmd )   {     $this­>_commands []= $cmd;   }   public function runCommand( $name, $args )   {     foreach( $this­>_commands as $cmd )     {       if ( $cmd­>onCommand( $name, $args ) )         return;     }   } }
  18. 18. class UserCommand implements ICommand {   public function onCommand( $name, $args )   {     if ( $name != 'addUser' ) return false;     echo( quot;UserCommand handling 'addUser'nquot; );     return true;   } } class MailCommand implements ICommand {   public function onCommand( $name, $args )   {     if ( $name != 'mail' ) return false;     echo( quot;MailCommand handling 'mail'nquot; );     return true;   } } $cc = new CommandChain(); $cc­>addCommand( new UserCommand() ); $cc­>addCommand( new MailCommand() ); $cc­>runCommand( 'addUser', null ); $cc­>runCommand( 'mail', null ); ?>
  19. 19. .. UML for the pattern: % php chain.php  UserCommand handling 'addUser' MailCommand handling 'mail' %
  20. 20. 5. Strategy Pattern ­ In this pattern algorithms are extracted from  complex classes and made as separate class  so that they can be replaced easily. ­ It would be great for complex data  management systems that needs flexibility.
  21. 21. <?php interface IStrategy {   function filter( $record ); } class FindAfterStrategy implements IStrategy {   private $_name;   public function __construct( $name )   {     $this­>_name = $name;   }   public function filter( $record )   {     return strcmp( $this­>_name, $record ) <= 0;   } } class RandomStrategy implements IStrategy {   public function filter( $record )   {     return rand( 0, 1 ) >= 0.5;   } }
  22. 22. class UserList {   private $_list = array();   public function __construct( $names )   {     if ( $names != null )     {       foreach( $names as $name )       {         $this­>_list []= $name;       }     }   }   public function add( $name )   {     $this­>_list []= $name;   }   public function find( $filter )   {     $recs = array();     foreach( $this­>_list as $user )     {       if ( $filter­>filter( $user ) )         $recs []= $user;     }     return $recs;   } } $ul = new UserList( array( quot;Andyquot;, quot;Jackquot;, quot;Loriquot;, quot;Meganquot; ) ); $f1 = $ul­>find( new FindAfterStrategy( quot;Jquot; ) ); print_r( $f1 ); $f2 = $ul­>find( new RandomStrategy() ); print_r( $f2 );
  23. 23. .. UML for the pattern: % php strategy.php  Array (     [0] => Jack     [1] => Lori     [2] => Megan ) Array (     [0] => Andy     [1] => Megan ) %
  24. 24.                          Thank You :­)

×