Design Patterns in PHP
Simone Carletti, Altura Labs
weppos@weppos.net

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

Hard Coded Actions
Global Variables
What’s wrong with this code?
Nothing…
Context and responsibility conflicts
…except all!
Output mixed with
Presentation mixed
elaboration
with business logic
Simone Carletti, Altura Labs

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

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.
Christopher Alexander
Simone Carletti, Altura Labs

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.
Design Patterns (GoF)
Simone Carletti, Altura Labs

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.
Russ Olsen, Design Patterns in Ruby
Simone Carletti, Altura Labs

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?
Ship it!
Simone Carletti, Altura Labs

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  Behavioral
 MVC  Iterator
 Observer
 Creational
 Strategy
 Singleton
 Template Method
 Factory Method
 More
 Lazy initialization
 Registry
 Structural
 Mock Object
 Adapter
 Proxy
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
 You want an efficient design  The MVC pattern decouples
solution to split the view from views and models by
the business logic of your establishing a subscribe/notify
application protocol between them
 You want to keep your  A view reflects the state of the
application reusable by model
splitting the design in multiple
 This approach enables you to
layers
attach multiple view to a
model an provide different
representations
Simone Carletti, Altura Labs

MVC: in pictures
http://betterexplained.com/articles/intermediate-rails-understanding-models-
views-and-controllers/
Simone Carletti, Altura Labs

MVC: Model, View and Controller
 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.
Simone Carletti, Altura Labs

MVC: decoupling View and Model
XML Feed (X)HTML iPhone
$articles $articles
$articles
Articles
Article::find()
Simone Carletti, Altura Labs

MVC: in the wild
 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
Simone Carletti, Altura Labs

MVC: Single Responsibility Principle
 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
Simone Carletti, Altura Labs

MVC: find the error (1)
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');
}
}
Simone Carletti, Altura Labs

MVC: find the error (1/solution)
// BookController represents the Book controller
class BookController
{
public function SuggestionsAction()
{
$this->choices = Book::findSuggestionsForKeyword($params['query']);
$this->render('suggestions');
}
}
// Book class represent the Book model
class 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);
}
}
Simone Carletti, Altura Labs

MVC: find the error (2)
<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>
Simone Carletti, Altura Labs

Controller
MVC: find the error (2/solution) // the controller knows about User's ACL
// and runs the appropriate query through the model
class TicketsController
// define formatters in your model
{
// only when formatters are not tied to
public function AvailableAction()
// one or more specific views
{
class Ticket Model if ($currentUser->isAdmin()) {
{
$tickets = Ticket::findAll();
// ...
} else {
$tickets = Ticket::findAllPublic();
public function getFormattedTitle()
}
{
$this->ticket = $tickets;
return $ticket->title == '' ?
}
'This ticket has no title' :
}
$ticket->title .
''.
View
$ticket->price;
<h2>Available Tickets</h2>
}
Helper
}
<ul>
<?php foreach($tickets as $ticket) { ?>
// or delegate the responsibility to the view using
<li>
helpers
<?php $ticket->getFormattedTitle(); ?>
class TicketsHelper
</li>
{
<?php } ?>
public static function formatTitle($ticket)
</ul>
{
return $ticket->title == '' ?
<!-- or using helpers -->
'This ticket has no title' :
$ticket->title .
<h2>Available Tickets</h2>
''.
$ticket->price;
<ul>
}
<?php foreach($tickets as $ticket) { ?>
}
<li>
<?php TicketsHelper::formatTitle($ticket) ?>
</li>
<?php } ?>
Simone Carletti, Altura Labs </ul>

Singleton
The Highlander
Simone Carletti, Altura Labs

Singleton: problem & solution
Problem Solution
 You want a class to have  The Singleton pattern ensures
exactly one instance a class has only one instance,
and provide a global point to
 You want the instance to be access it
easily accessible
 You don’t want to use global
variables
Simone Carletti, Altura Labs

Singleton: considerations
 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
Simone Carletti, Altura Labs

Singleton: implementation
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;
}
}
Simone Carletti, Altura Labs

Singleton: example
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();
Simone Carletti, Altura Labs

Singleton: Class as Singleton
 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
Simone Carletti, Altura Labs

Singleton: Why not using Global Variables?
 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
Simone Carletti, Altura Labs

Singleton: in the wild
 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
Simone Carletti, Altura Labs

Singleton: using & abusing
 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
Simone Carletti, Altura Labs

Factory Method
Simone Carletti, Altura Labs

