Design Patterns in PHP
Upcoming SlideShare
Loading in...5
×
 

Design Patterns in PHP

on

  • 2,449 views

Design patterns in PHP

Design patterns in PHP

Statistics

Views

Total Views
2,449
Views on SlideShare
2,443
Embed Views
6

Actions

Likes
9
Downloads
132
Comments
0

4 Embeds 6

http://www.slideshare.net 3
http://www.lmodules.com 1
http://www.linkedin.com 1
http://www.scoop.it 1

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Design Patterns in PHP Design Patterns in PHP Presentation Transcript

  •     PHP Design Patterns By,         Biju T    
  • ­ What are design patterns and what it's not ­ Common design patterns ­ Sample cases    
  • 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.  
  • What it's not? ­ Design patterns are for Java Developers. ­ It's exclusive to software architectures. ­ It's for larger applications.
  • 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.
  • Patterns • The factory pattern • The singleton pattern • The observer pattern • The chain­of­command pattern • The strategy pattern
  • 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.
  • .. 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.
  • <?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; ); ?>
  • .. UML for the above code:
  • 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.
  • <?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 %
  • 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.
  • <?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; ); ?>
  • .. 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.
  • 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.
  • <?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;     }   } }
  • 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 ); ?>
  • .. UML for the pattern: % php chain.php  UserCommand handling 'addUser' MailCommand handling 'mail' %
  • 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.
  • <?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;   } }
  • 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 );
  • .. UML for the pattern: % php strategy.php  Array (     [0] => Jack     [1] => Lori     [2] => Megan ) Array (     [0] => Andy     [1] => Megan ) %
  •                          Thank You :­)