Design Patterns in PHP (PHPCon Italia)
-
Upload
simone-carletti -
Category
Technology
-
view
11.693 -
download
0
description
Transcript of Design Patterns in PHP (PHPCon Italia)
Simone Carletti, Altura Labs [email protected]
Design Patterns in PHP
About me
Technical Manager in Altura Labs
The first Zend Framework Italian contributor
Addicted to Agile Development and Development Best Practices
Passionate about Object Oriented Programming
I love pizza
Simone Carletti, Altura Labs
.. and what about you?
Simone Carletti, Altura Labs
Simone Carletti, Altura Labs
What’s wrong with this code?
Nothing…
…except all!
Hard Coded Actions
Presentation mixed with business logic
Global Variables
Output mixed with elaboration
Context and responsibility conflicts
Designing object oriented software is hard, and designing reusable object-oriented software is even harder.
Design Patters (GoF)
Simone Carletti, Altura Labs
Design Patterns
Simone Carletti, Altura Labs
Design Patterns describe simple and elegant solutions to specific problems in
object oriented software design.
Simone Carletti, Altura Labs
Christopher Alexander
Simone Carletti, Altura Labs
Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.
Christopher Alexander
Simone Carletti, Altura Labs
Each pattern is a three-part rule, which expresses a relation between a certain context, a problem and a solution.
The Gang of Four
Simone Carletti, Altura Labs
Essential Elements
Pattern name A descriptive name for the pattern, in a word or two
Problem Describes the problem the pattern applies to
Solution Describes the elements and the resources along with their relationship and
responsibilities for solving the problem.
This is just an abstract description, the implementation varies according to the programming language
Consequences Results and trade-off
Simone Carletti, Altura Labs
What are Design Patterns
Solution to common development problems
Reusable successful design and architectures
Common language for developers
Simone Carletti, Altura Labs
What Design Patterns are not
The panacea for solving all development problems
Ready to use code scripts
Cut & Paste solutions
Simone Carletti, Altura Labs
Why Design Patterns?
Help you to reuse successful design and architectures
Help you to choose design alternatives
Help you to solve problems you haven’t seen before
Give a common vocabulary
Let you communicate quickly and unambiguously
Make a system more reusable
Simone Carletti, Altura Labs
Design for Changes
The key to maximizing reuse lies in anticipating
new requirements and changes to existing
requirements, and in designing your systems so
that they can evolve accordingly.
Simone Carletti, Altura Labs
Design Patterns (GoF)
Golden Rules
1. Program to an interface, not an implementation 1. Some languages takes this rule to the next level with Duck Typing
2. Favor Object Composition over Inheritance 1. Black Box approach
3. Delegate
Simone Carletti, Altura Labs
How to Select a Design Pattern
Consider how to design patterns solve design problems
Scan Intent section
Study how patterns interrelate
Study patterns of like purpose
Examine a cause of redesign
Consider what should be variable in your design
Simone Carletti, Altura Labs
How to Use a Design Pattern
Read the pattern once through for an overview
Go back and study the Structure, Participants and Collaboration sections
Look at the Sample Code section to see a concrete example of the pattern in code
Choose names for pattern participants that are meaningful in the application context
Define the classes
Define application-specific names for operations in the pattern
Implement the operations to carry out the responsibilities and collaborations in the patterns
Simone Carletti, Altura Labs
How to NOT Use a Design Pattern
Don’t try to rewrite your application to fit a Design Pattern, select the best Pattern according to your needs
Don’t use a Design Pattern because it’s cool… use a Pattern because you need it
Don’t copy/paste language-specific Pattern implementations, understand how the Pattern works and how you can implement it in your application
Simone Carletti, Altura Labs
A word of warning
Ideally, when the appropriate problem comes
along, you should trigger the design pattern and
your problem is solved.
Simone Carletti, Altura Labs
Russ Olsen, Design Patterns in Ruby
patterns : oop = notable products : algebra
The question isn't whether you'll encounter most patterns but whether you'll recognize them when they cross your path. Will you know how to cleanly solve the problem represented by the pattern, or will you stumble thought several code iterations before you find an acceptable solutions?
Simone Carletti, Altura Labs
Ship it!
Design for Changes
Do you remember? But we careful…
Simone Carletti, Altura Labs
Avoid Over-Engineering
Simone Carletti, Altura Labs
Avoid Under-Engineering
Simone Carletti, Altura Labs
Don’t fall into the “everything is a pattern” trap
Simone Carletti, Altura Labs
Frameworks vs Design Patterns
Design patterns are more abstract than frameworks
Design patterns are smaller architectural elements than frameworks
Design patterns are less specialized than frameworks
A typical framework contains several design patterns, but the reverse is never true
Simone Carletti, Altura Labs
Helpful Agile methodologies
Refactoring Do you really need this Pattern now? You Ain't Gonna Need It Refactoring to Pattern
Unit Test Always have a consistent test suite before refactoring your code
Test-Driven Development
Simone Carletti, Altura Labs
Design Pattern Classification
Simone Carletti, Altura Labs
Design Patterns by Purpose
Creational Patterns Concern the process of object creation
Structural Patterns Deal with the composition of object and classes
Behavioral Patterns Characterize the way in which classes or objects interact
Concurrency Patterns
Architectural Patterns
…
Simone Carletti, Altura Labs
Design Patterns by Scope
Class Patterns Deal with relationships between classes and their subclasses. Ex. Factory Method, Adapter, Template method…
Object Patterns Deal with object relationships. The most part of patterns are in the object scope.
Ex. Singleton, Adapter, Decorator, Proxy, Iterator, Observer…
Simone Carletti, Altura Labs
Design Patterns
Architectural MVC
Creational Singleton Factory Method
Lazy initialization
Structural Adapter Proxy
Behavioral Iterator Observer Strategy
Template Method
More Registry Mock Object
Simone Carletti, Altura Labs
Q & A (part 1/2)
Simone Carletti, Altura Labs
Design Patterns in Action
Simone Carletti, Altura Labs
Pattern Template
Problem & Solution
Considerations
In pictures
Implementation & Examples
In the Wild
Using and Abusing
Simone Carletti, Altura Labs
MVC
Simone Carletti, Altura Labs
MVC: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You want an efficient design solution to split the view from the business logic of your application
You want to keep your application reusable by splitting the design in multiple layers
The MVC pattern decouples views and models by establishing a subscribe/notify protocol between them
A view reflects the state of the model
This approach enables you to attach multiple view to a model an provide different representations
MVC: in pictures
Simone Carletti, Altura Labs
http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/
MVC: Model, View and Controller
Simone Carletti, Altura Labs
The model is the domain-specific representation of data. It usually consists in a database or some other storage system.
The view renders the model in a form suitable according to the request. This layer is commonly known with the word template.
The controller processes the requests and it’s in charge of querying the model and returning the right template according to the request.
MVC: decoupling View and Model
Simone Carletti, Altura Labs
Articles
Article::find()
XML Feed iPhone (X)HTML
$articles
$articles $articles
MVC: in the wild
Simone Carletti, Altura Labs
The most part of PHP web frameworks implement the MVC pattern, including Symfony, Zend Framework, CakePHP…
The most part of modern PHP applications inherit some principles from MVC pattern. Many applications use a template engine Many applications separate the model from the view and interact with the
database via ORM frameworks
MVC: Single Responsibility Principle
Simone Carletti, Altura Labs
Every object should have a single responsibility, and that all its services should be narrowly aligned with that responsibility.
The most frequent error using MVC is to execute operations in the wrong context
MVC: find the error (1)
Simone Carletti, Altura Labs
class BookController{ public function SuggestionsAction() { $firstChoice = Book::findAll( array( 'conditions' => array('name LIKE ?', '%'.$params['query']), 'order' => 'weight DESC' ) ); $secondChoice = Book::findAll( array( 'conditions' => array('name LIKE ?', '%'.$params['query'].'%'), 'order' => 'weight DESC' ) );
$this->choices = array_merge($firstChoice, $secondChoice); $this->render('suggestions'); }}
MVC: find the error (1/solution)
Simone Carletti, Altura Labs
// BookController represents the Book controllerclass BookController{ public function SuggestionsAction() { $this->choices = Book::findSuggestionsForKeyword($params['query']); $this->render('suggestions'); }}
// Book class represent the Book modelclass Book { public static function findSuggestionsForKeyword($query) { $firstChoice = self::findAll( array( 'conditions' => array('name LIKE ?', '%'.$params['query']), 'order' => 'weight DESC' ) ); $secondChoice = self::findAll( array( 'conditions' => array('name LIKE ?', '%'.$params['query'].'%'), 'order' => 'weight DESC' ) ); return array_merge($firstChoice, $secondChoice); }}
MVC: find the error (2)
Simone Carletti, Altura Labs
<h2>Available Tickets</h2>
<?php$tickets = Ticket::findAll(array('conditions' => array('published' => true)));
$available = array();foreach($tickets as $ticket) { if ($currentUser->isAdmin() == true || $ticket->isPublic()) { $available[] = $ticket; }}
?>
<ul><?php foreach($available as $ticket) { ?> <li><?php echo $ticket->title == '' ? 'This ticket has no title' : $ticket->title . ' ' . $ticket->price; ?></li><?php } ?></ul>
MVC: find the error (2/solution)
Simone Carletti, Altura Labs
// define formatters in your model// only when formatters are not tied to// one or more specific viewsclass Ticket { // ...
public function getFormattedTitle() { return $ticket->title == '' ? 'This ticket has no title' : $ticket->title . ' ' . $ticket->price; }}
// or delegate the responsibility to the view using helpersclass TicketsHelper{ public static function formatTitle($ticket) { return $ticket->title == '' ? 'This ticket has no title' : $ticket->title . ' ' . $ticket->price; }}
<h2>Available Tickets</h2>
<ul><?php foreach($tickets as $ticket) { ?> <li> <?php $ticket->getFormattedTitle(); ?> </li><?php } ?></ul>
<!-- or using helpers -->
<h2>Available Tickets</h2>
<ul><?php foreach($tickets as $ticket) { ?> <li> <?php TicketsHelper::formatTitle($ticket) ?> </li><?php } ?></ul>
// the controller knows about User's ACL// and runs the appropriate query through the modelclass TicketsController{ public function AvailableAction() { if ($currentUser->isAdmin()) { $tickets = Ticket::findAll(); } else { $tickets = Ticket::findAllPublic(); } $this->ticket = $tickets; }}
Controller
View
Model
Helper
Singleton
The Highlander
Simone Carletti, Altura Labs
Singleton: problem & solution
Problem
You want a class to have exactly one instance
You want the instance to be easily accessible
You don’t want to use global variables
Solution
The Singleton pattern ensures a class has only one instance, and provide a global point to access it
Simone Carletti, Altura Labs
Singleton: considerations
Simone Carletti, Altura Labs
Often used for shared objects such as configurations, queues, database connections…
You don’t want the environment to be responsible of class instantiation
You don’t want the environment to be responsible of avoid multiple class instances
The Singleton is often a mixed behavior
Singleton: implementation
Simone Carletti, Altura Labs
class Singleton { // holds the singleton instance private static $_instance = null;
// redefined as private to be called only // from within the class scope private function __construct() { }
// redefined to deny object clones public function __clone() { throw new Exception('You cannot clone Singleton object'); }
public function getInstance() { if (null === self::$_instance) { self::$_instance = new Singleton(); } return self::$_instance; }}
Singleton: example
Simone Carletti, Altura Labs
class Singleton { // holds the singleton instance private static $_instance = null;
// redefined as private to be called only // from within the class scope private function __construct() { }
// redefined to deny object clones public function __clone() { throw new Exception('You cannot clone Singleton object'); }
public function getInstance() { if (null === self::$_instance) { self::$_instance = new Singleton(); } return self::$_instance; }}
$instance = Singleton::getInstance();$instance->doSomething();
Singleton::getInstance()->doSomething();Singleton::getInstance()->doSomething()->thenSomethingElse();
Singleton: Class as Singleton
Simone Carletti, Altura Labs
You can declare methods as static and use the class as the container for the Singleton functionality
You are sure no one will create additional instances
You can’t take advantage of other patterns, such as Lazy Initialization
You don’t have control over initialization
You don’t have access to the instance context
It’s not thread safe
Singleton: Why not using Global Variables?
Simone Carletti, Altura Labs
There’s no way to control the value of a global variable
Doesn’t prevent someone from creating multiple instances
Global variables are unpredictable
Global variables are difficult to debug and test
Global variables are unsecure
Global variable makes the code difficult to read
Singleton: in the wild
Simone Carletti, Altura Labs
Pake, the Symfony PHP-make library
Doctrine_Manager, the base component of all Doctrine based projects. It opens and keeps track of all database connections
Many components of the Symfony framework, including sfContext sfAutoload
sfCultureInfo
The configuration class ConfigFile in phpMyAdmin
Singleton: using & abusing
Simone Carletti, Altura Labs
Before applying a Singleton ask yourself: do I really need a Singleton?
Look at your code, check the number of a class instances
Beware to not spread the Singleton knowledge in classes where you don’t really need to
To all intents and purposes, a Singleton instance is a normal class instance, you can pass it as a parameter
Factory Method
Simone Carletti, Altura Labs
Factory Method: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You want to create an instance of a class but you don’t know in advance the object class you need to use
You want to localize the knowledge of which class must be instantiated
The Factory Method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate.
The Factory Method defers instantiation
Factory Method: considerations
Simone Carletti, Altura Labs
It’s difficult to find in PHP an original implementation of the Factory Method as defined by the GoF
There are different variation to the original Factory Method
The GoF discussed both Factory Method and Abstract Factory
Factory Method: example
Simone Carletti, Altura Labs
public static function factory($uri = 'http'){ // Separate the scheme from the scheme-specific parts $uri = explode(':', $uri, 2); $scheme = strtolower($uri[0]); $schemeSpecific = isset($uri[1]) === true ? $uri[1] : '';
if (strlen($scheme) === 0) { require_once 'Zend/Uri/Exception.php'; throw new Zend_Uri_Exception('An empty string was supplied for the scheme'); }
// Security check: $scheme is used to load a class file, so only alphanumerics are allowed. if (ctype_alnum($scheme) === false) { require_once 'Zend/Uri/Exception.php'; throw new Zend_Uri_Exception('Illegal scheme supplied, only alphanumeric characters are permitted'); }
/** * Create a new Zend_Uri object for the $uri. If a subclass of Zend_Uri exists for the * scheme, return an instance of that class. Otherwise, a Zend_Uri_Exception is thrown. */ switch ($scheme) { /* factory pattern implementation */ }
Zend_Loader::loadClass($className); $schemeHandler = new $className($scheme, $schemeSpecific);
return $schemeHandler;}
Factory Method: example
Simone Carletti, Altura Labs
public static function factory($uri = 'http'){ // ...
switch ($scheme) { case 'http': // Break intentionally omitted case 'https': $className = 'Zend_Uri_Http'; break;
case 'mailto': // TODO default: require_once 'Zend/Uri/Exception.php'; throw new Zend_Uri_Exception("Scheme \"$scheme\" is not supported"); break; }
Zend_Loader::loadClass($className); $schemeHandler = new $className($scheme, $schemeSpecific);
return $schemeHandler;}
Factory Method: in the wild
Simone Carletti, Altura Labs
Zend_Uri::factory() returns the right Zend_Uri subclass according to the type of URI passed as parameter
Zend_Cache::factory() returns the best Zend_Cache engines according to given options and configurations
Doctrine contains several implementation of the Factory pattern. For example Doctrine_Node::factory() return node instance based upon chosen implementation
Factory Method: using & abusing
Simone Carletti, Altura Labs
Use the Factory Method only if you really need it
Don’t anticipate future needs, refactoring is usually the right choice Plans might change and you just spent time building useless, heavy
infrastructures Be Smart! Be Agile! Be Lazy!
Lazy Initialization
Lazy evaluation
Simone Carletti, Altura Labs
Lazy Initialization: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You want to delay the creation of an instance or an expensive operation until the first time it is needed
You want the operation to be executed only when and if necessary
The Lazy Initialization pattern delays the creation of an object or the execution of an expensive process until the first time it is needed
Lazy Initialization: example
Simone Carletti, Altura Labs
class PluginManager {
protected $_plugins;
public function getPlugins() { // parse list once only when needed and store it in memory if (null === $this->_plugins) { $this->_plugins = $this->parsePluginList(); } return $this->parsePluginList(); }
public function activate($class) { require_once $class; // require the class once $plugin = new $class; // only if and when needed $plugin->activate(); }
public function deactivate($class) { if (!isActive($class)) { require_once 'Plugin_Not_Active_Exception.php'; throw new PluginNotActiveException("Plugin $class not active"); } $plugin = new $class; $plugin->deactivate(); }
// check whether $class is in getPlugins() protected function isActive($class) { /* */ }
// scans a folder tree looking for plugin files // this is a really expensive operation protected function parsePluginList() { /* */ } }
Lazy Initialization: in the wild
Simone Carletti, Altura Labs
The most part of Zend_Exception classes in Zend Framework are lazy-loaded
Controller classes in Symfony, Zend Framework and (almost) every PHP Framework are lazy-loaded
Many resources in Xoops, such as the ReplacementArray, are lazy-instantiated
Drupal maintains an internal registry of functions or classes in the system, allowing it to lazy-load code files as needed
Adapter
Simone Carletti, Altura Labs
Adapter: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You want to reuse a library in your application but it doesn’t match your interface
You want to normalize multiple libraries to use the same interface
The Adapter pattern converts the interface of a class into another interface clients expect
Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces
Adapter: considerations
Simone Carletti, Altura Labs
Adapter is a common pattern when using third party libraries
If you are developing your own libraries, you might want to avoid adapters and use common habits and guidelines
Often using in cooperation with other patterns, such as the Strategy pattern
Adapt or Modify?
Adapter pattern and Proxy pattern are similar, but they have different intents. Adapter is meant to change the interface of an existing object
Adapter: example
Simone Carletti, Altura Labs
class MySQL_Connection { public static function connect($host, $user, $pass) { // main connection logic }}
class PostgreSQL { public static function do_connect($args = array()) { // main connection logic }}
class OracleCoolLibrary { public function __construct($args = array()) { // main connection logic }
public function connect() { // main connection logic }}
Adapter: example
Simone Carletti, Altura Labs
class MySQL_Adapter extends MySQL_Connection{ public static function connect($params) { $host, $user, $pass = list($params); parent::connect(array($host, $user, $pass)); }}
class PostgreSQL_Adapter extends PostgreSQL{ public static function connect($params) { self::do_connect($params); }}
class Oracle_Adapter extends OracleCoolLibrary { public static function connect($params) { $instance = new OracleCoolLibrary($params); $instance->connect(); }}
class MySQL_Connection { public static function connect($host, $user, $pass) { // main connection logic }}
class PostgreSQL { public static function do_connect($args = array()) { // main connection logic }}
class OracleCoolLibrary { public function __construct($args = array()) { // main connection logic }
public function connect() { // main connection logic }}
Adapter: in the wild
Simone Carletti, Altura Labs
Zend_Db and all the database-specific subclasses
Zend_Http_Client provides different adapters for different purposes (including a test adapter)
Doctrine DBAdapter and database-specific subclasses
Adapter: using & abusing
Simone Carletti, Altura Labs
Avoid creating adapter of adapters
Go to the main library and build the Adapter at the lowest possible level
Proxy
Simone Carletti, Altura Labs
Proxy: problem & solution
Problem
You need to provide access to an object without exposing the object directly
You want to control access to that object
You want to filter access to that object
Solution
The Proxy pattern provides a surrogate or placeholder for an other object to control access to it
Simone Carletti, Altura Labs
Proxy: considerations
The Proxy is build around a lie
You might want to expose a similar public API Remember: composition over inheritance Duck Typing or Interface
You might want to improve performance for expensive operations
Simone Carletti, Altura Labs
Proxy: example
Simone Carletti, Altura Labs
// This class represents a simple bank accountclass Account { protected $balance;
public function __construct() { }
public function deposit($amount) { $this->balance += (int) $amount; return $this; }
public function withdraw($amount) { $this->balance -= (int) $amount; return $this; }
public function getBalance() { return $this->balance; }}
Proxy: example
Simone Carletti, Altura Labs
class AccountProxy{ protected $account;
public function __construct($account) { $this->account = $account; return $this; }
public function deposit($amount) { $this->account->deposit($amount); return $this; }
public function withdraw($amount) { $this->account->withdraw($amount); return $this; }
public function getBalance() { return $this->account->getBalance(); }}
$proxy = new AccountProxy(new Account());$proxy->deposit(20)->withdraw(5);print $proxy->getBalance();
class AccountProxy{ protected $account;
public function __construct($account) { $this->account = $account; return $this; }
public function deposit($amount) { $this->account->deposit($amount); return $this; }
public function withdraw($amount) { $this->account->withdraw($amount); return $this; }
public function getBalance() { return $this->account->getBalance(); }}
Proxy: example with Lazy Instantiation pattern
Simone Carletti, Altura Labs
class AccountProxy{ protected $account;
public function deposit($amount) { $this->getAccount()->deposit($amount); return $this; }
public function withdraw($amount) { $this->getAccount()->withdraw($amount); return $this; }
public function getBalance() { return $this->getAccount()->getBalance(); }
protected function getAccount() { if (null === $this->account) { $this->account = new Account(); } return $this->account; }}
Proxy: Virtual Proxy
Simone Carletti, Altura Labs
class AccountProxy{ protected $account;
public function deposit($amount) { $this->getAccount()->deposit($amount); return $this; }
public function withdraw($amount) { $this->getAccount()->withdraw($amount); return $this; }
public function getBalance() { return $this->getAccount()->getBalance(); }
protected function getAccount() { if (null === $this->account) { $this->account = new Account(); } return $this->account; }}
account
__call
$args
$this or $value
class AccountProxy{ protected $account;
public function __call($name, $args) { $account = $this->getAccount(); if (!is_callable(array(&$account, $name))) { throw new Exception("No method $name"); }
$params = array(&$account, $name) ; $return = call_user_func_array($params, $args); return $return === $account ? $this : $return; }
protected function getAccount() { if (null === $this->account) { $this->account = new Account(); } return $this->account; }}
Proxy: in the wild
Simone Carletti, Altura Labs
PHP 5 SOAP Library has examples of Remote Proxy in the WSDL mechanism
Many classes in Symfony provide proxy methods to shorten the code needed for get/set operations $request->getParameterHolder()->set('foo', 'bar'); $request->setParameter('foo', 'bar');
Proxy: using & abusing
Simone Carletti, Altura Labs
Don’t forget to redefine special class methods accordingly __clone __get __set
__toString …
Avoid responsibility-mistakes
Be sure all classes are well documented, especially when using virtual proxies and difficult-to-auto-document features
Iterator
Simone Carletti, Altura Labs
Iterator: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You have a complex aggregate object and you want to access its elements without working on implementation
You want to traverse and manipulate a collection object
The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing the underlying representation
Iterator: considerations
Simone Carletti, Altura Labs
You might not realize it, but you use the Iterator pattern every day working with Arrays
Iterator: example
Simone Carletti, Altura Labs
$colors = array('yellow', 'orange', 'green');
foreach($colors as $color) { print "Current color: $color\n";}
$items = array( 'first' => 1, 'second' => 2, 'third' => 3, );
foreach($items as $key => $value) { print "Value $value for key $key\n";}
Iterator: SPL example
Simone Carletti, Altura Labs
class Zend_Service_Amazon_ResultSet implements SeekableIterator{ /** * A DOMNodeList of <Item> elements */ protected $_results = null;
/** * Current index for SeekableIterator */ protected $_currentIndex = 0;
/** * Implement SeekableIterator::current() * * @return Zend_Service_Amazon_Item */ public function current() { return new Zend_Service_Amazon_Item($this->_results->item($this->_currentIndex)); }
/** * Implement SeekableIterator::key() * * @return int */ public function key() { return $this->_currentIndex; }
Iterator: SPL example
Simone Carletti, Altura Labs
/** * Implement SeekableIterator::next() */ public function next() { $this->_currentIndex += 1; }
/** * Implement SeekableIterator::rewind() */ public function rewind() { $this->_currentIndex = 0; }
/** * Implement SeekableIterator::seek() */ public function seek($index) { $indexInt = (int) $index; if ($indexInt >= 0 && (null === $this->_results || $indexInt < $this->_results->length)) { $this->_currentIndex = $indexInt; } else { throw new OutOfBoundsException("Illegal index '$index'"); } }
/** * Implement SeekableIterator::valid() */ public function valid() { return null !== $this->_results && $this->_currentIndex < $this->_results->length; }}
Iterator: PHP 5 SPL
Simone Carletti, Altura Labs
SPL offers some advanced Iterator algorithms Iterator RecursiveIterator SeekableIterator
ArrayIterato
Don’t forget to have a look at the Countable interface
Iterator: in the wild
Simone Carletti, Altura Labs
PHP 5 DirectoryIterator library
Zend_Feed, Zend_Service_Amazon, Zend_Service_Technorati in the Zend Framework
Iterator: using & abusing
Simone Carletti, Altura Labs
Limit (or avoid) using iterators for changing internal object status
Don’t fall into the concurrent modification trap!
Be sure you are not altering iterator internal index
Observer
Simone Carletti, Altura Labs
Observer: OMG!
Simone Carletti, Altura Labs
class User {
protected $_logger; protected $_username;
public function __construct($username, $notifier) { $this->_username = $username;
$this->_logger = new Logger(); $this->_notifier = $notifier; }
public function setUsername($username) { $this->_username = $username;
$this->_logger->debug("$username changed username"); $this->_notifier->userChangedLogin($this); }
public function login($password) { // login login
$this->_logger->debug("$username logged in"); }}
Observer: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You want objects to interact each other without making the classes tightly coupled
You need to maintain consistency between related objects with data integrity in mind
The Observer pattern defines dependency between objects so that when one object change state, all its dependents are notified and updated automatically
Observer: implementation
Simone Carletti, Altura Labs
class Subject{ protected $_observers = array();
public function attach($observer) { $this->_objservers[] = $observer; }
public function detach($observer) { $observers = array(); foreach($this->_observers as $object) { if ($object !== $observer) { $observers[] = $object; } } $this->_observers = $observers; }
public function notify() { foreach($this->_observers as $observer) { $observer->update($this); } }}
Observer: example
Simone Carletti, Altura Labs
class User {
protected $_username; protected $_observers = array();
public function attach($observer) { // ... see implementation }
public function detach($observer) { // ... see implementation }
public function notify() { // ... see implementation }
public function setUsername($username) { $this->_username = $username; $this->notify(); }
}
$user = new User();$user->attach(new Logger());$user->attach(Notifier::getInstance());
$user->setUsername('foobar');
Observer: PHP 5 SPL
Simone Carletti, Altura Labs
SPL suggests a standard way of implementing the Observer pattern. interface SplObserver interface SplSubject class SplObjectStorage
Observer: in the wild
Simone Carletti, Altura Labs
Zend_XmlRpc_Server_Fault in Zend Framework accepts a list of observers and notifies them in case of unexpected behaviors
Observer: using & abusing
Simone Carletti, Altura Labs
Don’t notify observers if you don’t need
Consider to add specific notifications if you find yourself calling update() too many times for different kind of notifications ->update()
->save() ->delete()
Be careful to notify observers only when a consistent change is complete.
Remember, your object should provide a way to let observers know what changed
Template Method
Simone Carletti, Altura Labs
Template Method: problem & solution
Problem Solution
Simone Carletti, Altura Labs
The Template Method pattern describes the skeleton of an algorithm in an operation, deferring some steps to subclasses
Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure
You have a complex come that might vary somewhere in the middle
You want to let subclasses change part of the abstract class algorithms
You want to defer to implementations some parts of an algorithms
Template Method: considerations
Simone Carletti, Altura Labs
Template Method is based on inheritance
Strategy pattern can be considered the composition variant
Template Method: implementation
Simone Carletti, Altura Labs
abstract class AbstractClass { public final function templateMethod() { print "AbstractClass::templateMethod()\n"; $this->mandatoryMethod(); $this->optionalMethod(); }
protected abstract function mandatoryMethod();
protected function optionalMethod() { print "AbstractClass::optionalMethod()\n"; }}
class FirstConcreteClass extends AbstractClass { protected function mandatoryMethod() { print "FirstConcreteClass::mandatoryMethod()\n"; }}
class SecondConcreteClass extends AbstractClass { protected function mandatoryMethod() { print "SecondConcreteClass::mandatoryMethod()\n"; } protected function optionalMethod() { print "SecondConcreteClass::optionalMethod()\n"; }}
$o = new FirstConcreteClass;$o->templateMethod();# AbstractClass::templateMethod()# FirstConcreteClass::mandatoryMethod()# AbstractClass::optionalMethod()
$o = new SecondConcreteClass;$o->templateMethod();# AbstractClass::templateMethod()# SecondConcreteClass::mandatoryMethod()# SecondConcreteClass::optionalMethod()
Template Method: example
Simone Carletti, Altura Labs
abstract class Page{ protected $_title; protected $_content;
public function __construct($title, $content) { $this->_title = $title; $this->_content = (array) $content; }
public final function generate() { $this->generateHeader(); $this->generateTitle(); $this->generateBodyHeader(); $this->generateBody(); $this->generateBodyFooter(); $this->generateFooter(); }
protected abstract function generateHeader(); protected abstract function generateBodyHeader(); protected abstract function generateBodyFooter(); protected abstract function generateFooter(); protected abstract function generateLine($line);
protected function generateTitle() { printf("Title: %s\n", $this->_title); }
protected final function generateBody() { foreach($this->_content as $line) { $this->generateLine($line); } }}
Template Method: example
Simone Carletti, Altura Labs
class HtmlPage extends Page { protected function generateHeader() { printf("<html>\n"); } protected function generateTitle() { printf("<head><title>%s</title></head>\n", $this->_title); } protected function generateBodyHeader() { printf("<body>\n"); } protected function generateBodyFooter() { printf("</body>\n"); } protected function generateFooter() { printf("</html>\n\n"); } protected function generateLine($line) { printf($line); }}
class FeedPage extends Page { protected function generateHeader() { printf("<?xml version=\"1.0\"?>\n"); printf("<rss version=\"2.0\">\n"); printf(" <channel>\n"); } protected function generateTitle() { $title = $this->_title; printf(" <title>%s</title>\n", $title); } protected function generateBodyHeader() { } protected function generateBodyFooter() { } protected function generateFooter() { printf(" </rss>\n"); printf("</channel>\n\n"); } protected function generateLine($line) { printf(" <item><title>%s</title></item>\n", $line); }}
Template Method: example
Simone Carletti, Altura Labs
$t = 'This is the title';$c = array('First entry', 'Second entry');
$o = new FeedPage($t, $c);$o->generate();
$o = new HtmlPage($t, $c);$o->generate();
<?xml version="1.0"?><rss version="2.0"> <channel> <title>This is the title</title> <item><title>First entry</title></item> <item><title>Second entry</title></item> </rss></channel>
<html><head><title>This is the title</title></head><body>First entrySecond entry</body></html>
Template Method: in the wild
Simone Carletti, Altura Labs
Propel bases the full public API on a custom implementation of the Template Method pattern. BaseClass is the “abstract” class Class extends BaseClass and overwrites only those methods you want to
customize
Template Method: using & abusing
Simone Carletti, Altura Labs
Avoid creating abstract classes that forces concrete classes to implement tons of methods
Strategy
Simone Carletti, Altura Labs
Strategy: problem & solution
Problem Solution
Simone Carletti, Altura Labs
You have a complex operation that might vary algorithms at runtime and you want to encapsulate algorithms
You want to be able to easily test the algorithms
You want to be able to add, remove or change an algorithm without changing the global operation logic
The Strategy pattern defines a family of algorithms, encapsulate each one, and make them interchangeable
Strategy lets the algorithm vary independently from clients that use it, often at runtime level
Strategy: considerations
Simone Carletti, Altura Labs
Strategy is an excellent example of composition and delegation
Strategy is an alternative to subclassing
Strategy and Template Method patterns expose different approach to a similar problem
Duck Typing is a common practice in Strategy pattern
Strategy: example
Simone Carletti, Altura Labs
interface Sorter { public function sort();}
class SelectionSort implements Sorter{ public function sort($array) { // selection sort algorithm }}
class InsertionSort implements Sorter{ public function sort($array) { // insertion sort algorithm }}
class SuperSecretSort implements Sorter{ public function sort($array) { // insertion sort algorithm }}
class ArraySorter { protected $_a;
public function __construct($a) { $this->_a; return self; }
public function sortWithAlgorithm($algorithm) { return $algorithm->sort($this->_a); }}
$array = array('white', 'green', 'black', 'red');$sorter = new ArraySorter($a);
$sorter->sortWithAlgorithm(new SelectionSort());$sorter->sortWithAlgorithm(new InsertionSort());
Strategy: example with Lazy Instantiation
Simone Carletti, Altura Labs
class ArraySorter { protected $_a;
public function __construct($a) { $this->_a; return self; }
public function sortWithAlgorithm($algorithm) { require_once $algorithm; $sorter = new $algorithm(); return $sorter->sort($this->_a); }}
$array = array('white', 'green', 'black', 'red');$sorter = new ArraySorter($a);
$sorter->sortWithAlgorithm('SelectionSort');$sorter->sortWithAlgorithm('InsertionSort');
Strategy: in the wild
Simone Carletti, Altura Labs
Zend_Pdf_Resource_Image_Png allows different image compression strategies (work in progress)
Symfony enables you to configure different escaping strategies with the escaping_strategy variable in your configuration file
Strategy: using & abusing
Simone Carletti, Altura Labs
Make sure you are not coupling the context with a specific strategy
Be careful when using one strategy as the default one
Time is running out…
Simone Carletti, Altura Labs
… but there are many other interesting Design Patterns out of there.
Registry
Mock Object
Command
Decorator
Chain or Responsibility
Data Mapper
Active Record
Table Data Gateway and Row Data Gateway
Beyond this Presentation
Simone Carletti, Altura Labs
Literature
Simone Carletti, Altura Labs
Readings
http://www.fluffycat.com/PHP-Design-Patterns/
http://www.phppatterns.com/
http://www.devarticles.com/c/a/PHP/Introduction-to-Design-Patterns-Using-PHP/
http://www.ibm.com/developerworks/library/os-php-designptrns/
http://www.phplibrairies.com/tutorial_design-pattern_en.html
Simone Carletti, Altura Labs
Q & A (part 2/2)
Simone Carletti, Altura Labs
Thank you!
[email protected] www.simonecarletti.com
Slides will be available at www.slideshare.net/weppos
Simone Carletti, Altura Labs