Real world dependency injection - DPC10

Real World Dependency Injection
Stephan Hochdörfer, bitExpert AG

"Dependency Injection is a key element of agile architecture"
Ward Cunningham

Agenda
1. About me

2. What is Dependency Injection?

3. Real World examples

4. Pros & Cons

5. Questions

About me
 Stephan Hochdörfer, bitExpert AG

 Department Manager Research Labs

 enjoying PHP since 1999

 S.Hochdoerfer@bitExpert.de

 @shochdoerfer

What is Dependency Injection?

What is Dependency?


What is Dependency?

 Application Layer

Data Access layer

Business logic layer

...

 External components

Framework classes

Webservices

...


Why are Dependencies bad?



„new“ is evil!



 Tightly coupled code

 Hard to re-use components

 Hard to test components, no isolation


Simple Dependency

Main Required
class class


Complex Dependency

Required
class
Main Required
class class
Required
class


Very complex Dependency
Database

Required
class
External
Main Required
resource
class class
Required
class

Required Required
Webservice
class class


How to Manage Dependencies?



You don`t need to. The Framework does it all!



Simple Container vs. Full stacked Framework



Consumer



Consumer Dependencies



Consumer Dependencies Container


Types of Dependency Injection

Type 1: Constructor injection

<?php

class MySampleService implements IMySampleService {
/**
* @var ISampleDao
*/
private $oSampleDao;

public function __construct(ISampleDao $poSampleDao) {
$this->oSampleDao = $poSamleDao;
}
}
?>



Type 2: Setter injection

<?php

/**
* @var ISampleDao
*/

public function setSampleDao(ISampleDao $poSampleDao) {
}
}
?>



Type 3: Interface injection

<?php

class MySampleService implements IMySampleService, IApplicationContextAware
{
/**
* @var IApplicationContext
*/
private $oCtx;

public function setApplicationContext(IApplicationContext $poCtx) {
$this->oCtx = $poCtx;
}
}
?>


Configuration Types

Type 1: Annotations

<?php

/**
* @var ISampleDao
*/

/**
* @Inject
*/
}
}
?>


Configuration Types

Type 1: Annotations
<?php

/**
* @var ISampleDao
*/

/**
* @Inject
* @Named('TheSampleDao')
*/
}
}
?>


Configuration Types

Type 2: External configuration via XML

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.bitexpert.de/schema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.bitexpert.de/schema/
http://www.bitexpert.de/schema/bitFramework-beans.xsd">

<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>


Configuration Types

Type 2: External configuration via YAML

services:
SampleDao:
class: SampleDao
arguments: ['app_sample', 'iSampleId', 'BoSample']
SampleService:
class: SampleService
arguments: [@SampleDao]


Configuration Types

Type 3: PHP Configuration

<?php
class BeanCache extends bF_Beanfactory_Container_PHP_ACache {
protected function createSampleDao() {
$oBean = new SampleDao('app_sample', 'iSampleId', 'BoSample');
return array("oBean" => $oBean, "bSingleton" => "1");
}

protected function createMySampleService() {
$oBean = new MySampleService($this->getBean('SampleDao'));
return array("oBean" => $oBean, "bSingleton" => "1");
}
?>


Cache, Cache, Cache!
180

160

140

120

100

80

60

40

20

0
XML no Caching XML with Caching PHP PHP compiled

Requests per Second meassured via Apache HTTP server benchmarking tool

Real world examples

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

Real World examples

Unittesting made easy

<?php
require_once 'PHPUnit/Framework.php';

class ServiceTest extends PHPUnit_Framework_TestCase {
public function testSampleService() {
$oSampleDao = $this->getMock('ISampleDao');

// run test case
$oService = new MySampleService($oSampleDao);
$bReturn = $oService->doWork();

// check assertions
$this->assertTrue($bReturn);
}
}
?>

Real World examples

One class, multiple configurations

Implementation

Live Working


<bean id="ExportLive" class="MyApp_Service_ExportManager">
<constructor-arg ref="DAOPageLive" />
</bean>

<bean id="ExportWorking" class="MyApp_Service_ExportManager">
<constructor-arg ref="DAOPageWorking" />
</bean>

</beans>

Real World examples

One class, multiple configurations II
<?php
class Promio_Action_Account_Auth extends bF_Mvc_Action_AFormAction {
private $oAccountManager;
private $iType;

public function __construct(Promio_Service_IAccountManager $poAccountManager) {
$this->oAccountManager = $poAccountManager;
}

public function setType($piType) {
$this->iType = (int) $piType;
}

protected function processFormSubmission(bF_Bo_ABo $poBOFormBackingObject) {
$oMaV = new bF_Mvc_ModelAndView($this->getSuccessView(), true);
try {
$poBOFormBackingObject->setType($this->iType);
$this->oAccountManager->save($poBOFormBackingObject);
}
catch(bF_Service_ServiceException $oException) {
$oMaV = new bF_Mvc_ModelAndView($this->getFailureView(), true);
}
return $oMaV;
}
}
?>

Real World examples

Mocking external services

Consumer Connector Webservice

IConnector interface


<bean id="Consumer" class="MyApp_Service_Consumer">
<constructor-arg ref="Connector" />
</bean>

</beans>

Real World examples

Mocking external services

alternative Local
Consumer
Connector filesystem

IConnector interface


<bean id="Consumer" class="MyApp_Service_Consumer">
<constructor-arg ref="AltConnector" />
</bean>

</beans>

Real World examples

Clean, readable code
<?php

class Promio_Action_News_Delete extends bF_Mvc_Action_AAction {
/**
* @var Promio_Service_INewsManager
*/
private $oNewsManager;

public function __construct(Promio_Service_INewsManager $poNewsManager) {
$this->oNewsManager = $poNewsManager;
}

protected function execute(bF_Mvc_Request $poRequest) {
try {
$this->oNewsManager->delete((int) $poRequest->getVar('iNewsId'));
}
catch(bF_Service_ServiceException $oException) {
}

$oMaV = new bF_Mvc_ModelAndView($this->getSuccessView(), true);
return $oMaV;
}
}
?>

Real World examples

No framework dependency
<?php

/**
* @var ISampleDao
*/

}

public function getSample($piSampleId) {
try {
return $this->oSampleDao->readByPrimaryKey((int) $piSampleId);
}
catch(DaoException $oException) {
}
}
}
?>

Pros & Cons

Benefits

 Good for agile development

Reducing amount of code

Helpful for Unit testing

 Loose coupling

Least intrusive mechanism

Switching implementations by changing configuration

Separation of glue code from business logic

 Clean view on the code

Separate configuration from code

Getting rid of boilerpate configuration code

Pros & Cons

Cons

 To many different implementations, no standard today!

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, …

No JSR 330 for PHP

 Simple Containers vs. fully-stacked Framework

No dependency from application to Container!

 Developers need to be aware of configuration ↔ runtime

Real world dependency injection - DPC10

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (20)

Similar to Real world dependency injection - DPC10

Similar to Real world dependency injection - DPC10 (20)

More from Stephan Hochdörfer

More from Stephan Hochdörfer (20)

Recently uploaded

Recently uploaded (20)

Real world dependency injection - DPC10