Migrating to dependency injection

Migrating to
Dependency Injection

@josh_adell
www.servicetrade.com
blog.everymansoftware.com
github.com/jadell/neo4jphp
https://joind.in/10419

Legacy Code

Began with PHP 5.0 (now 5.3)
~80k LoC
Mixed PHP & HTML
3 x functions.php with ~9k LoC each
magic_quotes AND register_globals
No abstract classes or interfaces
Tightly coupled components
No tests

class UserRepository {
public function findUser($id) {
$db = new Database(/* connection params*/);
$userInfo = $db->query(/* User query with $id */);
$user = new User();
$user->setProperties($userInfo);
return $user;
}
}
========================================================
class UserController {
public function getUser() {
$repo = new UserRepository();
return $repo->findUser($_GET['id']);
}
}

Dependency Injection (DI)
Components should not
create the other components
on which they depend.
Injector injects Dependencies into Consumers

class PageController {
public function __construct(
Database $db) {
$this->repo = new Repository($db);
}
}
========================================================
class PageController {
Repository $repo) {
$this->repo = $repo;
}
}

DI Container

Wires objects together
I like Pimple: http://pimple.sensiolabs.org/
Parameters
Services / Shared Objects
Factory Services
Factory Callbacks

$di = new Pimple();
// Parameters
$di['dbHost'] = "localhost";
$di['dbUser'] = "username";
$di['dbPass'] = "password";
// Services / Shared Objects
$di['database'] = function ($di) {
return new Database($di['dbHost'], $di['dbUser'], $di
['dbPass']);
};
$di['userRepository'] = function ($di) {
return new UserRepository($di['database]);
};

// Factory Services
$di['user'] = $di->factory(function () {
return new User();
});
// Factory Callbacks
$di['userFactory'] = $di->protect(function ($name) {
return new User($name);
});

Re-architect the application
so that object instantiation
only occurs in the DI Container.
Re-architect the application
so the DI Container
is only referenced from the DI Container.

Why Bother?

Testing / Quality
Maintenance
Extensibility
Flexibility

One Step at a Time
1.
2.
3.

Create a DI factory method for the class
Replace "new" with calls to the DI factory method
a.
b.

Move all shared objects to the constructor
Move all factory creations to anonymous function in the constructor

a.
b.

Pass in shared objects from the DI Container
Pass in factories callbacks from the DI Container

4.

Repeat from Step 1 for all classes

Step #1: DI Container method
$di['userRepository'] = function () {
return new UserRepository();
};

Step #2: Replace “new”
global $di;
$repo = $di['userRepository'];
return $repo->findUser($_GET['id']);
}
}

Step #3a: Move shared objects
public function __construct() {
$this->db = new Database(/* connection params*/);
}
$userInfo = $this->db->query(/* User query with $id */);
$user = new User();
return $user;
}
}

Step #3b: Move factory creation
public function __construct() {
$this->db = new Database(/* connection params*/);
$this->userFactory = function () {
return new User();
};
}
$user = call_user_func($this->userFactory);
return $user;
}
}

Step #4a: Pass in shared objects
$di['database'] = function () {
return new Database();
};
$di['userRepository'] = function (
$di) {
return new UserRepository(
$di['database']);
};
========================================================
Database $db) {
$this->db = $db;
$this->userFactory = function () {
return new User();
};
}
// ...

Step #4b: Pass in factory callbacks
$di['userFactory'] = $di->protect(function () {
return new User();
});
$di['userRepository'] = function ($di) {
return new UserRepository($di['database'], $di['userFactory']);
};
========================================================
public function __construct(Database $db, callable $userFactory) {
$this->db = $db;
$this->userFactory = $userFactory;
}
// ...

Done with UserRepository!
public function __construct(Database $db, callable $userFactory) {
$this->db = $db;
$this->userFactory = $userFactory;
}
$user = call_user_func($this->userFactory);
return $user;
}
}

Repeat for UserController
$di['userController'] = function ($di) {
return new UserController($di['userRepository']);
};
========================================================

public function __construct(UserRepository $repo) {
$this->userRepo = $repo;
}
global $di;
$repo = $di['userRepository'];
return $this->userRepo->findUser($_GET['id']);
}
}

That seems like a lot of steps

New Requirement

Every time a user submits a report,
send an email.

Setup Event Publisher
class User {
EventEmitter $ee) {
$this->event = $ee;
}
public function submitReport(Report $report) {
// ...
$this->event->publish('newReport', $this, $report);
}
}

Setup Event Subscribers
$di['eventEmitter'] = function () {
return new EventEmitter();
};
$di['emailService'] = function ($di) {
return new EmailService();
};
$di['userFactory'] = $di->protect(function () use ($di)) {
$di['eventEmitter']->subscribe('newReport', $di['emailService']);
return new User($di['eventEmitter']);
});

I have to admit, it's getting better

Questions?
class Presentation {
public function __construct(Presenter $presenter) {
$this->presenter = $presenter;
}
public function askQuestion(Question $question) {
return $this->presenter->answer($question);
}
}

@josh_adell
www.servicetrade.com
blog.everymansoftware.com
github.com/jadell/neo4jphp
http://pimple.sensiolabs.org/
http://martinfowler.com/articles/injection.html

https://joind.in/10419

Migrating to dependency injection

More Related Content

What's hot

Similar to Migrating to dependency injection

Recently uploaded

Migrating to dependency injection