Dependency Injection with PHP and PHP 5.3

Dependency Injection
with PHP and PHP 5.3

Fabien Potencier

Fabien Potencier
•  Serial entrepreneur and developer by passion
•  Founder of Sensio (in 1998)
–  A services and consulting company
specialized in Web technologies
and Internet marketing (France and USA)
–  70 people
–  Open-Source specialists
–  Big corporate customers
–  Consulting, training, development, web design, … and more
–  Sponsor of a lot of Open-Source projects
like symfony and Doctrine

Fabien Potencier
•  Creator and lead developer of symfony…
•  and creator and lead developer of some more OSS:
–  symfony components
–  Swift Mailer : Powerful component based mailing library for PHP
–  Twig : Fexible, fast, and secure template language for PHP
–  Pirum : Simple PEAR Channel Server Manager
–  Sismo : PHP continuous integration server
–  Lime : Easy to use unit testing library for PHP
–  Twitto : A web framework in a tweet
–  Twittee : A Dependency Injection Container in a tweet
–  Pimple : A small PHP 5.3 dependency injection container

Fabien Potencier

•  Read my technical blog: http://fabien.potencier.org/

•  Follow me on Twitter: @fabpot

•  Fork my code on Github: http://github.com/fabpot/


A real world « web » example

In most web applications, you need to manage the user preferences

–  The user language
–  Whether the user is authenticated or not
–  The user credentials
–  …

This can be done with a User object

–  setLanguage(), getLanguage()
–  setAuthenticated(), isAuthenticated()
–  addCredential(), hasCredential()
–  ...

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() Very hard to
{ customize
$this->storage = new SessionStorage();
}

function setLanguage($language)
{
$this->storage->set('language', $language);
}

// ...
} Very easy
to use
$user = new User();

class User
{
protected $storage; Very easy to
customize
function __construct($storage)
{
$this->storage = $storage;
}
}

$storage = new SessionStorage();
$user = new User($storage);
Slightly more
difficult to use

That’s Dependency Injection

Nothing more

Let’s understand why the ﬁrst example
is not a good idea

I want to change the session cookie name

class User
{
protected $storage;

function __construct()
Hardcode it in the
{ User class
$this->storage = new SessionStorage('SESSION_ID');
}

function setLanguage($language)
{
$this->storage->set('language', $language);
}

// ...
}

$user = new User();

class User
{
protected $storage;

{
$this->storage = new SessionStorage(STORAGE_SESSION_NAME);
}
}
Add a global
configuration?
define('STORAGE_SESSION_NAME', 'SESSION_ID');

$user = new User();

class User
{
protected $storage;

function __construct($sessionName)
{
$this->storage = new SessionStorage($sessionName);
}
}

$user = new User('SESSION_ID');
Configure via
User?

