Real World Dependency Injection - IPC11 Spring Edition

Real World
Dependency Injection

Real World Dependency Injection
About me
 Stephan Hochdörfer, bitExpert AG
 Department Manager Research Labs
 enjoying PHP since 1999
 S.Hochdoerfer@bitExpert.de
 @shochdoerfer

What are Dependencies?

Application
Framework add. Libraries

Controller
Service / Model
Datastore(s)
UtilsPHP extensions

Are Dependencies bad?

Dependencies are not bad!

They are useful!

Hard-coded dependencies are bad!

Tightly coupled code

No reuse of components

No isolation, not testable!

Development gets overcomplicated!

„new“ is evil!

<?php
class DeletePage extends Mvc_Action_AAction {
private $pageManager;
public function __construct() {
$this->pageManager = new PageManager();
}
protected function execute(Mvc_Request $request) {
$this->pageManager->delete(
(int) $request->get('pageId')
);
}
}
„new“ is evil!

„new“ is evil!
<?php
public function __construct(PageManager $pm) {
$this->pageManager = $pm;
}
);
}
}

"High-level modules should not
depend on low-level modules.
Both should depend on
abstractions."
Robert C. Martin

Interfaces act as contracts

„new“ is evil!
<?php
public function __construct(IPageManager $pm) {
}
);
}
}

How to Manage Dependencies?

Manually resolve dependencies?

Automatic wiring required!
Simple Container vs. Full stacked
DI Framework

What is Dependency Injection?

Consumer

Consumer Dependencies

Consumer Dependencies Container

How to inject a Dependency?

Constructor Injection
<?php
class MySampleService implements IMySampleService {
/**
* @var ISampleDao
*/
private $sampleDao;
public function __construct(ISampleDao $sampleDao) {
$this->sampleDao = $sampleDao;
}
}

Setter injection
<?php
/**
* @var ISampleDao
*/
private $sampleDao;
public function setSampleDao(ISampleDao $sampleDao){
}
}

Interface injection
<?php
interface IApplicationContextAware {
public function setCtx(IApplicationContext $ctx);
}

Interface injection
<?php
class MySampleService implements IMySampleService,
IApplicationContextAware {
/**
* @var IApplicationContext
*/
private $ctx;
public function setCtx(IApplicationContext $ctx) {
$this->ctx = $ctx;
}
}

How to wire it all up?

Annotation based wiring
<?php
private $sampleDao;
/**
* @Inject
*/
public function __construct(ISampleDao $sampleDao)
{
}
}

Annotation based wiring
<?php
private $sampleDao;
/**
* @Inject
* @Named('TheSampleDao')
*/
public function __construct(ISampleDao $sampleDao)
{
}
}

External configuration - XML
<?xml version="1.0" encoding="UTF-8" ?>
<beans>
<bean id="SampleDao" class="SampleDao">
<constructor-arg value="app_sample" />
<constructor-arg value="iSampleId" />
<constructor-arg value="BoSample" />
</bean>
<bean id="SampleService" class="MySampleService">
<constructor-arg ref="SampleDao" />
</bean>
</beans>

External configuration - YAML
services:
SampleDao:
class: SampleDao
arguments: ['app_sample', 'iSampleId', 'BoSample']
SampleService:
class: SampleService
arguments: [@SampleDao]

External configuration - PHP
<?php
class BeanCache extends Beanfactory_Container_PHP {
protected function createSampleDao() {
$oBean = new SampleDao('app_sample',
'iSampleId', 'BoSample');
return $oBean;
}
protected function createMySampleService() {
$oBean = new MySampleService(
$this->getBean('SampleDao')
);
return $oBean;
}
}

Why Dependency Injection?
DI vs. Registry vs. Service Locator

Ready to unlock the door?

Unittesting made easy

