Design Patterns 090322101222 Phpapp02

8/3/2019 Design Patterns 090322101222 Phpapp02

http://slidepdf.com/reader/full/design-patterns-090322101222-phpapp02 1/120

Simone Carletti, Altura [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?





What’s wrong with this code?

Nothing…

…except all!

Hard Coded Actions

Presentation mixed

with business logic

Global Variables

Output mixed withelaboration

Context and responsibility conflicts



Designing object oriented software is hard,and designing reusable object-orientedsoftware is even harder.

Design Patters (GoF)




Design Patterns




Design Patterns describe simple andelegant solutions to specific problems in

object oriented software design.




Christopher Alexander


Each pattern describes a problem which occursover and over again in our environment, and thendescribes 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 sameway twice.



Christopher Alexander


Each pattern is a three-part rule, whichexpresses a relation between a certaincontext, a problem and a solution.



The Gang of Four




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 tothe programming language

Consequences

Results and trade-off




What are Design Patterns

Solution to common development problems Reusable successful design and architectures

Common language for developers




What Design Patterns are not

The panacea for solving all development problems Ready to use code scripts

Cut & Paste solutions




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




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)



Golden Rules

1.

Program to an interface, not an implementation1. Some languages takes this rule to the next level with Duck Typing

2. Favor Object Composition over Inheritance

1. Black Box approach

3. Delegate




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




How to Use a Design Pattern

Read the pattern once through for an overview

Go back and study the Structure, Participants and Collaborationsections

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




How to NOT Use a Design Pattern

Don’t try to rewrite your application to fit a Design Pattern, selectthe best Pattern according to your needs

Don’t use a Design Pattern because it’s cool… use a Patternbecause you need it

Don’t copy/paste language-specific Pattern implementations,understand how the Pattern works and how you can implement it inyour application




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



patterns : oop = notable products : algebra

The question isn't whether you'll encounter most patternsbut 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!



Design for Changes

Do you remember? But we careful…




Avoid Over-Engineering




Avoid Under-Engineering




Don’t fall into the

“everything is a pattern” trap




Frameworks vs Design Patterns

Design patterns are more abstract than frameworks

Design patterns are smaller architectural elements thanframeworks

Design patterns are less specialized than frameworks

A typical framework contains several design patterns, but thereverse is never true




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




Design Pattern Classification




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

…




Design Patterns by Scope

Class PatternsDeal with relationships between classes and their subclasses.

Ex. Factory Method, Adapter, Template method…

Object PatternsDeal with object relationships.

The most part of patterns are in the object scope.

Ex. Singleton, Adapter, Decorator, Proxy, Iterator, Observer…




Design Patterns

Architectural MVC

Creational

Singleton

Factory Method Lazy initialization

Structural

Adapter

Proxy

Behavioral Iterator

Observer

Strategy

Template Method

More

Registry

Mock Object




Q & A(part 1/2)




Design Patterns in Action




Pattern Template

Problem & Solution

Considerations

In pictures

Implementation & Examples

In the Wild

Using and Abusing




MVC




MVC: problem & solution

Problem Solution


You want an efficient designsolution to split the view fromthe business logic of your application

You want to keep your application reusable bysplitting the design in multiple

layers

The MVC pattern decouplesviews and models byestablishing a subscribe/notifyprotocol between them

A view reflects the state of themodel

This approach enables you to

attach multiple view to amodel an provide differentrepresentations



MVC: in pictures


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



MVC: Model, View and Controller


The model is the domain-specific representation of data. It usuallyconsists in a database or some other storage system.

The view renders the model in a form suitable according to therequest. This layer is commonly known with the word template.

The controller processes the requests and it’s in charge of queryingthe model and returning the right template according to the request.



MVC: decoupling View and Model


Articles

Article::find()

XML Feed iPhone(X)HTML

$articles

$articles$articles



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 principlesfrom MVC pattern.

Many applications use a template engine

Many applications separate the model from the view and interact with thedatabase via ORM frameworks



MVC: Single Responsibility Principle


Every object should have a single responsibility, and that all itsservices should be narrowly aligned with that responsibility.

The most frequent error using MVC is to execute operations in thewrong context



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

}}



MVC: find the error (1/solution)


// 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)


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