Factory Method: problem & solution
Problem Solution
 You want to create an  The Factory Method pattern
instance of a class but you defines an interface for
don’t know in advance the creating an object, but lets
object class you need to use subclasses decide which
class to instantiate.
 You want to localize the
knowledge of which class  The Factory Method defers
must be instantiated instantiation
Simone Carletti, Altura Labs

Factory Method: considerations
 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
Simone Carletti, Altura Labs

Factory Method: example
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;
}
Simone Carletti, Altura Labs

Factory Method: example
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;
}
Simone Carletti, Altura Labs

Factory Method: in the wild
 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
Simone Carletti, Altura Labs

Factory Method: using & abusing
 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!
Simone Carletti, Altura Labs

Lazy Initialization
Lazy evaluation
Simone Carletti, Altura Labs

Lazy Initialization: problem & solution
Problem Solution
 You want to delay the creation  The Lazy Initialization pattern
of an instance or an delays the creation of an
expensive operation until the object or the execution of an
first time it is needed expensive process until the
first time it is needed
 You want the operation to be
executed only when and if
necessary
Simone Carletti, Altura Labs

Lazy Initialization: example
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() { /* */ }
}
Simone Carletti, Altura Labs

Lazy Initialization: in the wild
 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
Simone Carletti, Altura Labs

Adapter
Simone Carletti, Altura Labs

Adapter: problem & solution
Problem Solution
 You want to reuse a library in  The Adapter pattern converts
your application but it doesn’t the interface of a class into
match your interface another interface clients
expect
 You want to normalize
multiple libraries to use the  Adapter lets classes work
same interface together that couldn’t
otherwise because of
incompatible interfaces
Simone Carletti, Altura Labs

Adapter: considerations
 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
Simone Carletti, Altura Labs

Adapter: example
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
}
}
Simone Carletti, Altura Labs

Adapter: example
class MySQL_Connection class MySQL_Adapter extends MySQL_Connection
{ {
public static function connect($host, $user, $pass) public static function connect($params)
{ {
// main connection logic $host, $user, $pass = list($params);
} parent::connect(array($host, $user, $pass));
} }
}
class PostgreSQL class PostgreSQL_Adapter extends PostgreSQL
{ {
public static function do_connect($args = array()) public static function connect($params)
{ {
// main connection logic self::do_connect($params);
} }
} }
class OracleCoolLibrary class Oracle_Adapter extends OracleCoolLibrary
{ {
public function __construct($args = array()) public static function connect($params)
{ {
// main connection logic $instance = new OracleCoolLibrary($params);
} $instance->connect();
}
public function connect() }
{
// main connection logic
}
}
Simone Carletti, Altura Labs

Adapter: in the wild
 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
Simone Carletti, Altura Labs

Adapter: using & abusing
 Avoid creating adapter of adapters
 Go to the main library and build the Adapter at the lowest possible
level
Simone Carletti, Altura Labs

Proxy
Simone Carletti, Altura Labs

Proxy: problem & solution
Problem Solution
 You need to provide access to  The Proxy pattern provides a
an object without exposing the surrogate or placeholder for
object directly an other object to control
access to it
 You want to control access to
that object
 You want to filter access to
that object
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
// This class represents a simple bank account
class 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;
}
}
Simone Carletti, Altura Labs

Proxy: example
class AccountProxy $proxy = new AccountProxy(new Account());
{ $proxy->deposit(20)->withdraw(5);
protected $account; print $proxy->getBalance();
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();
}
}
Simone Carletti, Altura Labs

Proxy: example with Lazy Instantiation pattern
class AccountProxy class AccountProxy
{ {
protected $account; protected $account;
public function __construct($account) public function deposit($amount)
{ {
$this->account = $account; $this->getAccount()->deposit($amount);
return $this; return $this;
} }
public function deposit($amount) public function withdraw($amount)
{ {
$this->account->deposit($amount); $this->getAccount()->withdraw($amount);
return $this; return $this;
} }
public function withdraw($amount) public function getBalance()
{ {
$this->account->withdraw($amount); return $this->getAccount()->getBalance();
return $this; }
}
protected function getAccount()
public function getBalance() {
{ if (null === $this->account) {
return $this->account->getBalance(); $this->account = new Account();
} }
} return $this->account;
}
}
Simone Carletti, Altura Labs

