Design patterns revisited with PHP 5.3

Design patterns… revisited for PHP 5.3
Fabien Potencier
http://www.flickr.com/photos/revivaling/4979552548

Serial entrepreneur
Developer by passion
Founder of Sensio
Creator and lead developer of Symfony
http://www.twitter.com/fabpot
http://www.github.com/fabpot
http://fabien.potencier.org/

How does PHP 5.3 change the implementation
of some well-known Design Patterns?

http://en.wikipedia.org/wiki/Design_pattern_%28computer_science%29
« A design pattern
is a general reusable solution
to a commonly occurring problem »

http://en.wikipedia.org/wiki/Design_pattern_%28computer_science%29
« By deﬁnition, a pattern
must be programmed anew
into each application that uses it. »

Design patterns revisited with PHP 5.3

The Singleton

The Singleton may cause
serious damage to your code!
http://www.flickr.com/photos/mattbell/1696868871

class Singleton
{
function &getInstance()
{
static $instance;
if (!$instance) {
$instance = new Singleton();
}
return $instance;
}
}
$obj =& Singleton::getInstance();
You can still
instantiate the class
directly
The Singleton and PHP 4

class Singleton
{
static private $instance;
private function __construct() {}
static public function getInstance()
{
if (null === self::$instance) {
self::$instance = new self();
}
return self::$instance;
}
final private function __clone() {}
}
$obj = Singleton::getInstance();
do not forget to
override __clone()
The Singleton and PHP 5.0/5.1/5.2

abstract class Singleton
{
private static $instances = array();
final private function __construct()
{
if (isset(self::$instances[get_called_class()])) {
throw new Exception("A ".get_called_class()." instance already exists.");
}
static::initialize();
}
protected function initialize() {}
final public static function getInstance()
{
$class = get_called_class();
if (!isset(self::$instances[$class])) {
self::$instances[$class] = new static();
}
return self::$instances[$class];
}
final private function __clone() {}
}
The Singleton and PHP 5.3

class Foo extends Singleton {}
class Bar extends Singleton {}
$a = Foo::getInstance();
$b = Bar::getInstance();
The Singleton and PHP 5.3

Active Record
…Late Static Binding

$article = Article::findByPk(1);
$article = Article::findByTitleAndAuthorId('foo', 1);

class Model
{
static public function getMe()
{
return __CLASS__;
}
}
class Article extends Model {}
echo Article::getMe();

class Model
{
static public function getMe()
{
return get_called_class();
}
}
echo Article::getMe();

class Model
{
static public function findByPk($id)
{
$table = strtolower(get_called_class());
$sql = "SELECT * FROM $this->table WHERE id = ?";
return $this->db->get($sql, $id);
}
}
$article = Article::findByPk(1);

class Model
{
static public function __callStatic($method, $arguments)
{
$table = strtolower(get_called_class());
$column = strtolower(substr($method, 6));
$value = $arguments[0];
$sql = "SELECT * FROM $this->table WHERE $column = ?";
return $this->db->get($sql, $value);
}
}
$article = Article::findByTitle('foo');

This is pseudo code with no proper SQL Injection protection!
http://www.flickr.com/photos/zippy/22748510

The Observer Pattern

The Observer pattern allows
to extend or change the behavior of classes
without having to change them

When a method is called
on an object (subject),
it notiﬁes other objects (listeners)
of the event

A Dispatcher is an object
that manages connections
between subjects and listeners

class User
{
function setLanguage($language)
{
$this->language = $language;
}
}
class Translator
{
{
}
}

Dispatcher Listeners
Translator listens
to ’language_change’
User notiﬁes
‘language_change’
Notiﬁers
1
2 Calls
all listeners
Translator callback
is called

Dispatcher Listeners
Translator listens
to ’language_change’
User notiﬁes
‘language_change’
Notiﬁers
1
2 Calls
all listeners
Translator callback
is called
Your class listens
to‘language_change’
Your class callback
is called

$dispatcher = new Dispatcher();
$translator = new Translator($dispatcher);
$user = new User($dispatcher);
$user->setLanguage('fr');

class Translator
{
public function __construct($dispatcher)
{
$listener = array($translator, 'listenLanguageChange');
$dispatcher->connect('language_change', $listener);
}
public function listenLanguageChangeEvent($arguments)
{
$this->setLanguage($arguments['language']);
}
}
A PHP callable
The Event name

class User
{
{
$this->dispatcher->notify('language_change',
array('language' => $language));
}
}

// register the listener with the dispatcher
$dispatcher = new Dispatcher(array(
'foo' => $listener,
));
// notify the event anywhere
$dispatcher->notify(
'foo',
array('name' => 'Fabien')
);
A listener can be any PHP callable

class Dispatcher
{
function __construct($map)
{
$this->map = $map;
}
function notify($name, $args = array())
{
call_user_func($this->map[$name], $args);
}
}
A PHP callable