// 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 usinghelpersclass 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><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




Singleton: problem & solution

Problem

You want a class to haveexactly one instance

You want the instance to beeasily accessible

You don’t want to use globalvariables

Solution

The Singleton pattern ensuresa class has only one instance,and provide a global point toaccess it




Singleton: considerations


Often used for shared objects such as configurations, queues,database connections…

You don’t want the environment to be responsible of classinstantiation

You don’t want the environment to be responsible of avoid multipleclass instances

The Singleton is often a mixed behavior



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;

}}



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



Singleton: Class as Singleton


You can declare methods as static and use the class as thecontainer for the Singleton functionality

You are sure no one will create additional instances

You can’t take advantage of other patterns, such as LazyInitialization

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?


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


Pake, the Symfony PHP-make library

Doctrine_Manager, the base component of all Doctrine basedprojects. 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


Before applying a Singleton ask yourself: do I really need aSingleton?

Look at your code, check the number of a class instances

Beware to not spread the Singleton knowledge in classes whereyou don’t really need to

To all intents and purposes, a Singleton instance is a normal classinstance, you can pass it as a parameter



Factory Method




Factory Method: problem & solution

Problem Solution


You want to create aninstance of a class but youdon’t know in advance the

object class you need to use

You want to localize theknowledge of which classmust be instantiated

The Factory Method patterndefines an interface for creating an object, but lets

subclasses decide whichclass to instantiate.

The Factory Method defersinstantiation



Factory Method: considerations