Unittesting made easy
<?php
require_once 'PHPUnit/Framework.php';
class ServiceTest extends PHPUnit_Framework_TestCase {
public function testSampleService() {
// set up dependencies
$sampleDao = $this->getMock('ISampleDao');
$service = new MySampleService($sampleDao);
// run test case
$return = $service->doWork();
// check assertions
$this->assertTrue($return);
}
}

One class, multiple configurations

Page ExporterPage Exporter
Released / Published
Pages
Pages

Pages
Pages
Workingcopy
Pages
Workingcopy
Pages

<?php
abstract class PageExporter {
protected function setPageDao(IPageDao $pageDao) {
$this->pageDao = $pageDao;
}
}

<?php
abstract class PageExporter {
protected function setPageDao(IPageDao $pageDao) {
}
}
Remember:
The contract!

<?php
class PublishedPageExporter extends PageExporter {
$this->setPageDao(new PublishedPageDao());
}
}
class WorkingCopyPageExporter extends PageExporter {
$this->setPageDao(new WorkingCopyPageDao());
}
}

"Only deleted code is good code!"
Oliver Gierke

<?php
class PageExporter {
public function __construct(IPageDao $pageDao) {
}
}

<?php
// create ApplicationContext instance
$ctx = new ApplicationContext();
// retrieve live exporter
$exporter = $ctx->getBean('ExportLive');
// retrieve working copy exporter
$exporter = $ctx->getBean('ExportWorking');

One class, multiple configurations II
Pages
Pages
Workingcopy
Pages
Workingcopy
Pages

Pages
Pages
Workingcopy
Pages
Workingcopy
Pages
HTMLHTML

Pages
Pages
Workingcopy
Pages
Workingcopy
Pages
PDFPDFHTMLHTML

One class, multiple configurations III

http://editor.loc/page/[id]/headline/
http://editor.loc/page/[id]/content/
http://editor.loc/page/[id]/teaser/

<?php
class EditPart extends Mvc_Action_AFormAction {
private $pagePartsManager;
private $type;
public function __construct(IPagePartsManager $pm) {
$this->pagePartsManager = $pm;
}
public function setType($ptype) {
$this->type = (int) $type;
}
protected function process(Bo_ABo $formBackObj) {
}
}

Mocking external service access

Booking serviceBooking service

Booking serviceBooking service WS-
Connector
WS-
Connector

Connector
WS-
Connector WebserviceWebservice

Connector
WS-
Connector WebserviceWebservice
Remember:
The contract!

Booking serviceBooking service FS-
Connector
FS-
Connector FilesystemFilesystem

Booking serviceBooking service FS-
Connector
FS-
Connector FilesystemFilesystem
fullfills the
contract!

Clean, readable code

Clean, readable code
<?php
public function __construct(IPageManager $pm) {
}
(int) $request->get('pageId'));
return new ModelAndView($this->getSuccessView());
}
}

No framework dependency

No framework dependency
<?php
private $sampleDao;
public function __construct(ISampleDao $sampleDao) {
}
public function getSample($sampleId) {
try {
return $this->sampleDao->readById($sampleId);
}
catch(DaoException $exception) {}
}
}

Benefits
Loose coupling, reuse of components!

Benefits
Can reduce the amount of code!

Benefits
Helps developers to
understand the code!

Cons – No JSR330 for PHP
Bucket, Crafty, FLOW3, Imind_Context,
PicoContainer, Pimple, Phemto,
Stubbles, Symfony 2.0, Sphicy, Solar,
Substrate, XJConf, Yadif, Zend_Di
(Proposal), Lion Framework, Spiral
Framework, Xyster Framework, …

Cons – Developers need mindshift
Configuration ↔ Runtime

Image Credits
http://www.sxc.hu/photo/1028452

Real World Dependency Injection - IPC11 Spring Edition

Recommended

More Related Content

What's hot (19)

Viewers also liked (8)

Similar to Real World Dependency Injection - IPC11 Spring Edition (20)

More from Stephan Hochdörfer (20)

Real World Dependency Injection - IPC11 Spring Edition