Design Patterns in PHP (PHPCon Italia 2009)

Simone Carletti, Altura Labs
[email protected]
Design Patterns in PHP

View Slide

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

View Slide

.. and what about you?

View Slide

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

View Slide

Designing object oriented software is hard,
and designing reusable object-oriented
software is even harder.
Design Patters (GoF)

View Slide

Design Patterns

View Slide

Design Patterns describe simple and
elegant solutions to specific problems in
object oriented software design.

View Slide

Christopher Alexander
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.

View Slide

Christopher Alexander
Each pattern is a three-part rule, which
expresses a relation between a certain
context, a problem and a solution.

View Slide

The Gang of Four

View Slide

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

View Slide

What are Design Patterns
  Solution to common development problems
  Reusable successful design and architectures
  Common language for developers

View Slide

What Design Patterns are not
  The panacea for solving all development problems
  Ready to use code scripts
  Cut & Paste solutions

View Slide

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

View Slide

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)

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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!

View Slide

Design for Changes
Do you remember? But we careful…

View Slide

Avoid Over-Engineering

View Slide

Avoid Under-Engineering

View Slide

Don’t fall into the
“everything is a pattern” trap

View Slide

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

View Slide

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

View Slide

Design Pattern Classification

View Slide

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
  …

View Slide

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…

View Slide

Design Patterns
  Architectural
  MVC
  Creational
  Singleton
  Factory Method
  Lazy initialization
  Structural
  Adapter
  Proxy
  Behavioral
  Iterator
  Observer
  Strategy
  Template Method
  More
  Registry
  Mock Object

View Slide

Q & A
(part 1/2)

View Slide

Design Patterns in Action

View Slide

Pattern Template
  Problem & Solution
  Considerations
  In pictures
  Implementation & Examples
  In the Wild
  Using and Abusing

View Slide

MVC

View Slide

MVC: problem & solution
Problem Solution
  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

View Slide

MVC: in pictures
http://betterexplained.com/articles/intermediate-rails-understanding-models-
views-and-controllers/

View Slide

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.

View Slide

MVC: decoupling View and Model
Articles
Article::find()
XML Feed iPhone
(X)HTML
$articles
$articles
$articles

View Slide

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

View Slide

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

View Slide

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'].'%'),
)
);
$this->choices = array_merge($firstChoice, $secondChoice);
$this->render('suggestions');
}
}

View Slide

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']),
)
);
$secondChoice = self::findAll(
array(
'conditions' => array('name LIKE ?', '%'.
$params['query'].'%'),
)
);
return array_merge($firstChoice, $secondChoice);
}
}

View Slide

MVC: find the error (2)
Available Tickets
$tickets = Ticket::findAll(array('conditions' => array('published' => true)));
$available = array();
foreach($tickets as $ticket) {
if ($currentUser->isAdmin() == true || $ticket->isPublic()) {
$available[] = $ticket;
}
}
?>

title == '' ?
'This ticket has no title' :
$ticket->title . ' ' . $ticket->price; ?>

View Slide

MVC: find the error (2/solution)
// define formatters in your model
// only when formatters are not tied to
// one or more specific views
class Ticket
{
// ...
public function getFormattedTitle()
{
return $ticket->title == '' ?
$ticket->title .
' ' .
$ticket->price;
}
}
// or delegate the responsibility to the view using
helpers
class TicketsHelper
{
public static function formatTitle($ticket)
{
return $ticket->title == '' ?
$ticket->title .
' ' .
$ticket->price;
}
}
Available Tickets

getFormattedTitle(); ?>

Available Tickets

// the controller knows about User's ACL
// and runs the appropriate query through the model
class TicketsController
{
public function AvailableAction()
{
if ($currentUser->isAdmin()) {
$tickets = Ticket::findAll();
} else {
$tickets = Ticket::findAllPublic();
}
$this->ticket = $tickets;
}
}
Controller
View
Model
Helper

View Slide

Singleton
The Highlander

View Slide

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

View Slide

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

View Slide

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; 
} 
}

View Slide

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(); 

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

Factory Method

View Slide

Factory Method: problem & solution
Problem Solution
  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

View Slide

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

View Slide

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) {
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;
}

View Slide

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:
throw new Zend_Uri_Exception("Scheme \"$scheme\" is not supported");
break;
}
Zend_Loader::loadClass($className);
$schemeHandler = new $className($scheme, $schemeSpecific);
return $schemeHandler;
}

View Slide

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

View Slide

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!

View Slide

Lazy Initialization
Lazy evaluation

View Slide

Lazy Initialization: problem & solution
Problem Solution
  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

View Slide

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() { /* */ } 
} 

View Slide

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

View Slide

Adapter

View Slide

Adapter: problem & solution
Problem Solution
  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

View Slide

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

View Slide

Adapter: example
class MySQL_Connection
{
public static function connect($host, $user, $pass)
{
// main connection logic
}
}
class PostgreSQL
{
public static function do_connect($args = array())
{
}
}
class OracleCoolLibrary
{
public function __construct($args = array())
{
}
public function connect()
{
}
}