class User
{
protected $storage;

function __construct($storageOptions)
{
$this->storage = new SessionStorage($storageOptions
['session_name']);

$user = new User(
array('session_name' => 'SESSION_ID')
);
Configure with an
array?

I want to change the session storage implementation

Filesystem
MySQL
Memcached
…

class User
{
protected $storage;

function __construct() Use a global
{ registry object?
$this->storage = Registry::get('session_storage');
}
}

Registry::set('session_storage', $storage);
$user = new User();

Now, the User depends on the Registry

Instead of harcoding
the Storage dependency
inside the User class constructor

Inject the Storage dependency
in the User object

class User
{
protected $storage;

{
}
}

$storage = new SessionStorage('SESSION_ID');

Use diﬀerent Storage strategies

class User
{
protected $storage;

{
}
} Use a different
Storage engine
$storage = new MySQLSessionStorage('SESSION_ID');

Conﬁguration becomes natural

class User
{
protected $storage;

{
}
} Configuration
is natural
$storage = new MySQLSessionStorage('SESSION_ID');

Wrap third-party classes (Interface / Adapter)

class User
{
protected $storage;
Add an interface
function __construct(SessionStorageInterface $storage)
{
}
}

interface SessionStorageInterface
{
function get($key);

function set($key, $value);
}

Mock the Storage object (for testing)

class User
{
protected $storage;

function __construct(SessionStorageInterface $storage)
{
}
}
Mock the Session
class SessionStorageForTests implements SessionStorageInterface
{
protected $data = array();

static function set($key, $value)
{
self::$data[$key] = $value;
}
}

Use diﬀerent Storage strategies
Conﬁguration becomes natural
Wrap third-party classes (Interface / Adapter)
Mock the Storage object (for testing)

Easy without changing the User class

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


// constructor injection

// setter injection
$user = new User();
$user->setStorage($storage);

// property injection
$user = new User();
$user->storage = $storage;

A slightly more complex
web example

$request = new Request();
$response = new Response();

$storage = new FileSessionStorage('SESSION_ID');

$cache = new FileCache(
array('dir' => dirname(__FILE__).'/cache')
);
$routing = new Routing($cache);

class Application
{
{
$this->request = new WebRequest();
$this->response = new WebResponse();

$storage = new FileSessionStorage('SESSION_ID');
$this->user = new User($storage);

$cache = new FileCache(
array('dir' => dirname(__FILE__).'/cache')
);
$this->routing = new Routing($cache);
}
}

$application = new Application();

We need a Container
Describes objects
and their dependencies

Instantiates and conﬁgures
objects on-demand

A container
SHOULD be able to manage
any PHP object (POPO)

The objects MUST not know
that they are managed
by a container

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

Let’s build a simple container with PHP 5.3

DI Container

Managing parameters

class Container
{
protected $parameters = array();

public function setParameter($key, $value)
{
$this->parameters[$key] = $value;
}

public function getParameter($key)
{
return $this->parameters[$key];
}
}

Decoupling

$container = new Container(); Customization
$container->setParameter('session_name', 'SESSION_ID');
$container->setParameter('storage_class', 'SessionStorage');

$class = $container->getParameter('storage_class');
$sessionStorage = new $class($container->getParameter('session_name'));
$user = new User($sessionStorage);
Objects creation

class Container Using PHP
{ magic methods

public function __set($key, $value)
{
}

public function __get($key)
{
return $this->parameters[$key];
}
}

Interface
is cleaner

$container = new Container();
$container->session_name = 'SESSION_ID';
$container->storage_class = 'SessionStorage';

$sessionStorage = new $container->storage_class($container->session_name);
$user = new User($sessionStorage);

DI Container

Managing objects

We need a way to describe how to create objects,
without actually instantiating anything!

Anonymous functions to the rescue!

Anonymous Functions / Lambdas

A lambda is a function
deﬁned on the ﬂy
with no name

function () { echo 'Hello world!'; };


A lambda can be stored
in a variable

$hello = function () { echo 'Hello world!'; };


And then it can be used
as any other PHP callable

$hello();

call_user_func($hello);


You can also pass a lambda
as an argument to a function or method

function foo(Closure $func)
{
$func();
}

foo($hello);

Fonctions anonymes
$hello = function ($name) { echo 'Hello '.$name; };

$hello('Fabien');

call_user_func($hello, 'Fabien');

function foo(Closure $func, $name)
{
$func($name);
}

foo($hello, 'Fabien');

class Container
{
protected $objects = array();

public function __set($key, $value)
{
}

public function __get($key) Store a lambda
{
return $this->parameters[$key]; able to create the
object on-demand
}

public function setService($key, Closure $service)
{
$this->objects[$key] = $service;
}

public function getService($key) Ask the closure to create
{
return $this->objects[$key]($this); th e object and pass the
}
} current Container

$container->session_name = 'SESSION_ID'; Description
$container->setService('user', function ($c)
{
return new User($c->getService('storage'));
});
$container->setService('storage', function ($c)
{
return new $c->storage_class($c->session_name);
});

Creating the User
is now as easy as before
$user = $container->getService('user');

class Container
{
protected $values = array(); Simplify the code
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];
}
}
}

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

$user = $container->user;

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

spl_object_hash($container->user)

!==

$container->user = function ($c)
{
static $user;

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

return $user;
};


===

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

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

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

public function getTitle()
{
return $this->title;
}
}

$articles = array(
new Article('Title 1'),
new Article('Title 2'),
);

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

$titles = array_map($mapper, $articles);

$method = 'getTitle';

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

$method = 'getAuthor';

$titles = array_map($mapper, $articles);

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

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

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

function asShared(Closure $lambda)
{
return function ($container) use ($lambda)
{
static $object;

if (is_null($object))
{
$object = $lambda($container);
}
return $object;
};
}

class Container
{
protected $values = array();

{
}

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

{
}
else
{
}
}
}

class Container
{
protected $values = array();

{
}

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

{
}
else
{
}
}

function asShared($callable)
{

40 LOC for a fully-
return function ($c) use ($callable)
{
static $object;

if (is_null($object))
{
$object = $callable($c);
featured container
}
return $object;
};
}
}

More about Dependency Injection

http://fabien.potencier.org/article/17/on-php-5-3-lambda-functions-and-closures

http://components.symfony-project.org/dependency-injection/

http://github.com/fabpot/pimple

http://twittee.org/

Twittee: A 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

Remember, most of the time,
you don’t need a Container
to use Dependency Injection

You can start to use and beneﬁt from
Dependency Injection today

by implementing it
in your projects

by using externals libraries
that already use DI
without the need of a container

Symfony
Zend Framework
ezComponents
Doctrine
Swift Mailer
…

Questions?

My slides will be available on
slideshare.com/fabpot

symfony-live.com
with Matthew Weier O’Pheinney

I will reveal the first alpha release of Symfony 2.0!

symfony-live.com
with Matthew Weier O’Pheinney

… with Matthew Weier O'Phinney as a special guest

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/

BONUS
Symfony Components

SymfonyComponentsDependencyInjection

DI Container Hello World example

use SymfonyComponentsDependencyInjectionBuilder;
use SymfonyComponentsDependencyInjectionReference;