class Dispatcher
{
function __construct($map)
{
$this->map = $map;
}
function notify($name, $args = array())
{
$this->map[$name]($rags);
}
} An anonymous function

// a function
function foo($args)
{
echo "Hello {$args['name']}n";
};
$listener = 'foo';

// an anonymous function
$listener = function ($args)
{
};

// register the listener with the dispatcher
'foo' => function ($args)
{
},
));
// notify the event anywhere
$dispatcher->notify(
'foo',
);

'foo' => $listener
));

class Dispatcher
{
function connect($name, $listener)
{
if (!isset($this->map[$name])) {
$this->map[$name] = array();
}
$this->map[$name][] = $listener;
}
}

$l1 = function ($args)
{
echo "Hello1 {$args['name']}?n";
};
$l2 = function ($args)
{
echo "Hello2 {$args['name']}?n";
};

$listener = new Listeners($l1, $l2);
'foo' => $listener
));
'foo' => new Listeners($l1, $l2)
));

$listener = new Listeners($l1, $l2);
$listeners($args);

class Listeners
{
function __construct()
{
$this->listeners = func_get_args();
}
function __invoke($args = array())
{
foreach ($this->listeners as $listener) {
$listener($args);
}
}
}
Makes the object callable

Template View

echo render('Hello {{ name }}!', array('name' => 'Fabien'));
echo render(
file_get_contents(__DIR__.'/template.php'),
);

Dependency Injector

http://www.picoinjector.org/injection.html
« Dependency Injection is where components
are given their dependencies
through their constructors, methods, or directly into ﬁelds »

In most web applications, you need to manage the user preferences
–  The user language
–  Whether the user is authenticated or not
–  …
This can be done with a User object
–  setLanguage(), getLanguage()
–  setAuthenticated(), isAuthenticated()
–  …

The User information
need to be persisted
between HTTP requests
We use the PHP session for the Storage

class SessionStorage
{
function __construct($cookieName = 'PHP_SESS_ID')
{
session_name($cookieName);
session_start();
}
function set($key, $value)
{
$_SESSION[$key] = $value;
}
// ...
}

class User
{
protected $storage;
function __construct()
{
$this->storage = new SessionStorage();
}
{
$this->storage->set('language', $language);
}
// ...
}
$user = new User();
Very easy
to use
Very hard to
customize

class User
{
protected $storage;
function __construct($storage)
{
$this->storage = $storage;
}
}
$storage = new SessionStorage();
$user = new User($storage);
Slightly more
difficult to use
Very easy to
customize

That’s Dependency Injection
Nothing more

Instead of harcoding
the Storage dependency
inside the User class constructor
Inject the Storage dependency
in the User object

A Dependency Injector
Describes objects
and their dependencies
Instantiates and conﬁgures
objects on-demand

An injector
SHOULD be able to manage
ANY PHP object (POPO)
The objects MUST not know
that they are managed
by the injector

•  Parameters
–  The SessionStorage implementation we want to use (the class name)
–  The session name
•  Objects
–  SessionStorage
–  User
•  Dependencies
–  User depends on a SessionStorage implementation

Let’s build a simple injector
with PHP 5.3
http://www.flickr.com/photos/22750018@N05/4531762220/

Dependency Injector: Parameters

class Injector
{
protected $parameters = array();
public function setParameter($key, $value)
{
$this->parameters[$key] = $value;
}
public function getParameter($key)
{
return $this->parameters[$key];
}
}

$injector = new Injector();
$injector->setParameter('session_name', 'SESSION_ID');
$injector->setParameter('storage_class', 'SessionStorage');
$class = $injector->getParameter('storage_class');
$sessionStorage = new $class($injector->getParameter('session_name'));
$user = new User($sessionStorage);
Decoupling
Customization
Objects creation

class Injector
{
public function __set($key, $value)
{
}
public function __get($key)
{
}
}
Using PHP
magic methods

$injector->session_name = 'SESSION_ID';
$injector->storage_class = 'SessionStorage';
$sessionStorage = new $injector->storage_class($injector->session_name);
$user = new User($sessionStorage);
Interface
is cleaner

Dependency Injector: Objects

We need a way to describe how to create objects,
without actually instantiating anything!
Anonymous functions to the rescue!

class Injector
{
protected $objects = array();
public function __set($key, $value)
{
}
public function __get($key)
{
}
public function setService($key, Closure $service)
{
$this->objects[$key] = $service;
}
public function getService($key)
{
return $this->objects[$key]($this);
}
}
Store a lambda
able to create the
object on-demand
Ask the closure to create
the object and pass the
current injector

$injector->setService('user', function ($c)
{
return new User($c->getService('storage'));
});
$injector->setService('storage', function ($c)
{
return new $c->storage_class($c->session_name);
});
$user = $injector->getService('user');
Creating the User
is now as easy as before
Description

class Injector
{
protected $values = array();
function __set($id, $value)
{
$this->values[$id] = $value;
}
function __get($id)
{
if (is_callable($this->values[$id])) {
return $this->values[$id]($this);
} else {
return $this->values[$id];
}
}
}
Simplify the code

