Your SlideShare is downloading. ×
Design patterns in PHP
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Design patterns in PHP

1,590
views

Published on

Using common design patterns in PHP - Talk originally given at Geekdom in San Antonio, Texas, October 10, 2013

Using common design patterns in PHP - Talk originally given at Geekdom in San Antonio, Texas, October 10, 2013

Published in: Technology

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

No Downloads
Views
Total Views
1,590
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
44
Comments
0
Likes
5
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Design Patterns in PHP Jason Straughan - Grok Interactive, LLC
  • 2. What are design patterns? Wikipedia says ...a general reusable solution to a commonly occurring problem within a given context in software design...a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application.
  • 3. What are design patterns? Design patterns are concepts and best practices for solving common software development problems.
  • 4. When to use You already are using them. To solve common problems. To express architecture or solutions. Recognize in existing code.
  • 5. How to use Not plug-and-play. Implement as needed. Use in frameworks and libraries. Impress your friends.
  • 6. Common Patterns in PHP ● Factory ● Singleton ● Delegate ● Decorator ● Strategy ● Observer ● Adapter ● State ● Iterator ● Front Controller ● MVC ● Active Record
  • 7. The Factory Pattern Creates objects without having to instantiate the classes directly. Factories create objects.
  • 8. When to use the Factory Pattern Keep DRY when complex object creation needs to be reusable. Encapsulate several objects or steps into new object creation.
  • 9. class Factory { public function create_thing() { return new Thing(); } } class Thing { public function do_something() { echo 'Hello PHPeople'; } } Example of a Factory Pattern $factory = new Factory(); $thing = $factory->create_thing(); $thing->do_something(); // 'Hello PHPeople'
  • 10. Example of a Factory Pattern class SMSFactory { public function create_messenger() { // setup SMS API return new SMSMessage(); } } class SMSMessage { public function __construct() { // Setup SMS API } public function send_message($message) { // Send $message via SMS } } $factory = new SMSFactory(); $messenger = $factory->create_messenger(); $messenger->send_message('Hello PHPeople');
  • 11. The Singleton Pattern Creates object without direct instantiation and does not allow more that one instance of self. Singletons ensure only one instance of an object at any given time.
  • 12. When to use the Singleton Pattern Require only one instance of an class. Need only one connection to a server.
  • 13. Example of a Singleton Pattern $var = SomeSingleton::getInstance(); // Returns instance of SomeSingleton $var = new SomeSingleton(); // Fatal error: // Call to private SomeSingleton::__construct() class SomeSingleton { public static $instance; private function __construct() {} private function __clone() {} public static function getInstance() { if (!(self::$instance instanceof self)) { self::$instance = new self(); } return self::$instance; } }
  • 14. Example of a Singleton Pattern public static function getInstance() { if (!(self::$instance instanceof self)) { self::$instance = new self(); } return self::$instance; } ... } $db = Database::getInstance(); $db->query(...); class Database { private $db; public static $instance; private function __construct() { // code to connect to db } private function __clone() {}
  • 15. Use associated objects to perform duties to complete tasks. Delegation of tasks to helpers based on needs. The Delegate Pattern
  • 16. When to use the Delegate Pattern Object uses functionality in other classes. Remove coupling to reusable code or abstract logic and tasks.
  • 17. Example of a Delegate Pattern $delegated = new SomeDelegate(); echo $delegated->do_something(); // 'Hello PHPeople' class SomeDelegate { public function do_something() { $delegate = new Delegate(); return $delegate->output(); } } class Delegate { public function output() { return 'Hello PHPeople'; } }
  • 18. class Notifier { ... public function send_notification() { ... $this->setup_mail_client(); $this->send_email(); ... } protected function setup_mail_client() { ... } protected function send_email() { ... } } Example of a Delegate Pattern class Notifier { ... public function send_notification() { $mailer = new Mailer(); $mailer->send_email(); ... } } class Mailer { private function __construct() { $this->setup_mail_client(); } ... public function send_email() { ... } } Delegated
  • 19. The Decorator Pattern Decorators add functionality to an object without changing the object’s behavior.
  • 20. When to use the Decorator Pattern Need to add features or methods to an object that are not part of the core logic. Need extended functionality for specific use cases.
  • 21. Example of a Decorator Pattern class SomeObject { public $subject; } class SomeObjectDecorator { private $object; public function __construct(SomeObject $object) { $this->object = $object; } public function say_hello() { return "Hello {$this->object->subject}"; } } $obj = new SomeObject(); $obj->subject = 'PHPeople'; $decorated = new SomeObjectDecorator($obj); echo $decorated->say_hello(); // 'Hello PHPeople'
  • 22. class User { public $first_name = ''; public $last_name = ''; } class UserDecorator { private $user; public function __construct(User $user) { $this->user = $user; } public function full_name() { return "{$this->user->first_name} {$this->user->last_name}"; } } Example of a Decorator Pattern $user = new User(); $user->first_name = 'Chuck'; $user->last_name = 'Norris'; $decorated_user = new UserDecorator($user); echo $decorated_user->full_name(); // 'Chuck Norris'
  • 23. The Strategy Pattern “The strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable” - Wikipedia Strategy Pattern allows you to pick from a group of algorithms as needed.
  • 24. When to use the Strategy Pattern Criteria based data manipulation. ● Search result ranking ● Weighted Voting ● A/B Testing ● Environment based decisions ● Platform specific code
  • 25. Example of a Strategy Pattern switch ($message_type) { case 'email': // Send Email // Lots of code break; case 'twitter': // Send Tweet // More code here break; }
  • 26. abstract class MessageStrategy { public function __construct() {} public function send_message($message) {} } class EmailMessageStrategy extends MessageStrategy { function send_message($message) { // send email message } } class TwitterMessageStrategy extends MessageStrategy { function send_message($message) { // send tweet } } Example of a Strategy Pattern class Message { public $messaging_method; function __construct(MessageStrategy $messaging_strategy) { $this->messaging_method = $messaging_strategy; } } $message = new Message(new EmailMessageStrategy()); $message->messaging_method->send_message('Hello PHPeople');
  • 27. Objects (subjects) register other objects (observers) that react to state changes of their subject. Observers look for changes and do something. The Observer Pattern
  • 28. When to use the Observer Pattern State changes of an object affect other objects or datasets. ● Event handling ● Data persistence ● Logging
  • 29. Observer Pattern in PHP using the SPL SplSubject { /* Methods */ abstract public void attach ( SplObserver $observer ) abstract public void detach ( SplObserver $observer ) abstract public void notify ( void ) } SplObserver { /* Methods */ abstract public void update ( SplSubject $subject ) }
  • 30. class Subject implements SplSubject { public $observers = array(); public $output = null; public function attach (SplObserver $observer ) { $this->observers[] = $observer; } public function detach (SplObserver $observer ) { $this->observers = array_diff($this->observers, array($observer)); } public function notify ( ) { foreach($this->observers as $observer) { $observer->update($this); } } } Example of a Observer Pattern (w/ SPL) class Observer implements SplObserver { public function update (SplSubject $subject ) { echo $subject->output; } } $subject = new Subject; $subject->attach(new Observer); $subject->notify(); // Null $subject->output = "Hello PHPeople"; $subject->notify(); // 'Hello PHPeople'
  • 31. Review Design Pattern are: ● Reusable concepts ● Best practice solutions ● Tried and true methods
  • 32. Continuing Education Design Patterns: Elements of Reusable Object- Oriented Software Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides Code and Slides provided online https://github.com/GrokInteractive/php_design_patterns_talk
  • 33. ?>