View Slide

Adapter: example
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
{
{
self::do_connect($params);
}
}
class Oracle_Adapter extends OracleCoolLibrary
{
{
$instance = new OracleCoolLibrary($params);
$instance->connect();
}
}
class MySQL_Connection
{
public static function connect($host, $user, $pass)
{
}
}
class PostgreSQL
{
public static function do_connect($args = array())
{
}
}
class OracleCoolLibrary
{
public function __construct($args = array())
{
}
public function connect()
{
}
}

View Slide

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

View Slide

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

View Slide

Proxy

View Slide

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

View Slide

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

View Slide

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;
}
}

View Slide

Proxy: example
class AccountProxy
{
protected $account;
public function __construct($account)
{
$this->account = $account;
return $this;
}
{
$this->account->deposit($amount);
return $this;
}
{
$this->account->withdraw($amount);
return $this;
}
{
return $this->account->getBalance();
}
}
$proxy = new AccountProxy(new Account());
$proxy->deposit(20)->withdraw(5);
print $proxy->getBalance();

View Slide

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

View Slide

Proxy: Virtual Proxy
class AccountProxy
{
protected $account;
{
$this->getAccount()->deposit($amount);
return $this;
}
{
$this->getAccount()->withdraw($amount);
return $this;
}
{
return $this->getAccount()->getBalance();
}
{
}
}
}
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;
}
{
}
}
}

View Slide

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');

View Slide

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

View Slide

Iterator

View Slide

Iterator: problem & solution
Problem Solution
  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

View Slide

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

View Slide

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";
}

View Slide

Iterator: SPL example
class Zend_Service_Amazon_ResultSet implements SeekableIterator
{
/**
* A DOMNodeList of 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;
}

View Slide

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;
}
}

View Slide

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

View Slide

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

View Slide

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

View Slide

Observer

View Slide

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->_logger->debug("$username changed username");
$this->_notifier->userChangedLogin($this);
}
public function login($password)
{
// login login
$this->_logger->debug("$username logged in");
}
}

View Slide

Observer: problem & solution
Problem Solution
  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

View Slide

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); 
} 
} 
}

View Slide

Observer: example
class User {
protected $_username;
protected $_observers = array();
public function attach($observer)
{
// ... see implementation
}
public function detach($observer)
{
}
public function notify()
{
}
public function setUsername($username)
{
$this->notify();
}
}
$user = new User();
$user->attach(new Logger());
$user->attach(Notifier::getInstance());
$user->setUsername('foobar');

View Slide

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

View Slide

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

View Slide

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

View Slide

Template Method

View Slide

Template Method: problem & solution
Problem Solution
  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

View Slide

Template Method: considerations
  Template Method is based on inheritance
  Strategy pattern can be considered the composition variant

View Slide

Template Method: implementation
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()

View Slide

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);
}
}
}

View Slide

class HtmlPage extends Page {
protected function generateHeader() {
printf("\n");
}
printf("%s\n",
$this->_title);
}
protected function generateBodyHeader() {
printf("\n");
}
protected function generateBodyFooter() {
printf("\n");
}
protected function generateFooter() {
printf("\n\n");
}
protected function generateLine($line) {
printf($line);
}
}
class FeedPage extends Page {
protected function generateHeader() {
printf("\n");
printf("\n");
printf(" \n");
}
$title = $this->_title;
printf(" %s\n", $title);
}
protected function generateBodyHeader() {
}
protected function generateBodyFooter() {
}
protected function generateFooter() {
printf(" \n");
printf("\n\n");
}
protected function generateLine($line) {
printf(" %s\n",
$line);
}
}

View Slide

$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();

This is the title
First entry
Second entry

This is the title

First entrySecond entry

View Slide

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

View Slide

Template Method: using & abusing
  Avoid creating abstract classes that forces concrete classes to
implement tons of methods

View Slide

Strategy

View Slide

Strategy: problem & solution
Problem Solution
  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

View Slide

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

View Slide

Strategy: example
interface Sorter {
public function sort();
}
class SelectionSort implements Sorter
{
public function sort($array)
{
// selection sort algorithm
}
}
class InsertionSort implements Sorter
{
{
// insertion sort algorithm
}
}
class SuperSecretSort implements Sorter
{
{
// 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());

View Slide

Strategy: example with Lazy Instantiation
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');

View Slide

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

View Slide

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

View Slide

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

View Slide

Beyond this Presentation

View Slide

Literature

View Slide

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

View Slide

Q & A
(part 2/2)

View Slide

Thank you!
[email protected]
www.simonecarletti.com
Slides will be available at
www.slideshare.net/weppos

View Slide

Design Patterns in PHP (PHPCon Italia 2009)

Design Patterns in PHP (PHPCon Italia 2009)

Simone Carletti

More Decks by Simone Carletti

Other Decks in Programming

Featured

Transcript