It’s difficult to find in PHP an original implementation of the FactoryMethod 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


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

} /**

* 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


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


Zend_Uri::factory() returns the right Zend_Uri subclass accordingto the type of URI passed as parameter

Zend_Cache::factory() returns the best Zend_Cache enginesaccording to given options and configurations

Doctrine contains several implementation of the Factory pattern.

For example Doctrine_Node::factory() return node instance basedupon chosen implementation



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, heavyinfrastructures

Be Smart! Be Agile! Be Lazy!



Lazy Initialization

Lazy evaluation




Lazy Initialization: problem & solution

Problem Solution


You want to delay the creationof an instance or anexpensive operation until the

first time it is needed

You want the operation to beexecuted only when and if necessary

The Lazy Initialization patterndelays the creation of anobject or the execution of an

expensive process until thefirst time it is needed



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



Lazy Initialization: in the wild


The most part of Zend_Exception classes in Zend Framework arelazy-loaded

Controller classes in Symfony, Zend Framework and (almost) everyPHP 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 thesystem, allowing it to lazy-load code files as needed



Adapter




Adapter: problem & solution

Problem Solution


You want to reuse a library inyour application but it doesn’tmatch your interface

You want to normalizemultiple libraries to use thesame interface

The Adapter pattern convertsthe interface of a class intoanother interface clients

expect

Adapter lets classes worktogether that couldn’totherwise because of incompatible interfaces



Adapter: considerations


Adapter is a common pattern when using third party libraries

If you are developing your own libraries, you might want to avoidadapters and use common habits and guidelines

Often using in cooperation with other patterns, such as the Strategypattern

Adapt or Modify?

Adapter pattern and Proxy pattern are similar, but they havedifferent intents. Adapter is meant to change the interface of anexisting object



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


} public function connect()


}}



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


}}class OracleCoolLibrary { public function __construct($args = array())

{ // main connection logic} public function connect()


}}



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



Adapter: using & abusing


Avoid creating adapter of adapters

Go to the main library and build the Adapter at the lowest possiblelevel



Proxy




Proxy: problem & solution

Problem

You need to provide access toan object without exposing theobject directly

You want to control access tothat object

You want to filter access tothat object

Solution

The Proxy pattern provides asurrogate or placeholder for an other object to control

access to it


P



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


P



Proxy: example


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

}

P



Proxy: example


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;


{ return $this->account->getBalance();

}}

$proxy = new AccountProxy(new Account());$proxy->deposit(20)->withdraw(5);print $proxy->getBalance();

P



class AccountProxy{ protected $account; public function __construct($account)

{ $this->account = $account; return $this;

} public function deposit($amount)

{ $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; public function deposit($amount)

{ $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;

}}

P



Proxy: Virtual Proxy


class AccountProxy{ protected $account; public function deposit($amount)

{ $this->getAccount()->deposit($amount); return $this;


{ $this->getAccount()->withdraw($amount); return $this;


{ return $this->getAccount()->getBalance();


{

if (null === $this->account) { $this->account = new 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;


{ if (null === $this->account) { $this->account = new Account();


}}

P



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 thecode needed for get/set operations

$request->getParameterHolder()->set('foo', 'bar');

$request->setParameter('foo', 'bar');

P



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 usingvirtual proxies and difficult-to-auto-document features



Iterator




Iterator: problem & solution

Problem Solution


You have a complexaggregate object and youwant to access its elements

without working onimplementation

You want to traverse andmanipulate a collection object

The Iterator pattern provides away to access the elements of an aggregate object

sequentially without exposingthe underlying representation

Iterator



Iterator: considerations


You might not realize it, but you use the Iterator pattern every day

working with Arrays

Iterator l



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

Iterator SPL l



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

Iterator SPL l



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;

}}

Iterator PHP 5 SPL



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

Iterator i th ild



Iterator: in the wild


PHP 5 DirectoryIterator library

Zend_Feed, Zend_Service_Amazon, Zend_Service_Technorati inthe Zend Framework

Iterator i g & b i g



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



Observer


Observer: OMG!



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

}}

Ob



Observer: problem & solution

Problem Solution


You want objects to interacteach other without making theclasses tightly coupled

You need to maintainconsistency between relatedobjects with data integrity inmind

The Observer pattern definesdependency between objectsso that when one object

change state, all itsdependents are notified andupdated automatically

Observer: implementation



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

}}

Observer: example



Observer: example


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



Observer: PHP 5 SPL


SPL suggests a standard way of implementing the Observer

pattern.

interface SplObserver

interface SplSubject

class SplObjectStorage

Observer: in the wild



Observer: in the wild


Zend_XmlRpc_Server_Fault in Zend Framework accepts a list of

observers and notifies them in case of unexpected behaviors

Observer: using & abusing



Observer: using & abusing


Don’t notify observers if you don’t need

Consider to add specific notifications if you find yourself callingupdate() too many times for different kind of notifications

->update()

->save()

->delete()

Be careful to notify observers only when a consistent change iscomplete.

Remember, your object should provide a way to let observers know

what changed



Template Method


T l t M th d



Template Method: problem & solution

Problem Solution


The Template Method patterndescribes the skeleton of analgorithm in an operation,

deferring some steps tosubclasses

Template Method letssubclasses redefine certainsteps of an algorithm without

changing the algorithm’sstructure

You have a complex comethat might vary somewhere inthe middle

You want to let subclasseschange part of the abstractclass algorithms

You want to defer to

implementations some partsof an algorithms

Template Method: considerations



Template Method: considerations


Template Method is based on inheritance

Strategy pattern can be considered the composition variant

Template Method: implementation



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

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

}}

}






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

}

}






$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



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 tocustomize

Template Method: using & abusing



e plate Met od: using & abusing


Avoid creating abstract classes that forces concrete classes to

implement tons of methods



Strategy


Strategy bl & l ti



Strategy: problem & solution

Problem Solution


You have a complex operationthat might vary algorithms atruntime 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 analgorithm without changingthe global operation logic

The Strategy pattern defines afamily of algorithms,encapsulate each one, and

make them interchangeable Strategy lets the algorithm

vary independently fromclients that use it, often atruntime level

Strategy: considerations



gy


Strategy is an excellent example of composition and delegation

Strategy is an alternative to subclassing

Strategy and Template Method patterns expose different approachto a similar problem

Duck Typing is a common practice in Strategy pattern

Strategy: example



gy p


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



gy p y


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



gy


Zend_Pdf_Resource_Image_Png allows different image

compression strategies (work in progress)

Symfony enables you to configure different escaping strategieswith the escaping_strategy variable in your configuration file

Strategy: using & abusing



gy


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…



g


… 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


Literature




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




Q & A

(part 2/2)




Thank you!

[email protected]

www.simonecarletti.com

Slides will be available at

www.slideshare.net/weppos

Design Patterns 090322101222 Phpapp02

Documents

Transcript of Design Patterns 090322101222 Phpapp02