Proxy: Virtual Proxy
class AccountProxy class AccountProxy
account
{ {
protected $account; protected $account;
$args
public function deposit($amount) public function __call($name, $args)
{ {
$this->getAccount()->deposit($amount); $account = $this->getAccount();
return $this; if (!is_callable(array(&$account, $name))) {
} throw new Exception(\"No method $name\");
__call }
public function withdraw($amount)
$this{ $value
or $params = array(&$account, $name) ;
$this->getAccount()->withdraw($amount); $return = call_user_func_array($params, $args);
return $this; return $return === $account ? $this : $return;
} }
public function getBalance() protected function getAccount()
{ {
return $this->getAccount()->getBalance(); if (null === $this->account) {
} $this->account = new Account();
}
protected function getAccount() return $this->account;
{ }
if (null === $this->account) { }
$this->account = new Account();
}
return $this->account;
}
}
Simone Carletti, Altura Labs

Proxy: in the wild
 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');
Simone Carletti, Altura Labs

Proxy: using & abusing
 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
Simone Carletti, Altura Labs

Iterator
Simone Carletti, Altura Labs

Iterator: problem & solution
Problem Solution
 You have a complex  The Iterator pattern provides a
aggregate object and you way to access the elements of
want to access its elements an aggregate object
without working on sequentially without exposing
implementation the underlying representation
 You want to traverse and
manipulate a collection object
Simone Carletti, Altura Labs

Iterator: considerations
 You might not realize it, but you use the Iterator pattern every day
working with Arrays
Simone Carletti, Altura Labs

Iterator: example
$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\";
}
Simone Carletti, Altura Labs

Iterator: SPL example
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;
}
Simone Carletti, Altura Labs