$container = new Builder();

$container->register('output', 'FancyOutput');

$container->
register('message', 'Message')->
setArguments(array(new Reference('output'), array('with_newline' => true)))
;

$container->message->say('Hello World!');

$message = $container->message;

Get the conﬁguration for the message service

The Message constructor must be given an output service

Get the output object from the container

Create a Message object by passing the constructor arguments

$message = $container->message;

is roughly equivalent to

$output = new FancyOutput();
$message = new Message($output, array('with_newline' => true));!


$container->
;

$container->message->say('Hello World!'); PHP
<container xmlns="http://symfony-project.org/2.0/container">
<services> XML
<service id="output" class="FancyOutput" />

<service id="message" class="Message"> XML is validated
<argument type="service" id="output" /> against an XSD
<argument type="collection">
<argument key="with_newline">true</argument>
</argument>
</service>
</services>
</container>

$loader = new XmlFileLoader($container);
$loader->load('services.xml');


$container->
setArguments(array(new sfServiceReference('output'), array('with_newline' => true)))
;

$container->message->say('Hello World!'); PHP
services:
output: { class: FancyOutput }
message: YAML
class: Message
arguments:
- @output
- { with_newline: true }

$loader = new YamlFileLoader($container);
$loader->load('services.yml');

<parameters>
<parameter key="output.class">FancyOutput</parameter>
<parameter key="message.options" type="collection">
<parameter key="with_newline">true</parameter>
</parameter>
</parameters>

<services>
<service id="output" class="%output.class%" />

<service id="message" class="Message">
<argument type="service" id="output" />
<argument>%message.options%</argument>
</service>
</services>
</container>


<imports>
<import resource="config.xml" />
</imports>

<services>
</service>
</services>
</container>

<parameters>
<parameter key="output.class">FancyOutput</parameter>
<parameter key="message.options" type="collection">
<parameter key="with_newline">true</parameter>
</parameter>
</parameters>
</container>

$loader = new FileXmlFileLoader($container);

<services>
<import resource="config.yml" class="SymfonyComponentsDependencyInjection
LoaderYamlFileLoader" />

</service>
</services>

parameters:
output.class: FancyOutput

message.options: { with_newline: true }


Loaders & Dumpers
•  IniFileLoader
•  XmlFileLoader
•  YamlFileLoader

•  XmlDumper
•  YamlDumper
Make your container
•  PhpDumper VERY fast
•  GraphvizDumper

use SymfonyComponentsDependencyInjectionBuilder;
use SymfonyComponentsDependencyInjectionDumperXmlDumper;
use SymfonyComponentsDependencyInjectionDumperYamlDumper;
use SymfonyComponentsDependencyInjectionDumperPhpDumper;
use SymfonyComponentsDependencyInjectionLoaderXmlFileLoader;
use SymfonyComponentsDependencyInjectionLoaderYamlFileLoader;



$container->
;

$dumper = new XmlDumper($container);
file_put_contents(__DIR__.'/container.xml', $dumper->dump());

$loader->load(__DIR__.'/container.xml');

$dumper = new YamlDumper($container);
file_put_contents(__DIR__.'/container.yml', $dumper->dump());

$loader = new YamlFileLoader($container);
$loader->load(__DIR__.'/container.yml');

$dumper = new PhpDumper($container);
echo $dumper->dump();

use SymfonyComponentsDependencyInjectionContainer;
use SymfonyComponentsDependencyInjectionParameter;

class ProjectServiceContainer extends Container
{
protected $shared = array();

protected function getOutputService()
{
if (isset($this->shared['output'])) return $this->shared['output'];

$instance = new FancyOutput();

return $this->shared['output'] = $instance;
}

protected function getMessageService()
{
if (isset($this->shared['message'])) return $this->shared['message'];

$instance = new Message($this->getService('output'), array('with_newline' => true));

return $this->shared['message'] = $instance;
}
}

use SymfonyComponentsDependencyInjectionDumperGraphvizDumper;

$dumper = new GraphvizDumper($container);
echo $dumper->dump();

digraph sc {
ratio="compress"
node [fontsize="11" fontname="Arial" shape="record"];
edge [fontsize="9" fontname="Arial" color="grey" arrowhead="open" arrowsize="0.5"];

node_output [label="outputnFancyOutputn", shape=record, fillcolor="#eeeeee", style="filled"];
node_message [label="messagenMessagen", shape=record, fillcolor="#eeeeee", style="filled"];
node_service_container [label="service_containernSymfonyComponentsDependencyInjectionBuilder
n", shape=record, fillcolor="#9999ff", style="filled"];
node_message -> node_output [label="" style="filled"];
}

Dependency Injection with PHP and PHP 5.3

Dependency Injection with PHP and PHP 5.3

More Related Content

Viewers also liked (6)

Similar to Dependency Injection with PHP and PHP 5.3 (20)

More from Fabien Potencier (20)

Recently uploaded (20)

Dependency Injection with PHP and PHP 5.3