$injector->user = function ($c)
{
return new User($c->storage);
};
$injector->storage = function ($c)
{
return new $c->storage_class($c->session_name);
};
$user = $injector->user;
Unified interface

Dependency Injector: Scope

For some objects, like the user,
the injector must always
return the same instance

spl_object_hash($injector->user)
!==

$injector->user = function ($c)
{
static $user;
if (is_null($user)) {
$user = new User($c->storage);
}
return $user;
};

===

$injector->user = $injector->asShared(function ($c)
{
return new User($c->storage);
});

function asShared(Closure $lambda)
{
return function ($injector) use ($lambda)
{
static $object;
if (is_null($object)) {
$object = $lambda($injector);
}
return $object;
};
}

class Injector
{
{
}
function __get($id)
{
if (!isset($this->values[$id])) {
throw new InvalidArgumentException(sprintf('Value "%s" is not
defined.', $id));
}
} else {
}
}
}
Error management

class Injector
{
{
}
function __get($id)
{
if (!isset($this->values[$id])) {
throw new InvalidArgumentException(sprintf('Value "%s" is not defined.', $id));
}
} else {
}
}
function asShared($callable)
{
return function ($c) use ($callable)
{
static $object;
if (is_null($object)) {
$object = $callable($c);
}
return $object;
};
}
}
40 LOC for a fully-
featured injector

Twittee: A Dependency Injection Container in a tweet
•  Implementation does not use PHP 5.3
•  Its usage needs PHP 5.3
class Container {
protected $s=array();
function __set($k, $c) { $this->s[$k]=$c; }
function __get($k) { return $this->s[$k]($this); }
}
twittee.org

Anonymous Functions
Closures
Late Static Binding
__invoke()
…

I’m NOT advocating
the usage of lambdas everywhere
This presentation was about
showing how they work
on practical examples

Sensio S.A.
92-98, boulevard Victor Hugo
92 115 Clichy Cedex
FRANCE
Tél. : +33 1 40 99 80 80
Contact
Fabien Potencier
fabien.potencier at sensio.com
http://www.sensiolabs.com/
http://www.symfony-project.org/
http://fabien.potencier.org/

Interlude
…Anonymous Functions
http://www.flickr.com/photos/gregory_bastien/2565132371

An anonymous function
is a function
deﬁned on the ﬂy (no name)
function () { echo 'Hello world!'; };

Can be stored in a variable
$hello = function () { echo 'Hello world!'; };

… to be used later on
$hello();
call_user_func($hello);

… or can be passed as a function argument
function foo(Closure $func)
{
$func();
}
foo($hello);

Fonctions anonymes
$hello = function ($name) { echo 'Hello '.$name; };
$hello('Fabien');
call_user_func($hello, 'Fabien');
Can take arguments

Fonctions anonymes
function foo(Closure $func, $name)
{
$func($name);
}
foo($hello, 'Fabien');

array_*
Greatly simplify usage of some array_* functions
array_map()
array_reduce()
array_filter()

class Article
{
public function __construct($title)
{
$this->title = $title;
}
public function getTitle()
{
return $this->title;
}
}

How to get an array of all article titles?
$articles = array(
new Article('PHP UK - part 1'),
new Article('PHP UK - part 2'),
new Article('See you next year!'),
);

$titles = array();
foreach ($articles as $article)
{
$titles[] = $article->getTitle();
}

$titles = array_map(
create_function('$article', 'return $article->getTitle();'),
$articles
);

$titles = array_map(
function ($article) { return $article->getTitle(); },
$articles
);

$titles = array();
foreach ($articles as $article)
{
$titles[] = $article->getTitle();
}
100100
$titles = array_map(create_function('$article', 'return $article->getTitle();'), $articles);
1800300
$titles = array_map(function ($article) { return $article->getTitle(); }, $articles);
200100
memory speed
$mapper = function ($article) { return $article->getTitle(); };
$titles = array_map($mapper, $articles);
180100

$mapper = function ($article) {
return $article->getTitle();
};
$mapper = function ($article) {
return $article->getAuthor();
};
$authors = array_map($mapper, $articles);

A closure is a lambda
that remembers the context
of its creation…

$mapper = function ($method)
{
return function ($article) use($method)
{
return $article->$method();
};
};

$method = 'getTitle';
$mapper = function ($article) use($method)
{
return $article->$method();
};
$method = 'getAuthor';

$titleMapper = $mapper('getTitle');
$titles = array_map($titleMapper, $articles);
$authorMapper = $mapper('getAuthor');
$authors = array_map($authorMapper, $articles);

$titles = array_map($mapper('getTitle'), $articles);
$authors = array_map($mapper('getAuthor'), $articles);

Design patterns revisited with PHP 5.3

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Design patterns revisited with PHP 5.3 (20)

More from Fabien Potencier (20)

Recently uploaded (20)

Design patterns revisited with PHP 5.3