Iterator: SPL example
/**
* 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;
}
}
Simone Carletti, Altura Labs

Iterator: PHP 5 SPL
 SPL offers some advanced Iterator algorithms
 Iterator
 RecursiveIterator
 SeekableIterator
 ArrayIterato
 Don’t forget to have a look at the Countable interface
Simone Carletti, Altura Labs

Iterator: in the wild
 PHP 5 DirectoryIterator library
 Zend_Feed, Zend_Service_Amazon, Zend_Service_Technorati in
the Zend Framework
Simone Carletti, Altura Labs

Iterator: using & abusing
 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
Simone Carletti, Altura Labs

Observer
Simone Carletti, Altura Labs

Observer: OMG!
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\");
}
}
Simone Carletti, Altura Labs

Observer: problem & solution
Problem Solution
 You want objects to interact  The Observer pattern defines
each other without making the dependency between objects
classes tightly coupled so that when one object
change state, all its
 You need to maintain
dependents are notified and
consistency between related
updated automatically
objects with data integrity in
mind
Simone Carletti, Altura Labs

Observer: implementation
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);
}
}
}
Simone Carletti, Altura Labs

Observer: example
class User { $user = new User();
$user->attach(new Logger());
protected $_username; $user->attach(Notifier::getInstance());
protected $_observers = array();
$user->setUsername('foobar');
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();
}
}
Simone Carletti, Altura Labs

Observer: PHP 5 SPL
 SPL suggests a standard way of implementing the Observer
pattern.
 interface SplObserver
 interface SplSubject
 class SplObjectStorage
Simone Carletti, Altura Labs

Observer: in the wild
 Zend_XmlRpc_Server_Fault in Zend Framework accepts a list of
observers and notifies them in case of unexpected behaviors
Simone Carletti, Altura Labs

Observer: using & abusing
 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
Simone Carletti, Altura Labs

Template Method
Simone Carletti, Altura Labs

Template Method: problem & solution
Problem Solution
 You have a complex come  The Template Method pattern
that might vary somewhere in describes the skeleton of an
the middle algorithm in an operation,
deferring some steps to
 You want to let subclasses
subclasses
change part of the abstract
class algorithms  Template Method lets
subclasses redefine certain
 You want to defer to steps of an algorithm without
implementations some parts
changing the algorithm’s
of an algorithms
structure
Simone Carletti, Altura Labs

Template Method: considerations
 Template Method is based on inheritance
 Strategy pattern can be considered the composition variant
Simone Carletti, Altura Labs

Template Method: implementation
abstract class AbstractClass
{
public final function templateMethod()
{
print \"AbstractClass::templateMethod()\\n\";
$this->mandatoryMethod();
$this->optionalMethod();
}
protected abstract function mandatoryMethod();
$o = new FirstConcreteClass;
$o->templateMethod();
protected function optionalMethod()
# AbstractClass::templateMethod()
{
# FirstConcreteClass::mandatoryMethod()
print \"AbstractClass::optionalMethod()\\n\";
# AbstractClass::optionalMethod()
}
}
$o = new SecondConcreteClass;
$o->templateMethod();
class FirstConcreteClass extends AbstractClass
# AbstractClass::templateMethod()
{
# SecondConcreteClass::mandatoryMethod()
protected function mandatoryMethod() {
# SecondConcreteClass::optionalMethod()
print \"FirstConcreteClass::mandatoryMethod()\\n\";
}
}
class SecondConcreteClass extends AbstractClass
{
protected function mandatoryMethod() {
print \"SecondConcreteClass::mandatoryMethod()\\n\";
}
protected function optionalMethod() {
print \"SecondConcreteClass::optionalMethod()\\n\";
}
}
Simone Carletti, Altura Labs

Template Method: example
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);
}
}
}
Simone Carletti, Altura Labs

Template Method: example
class FeedPage extends Page { class HtmlPage extends Page {
protected function generateHeader() { protected function generateHeader() {
printf(\"<?xml version=\\\"1.0\\\"?>\\n\"); printf(\"<html>\\n\");
printf(\"<rss version=\\\"2.0\\\">\\n\"); }
printf(\" <channel>\\n\"); protected function generateTitle() {
} printf(\"<head><title>%s</title></head>\\n\",
protected function generateTitle() { $this->_title);
$title = $this->_title; }
printf(\" <title>%s</title>\\n\", $title); protected function generateBodyHeader() {
} printf(\"<body>\\n\");
protected function generateBodyHeader() { }
} protected function generateBodyFooter() {
protected function generateBodyFooter() { printf(\"</body>\\n\");
} }
protected function generateFooter() { protected function generateFooter() {
printf(\" </rss>\\n\"); printf(\"</html>\\n\\n\");
printf(\"</channel>\\n\\n\"); }
} protected function generateLine($line) {
protected function generateLine($line) { printf($line);
printf(\" <item><title>%s</title></item>\\n\", }
$line); }
}
}
Simone Carletti, Altura Labs

Template Method: example
$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>
Simone Carletti, Altura Labs

Template Method: in the wild
 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
Simone Carletti, Altura Labs

Template Method: using & abusing
 Avoid creating abstract classes that forces concrete classes to
implement tons of methods
Simone Carletti, Altura Labs

Strategy
Simone Carletti, Altura Labs

Strategy: problem & solution
Problem Solution
 You have a complex operation  The Strategy pattern defines a
that might vary algorithms at family of algorithms,
runtime and you want to encapsulate each one, and
encapsulate algorithms make them interchangeable
 You want to be able to easily  Strategy lets the algorithm
test the algorithms vary independently from
clients that use it, often at
 You want to be able to add, runtime level
remove or change an
algorithm without changing
the global operation logic
Simone Carletti, Altura Labs

Strategy: considerations
 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
Simone Carletti, Altura Labs

Strategy: example
interface Sorter { class ArraySorter
public function sort(); {
} protected $_a;
class SelectionSort implements Sorter public function __construct($a)
{ {
public function sort($array) $this->_a;
{ return self;
// selection sort algorithm }
}
} public function sortWithAlgorithm($algorithm)
{
class InsertionSort implements Sorter return $algorithm->sort($this->_a);
{ }
public function sort($array) }
{
// insertion sort algorithm
}
} $array = array('white', 'green', 'black', 'red');
$sorter = new ArraySorter($a);
class SuperSecretSort implements Sorter
{ $sorter->sortWithAlgorithm(new SelectionSort());
public function sort($array) $sorter->sortWithAlgorithm(new InsertionSort());
{
// insertion sort algorithm
}
}
Simone Carletti, Altura Labs

Strategy: example with Lazy Instantiation
class ArraySorter $array = array('white', 'green', 'black', 'red');
{ $sorter = new ArraySorter($a);
protected $_a;
$sorter->sortWithAlgorithm('SelectionSort');
public function __construct($a) $sorter->sortWithAlgorithm('InsertionSort');
{
$this->_a;
return self;
}
public function sortWithAlgorithm($algorithm)
{
require_once $algorithm;
$sorter = new $algorithm();
return $sorter->sort($this->_a);
}
}
Simone Carletti, Altura Labs

Strategy: in the wild
 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
Simone Carletti, Altura Labs

Strategy: using & abusing
 Make sure you are not coupling the context with a specific strategy
 Be careful when using one strategy as the default one
Simone Carletti, Altura Labs

Time is running out…
… 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
Simone Carletti, Altura Labs

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!
weppos@weppos.net
www.simonecarletti.com
Slides will be available at
www.slideshare.net/weppos
Simone Carletti, Altura Labs