Dependency injection

dependency injection
The pattern

class Carpenter

{

public function work()

{

$hammer = new Hammer();

$hammer->chop();

}

}

!

$carpenter = new Carpenter();

$carpenter->work();

Let’s talk about

responsibility

•

Any carpenter should ignore how to build a
hammer, but how to use it.

•

The carpenter goes to a hardware store to get
some nice brown and big hammer.

•

Not testable

•

High coupling

class Carpenter

{

public function work(Hammer $hammer)

{

$hammer->chop();

}

}

!


$carpenter = new Carpenter();

$carpenter->work($hammer);

•

So can we just have a carpenter without a
hammer?

•

No way!

•

A carpenter ALWAYS have a hammer.

•

No hammer, no carpenter.

class Carpenter

{

private $hammer;

!

public function __construct(Hammer $hammer)

{

$this->hammer = $hammer;

}

!

}


{

$this->hammer->chop();

}

!


$carpenter = new Carpenter($hammer);

$carpenter->work();

2 years later…
•

All carpenters are upgraded.

•

No hammers anymore.

•

All carpenters will use a simple small red mallet

•

We want to make sure all objects that every
carpenter will use to chop, will be suitable for
that.

•

How can ensure this?

interface ToolInterface

{

public function chop();

}

!

class Hammer implements ToolInterface

{

public function chop()

{

}

}

!

class Mallet implements ToolInterface

{

public function chop()

{

}

}

class Carpenter

{

private $tool;

!

public function __construct(ToolInterface $tool)

{

$this->tool = $tool;

}

!

}


{

$this->tool->chop();

}

!

$carpenter = new Carpenter(new Hammer);

$carpenter = new Carpenter(new Mallet);

$carpenter->work();

•

Very testable and easily mockable

•

Low coupling

•

Seems to be the best solution ever

But…
is this implementation a good one?

•

This is purely what means dependency
injection.

•

Every dependency of an object is injected

•

… into the constructor if is needed for the
class to be built

•

… in a method if is just needed for this
method

Think about a full project with this code
$iron = new Iron;

$wood = new Wood;

$plastic = new Plastic(new Blue);

$hammer = new Hammer($iron, $wood, $plastic);

$paintCan = new Paint(new Red);

$carpenter = new Carpenter($hammer, $glasses, $paintCan);

!

$nail = new Nail($iron);

$carpenter->work($iron);

•

Not maintainable

•

Not scalable

•

Responsibility of building a carpenter is now
distributed by all controllers.

What container should provide?
•

Deﬁnition

•

Customization

•

Instantiation

•

Our container is the provider of all instances.

•

It is therefore responsable of building them

Services
•

A service is just an instance of an object

•

Each service must deﬁne the path of the object
( given by the namespace )

•

Also can deﬁne how to be built ( arguments )

•

An argument can be another service ( using @ )

services:

iron:

class: Iron

wood:

class: Wood

plastic:

class: Plastic

hammer:

class: Hammer

arguments:

iron: @iron

wood: @wood

plastic: @plastic

carpenter:

class: Carpenter

arguments:

hammer: @hammer

$carpenter = $container->get(‘carpenter’);

Customization
•

In this example, every time a Carpenter is
requested, a new Hammer will be used.

•

If we want to switch to a Mallet, we must change
definition.

•

We should be able to configure it outside the
definition of the container.

Parameters

•

Any parameter should be able to be deﬁned in
the project

•

A parameter is used using “%” keyword.

parameters:

tool_class: Hammer

services:

iron:

class: Iron

wood:

class: Wood

plastic:

class: Plastic

tool:

class: %tool_class%

arguments:

iron: @iron

wood: @wood

plastic: @plastic

carpenter:

class: Carpenter

arguments:

tool: @tool

Scopes
•

Prototype.

•

Container. Some objects can be just reused in
every request ( an inﬁnite paint can ) - In the
real world, a Logger or a simple Text library.

Prototype
•

One instance per container request

•

Container just build an instance and return it

•

It’s deﬁned by setting scope: prototype

•

For example, a nail

Container
•

First time, object is built and stored.

•

From next requests, same instance is reused and
returned

•

Saving memory ( storing objects ) and cpu ( building
them )

•

It’s deﬁned by setting scope: container. Default behavior

services:

paint_can:

class: PaintCan

scope: container

carpenter:

class: Painter

scope: prototype

arguments:

paint_can: @paint_can

•

Each time a painter is requested, we’ll reuse
same paint can object since they all can share
it.

Implementations
•

Symfony2 - DependencyInjection Component

•

Android - Dagger

•

Objective C - Typhoon

DI Saves your life
Use it, dude!

Dependency injection

More Related Content

Similar to Dependency injection (20)

Recently uploaded (20)

Dependency injection