Real World Dependency Injection SE - phpugrhh

Real World
Dependency Injection
Special Edition :)

Real World Dependency Injection – Special Edition

Über mich

 Stephan Hochdörfer, bitExpert AG
 Department Manager Research Labs
 PHP`ler seit 1999
 S.Hochdoerfer@bitExpert.de
 @shochdoerfer


Was sind Dependencies?


Sind Dependencies schlecht?



Normalerweise nicht...



…so lange Dependencies nicht
hartcodiert sind!


Starke Kopplung


Keine Wiederverwendung!


Keine Isolation, nicht testbar!


Dependency Wahnsinn!


s

„new“ is evil!


„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!
<?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 als Vertrag


„new“ is evil!
<?php

public function __construct(IPageManager $pm) {
}

);
}
}


Wie verwaltet man Dependencies?


Händisch? Mit der heißen Nadel gestrickt...


Automatismus notwendig!

Einfacher Container vs. Fullstack
DI Framework


Was ist Dependency Injection?

Consumer



Consumer Dependencies



Consumer Dependencies Container


Wie Dependencies injizieren?


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


Wie verbinden wir nun alles?


Annotations
<?php

private $sampleDao;

/**
* @Inject
*/
public function __construct(ISampleDao $sampleDao)
{
}
}


Annotations
<?php

private $sampleDao;

/**
* @Inject
* @Named('TheSampleDao')
*/
public function __construct(ISampleDao $sampleDao)
{
}
}


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


Externe Konfiguration - YAML

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


Externe Konfiguration - 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;
}
}


Beispiele gefällig?


Unittesting einfach gemacht


Unittesting einfach gemacht
<?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);
}
}


Eine Klasse, mehrfache Ausprägung



Page Exporter
Page Exporter



Page Exporter
Page Exporter

Released / /Published
Released Published Workingcopy
Workingcopy
Pages
Pages Pages
Pages


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


<?php
abstract class PageExporter {
protected function setPageDao(IPageDao $pageDao) {
}
}

Zur Erinnerung:
Der Vertrag!


<?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');


Eine Klasse, mehrfache Ausprägung II



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) {
}
}


Externe Services mocken



WS-
WS-
Bookingmanager
Bookingmanager Webservice
Webservice
Connector
Connector



WS-
WS-
Bookingmanager
Bookingmanager Webservice
Webservice
Connector
Connector

Zur Erinnerung:
Der Vertrag!



FS-
FS-
Bookingmanager
Bookingmanager Filesystem
Filesystem
Connector
Connector



FS-
FS-
Bookingmanager
Bookingmanager Filesystem
Filesystem
Connector
Connector

erfüllt den
Vertrag!


Sauberer, lesbarer Code


Sauberer, lesbarer Code
<?php

public function __construct(IPageManager $pm) {
}

(int) $request->get('pageId'));

return new ModelAndView($this->getSuccessView());
}
}


Keine Framework Abhängigkeit


Keine Framework Abhängigkeit
<?php
private $sampleDao;

public function __construct(ISampleDao $sampleDao) {
}

public function getSample($sampleId) {
try {
return $this->sampleDao->readById($sampleId);
}
catch(DaoException $exception) {}
}
}


Wie sieht das nun in der Praxis aus?


ZendDi – Erste Schritte
<?php
namespace Acme;

class TalkService {
}

public function getTalks() {
}
}


ZendDi – Erste Schritte
<?php

$di = new ZendDiDi();

$service = $di->get('AcmeTalkService');
$service->getTalks();


ZendDi – Constructor Injection
<?php
namespace Acme;

interface GenericRepository {
public function readTalks();
}

class TalkRepository implements GenericRepository {
public function readTalks() {
}
}

class TalkService {
public function __construct(TalkRepository $repo) {
}

}
}


ZendDi – Constructor Injection
<?php




ZendDi – Setter Injection
<?php
namespace Acme;

class Logger {
public function doLog($logMsg) {
}
}

class TalkService {
}

public function setLogger(Logger $logger) {
}

}
}


ZendDi – Setter Injection
<?php
$di->configure(
new ZendDiConfiguration(
array(
'definition' => array(
'class' => array(
'AcmeTalkService' => array(
'setLogger' => array('required' => true)
)
)
)
)
)
);

var_dump($service);


ZendDi – Interface Injection
<?php
namespace Acme;

class Logger {
public function doLog($logMsg) {
}
}

interface LoggerAware {
public function setLogger(Logger $logger);
}

class TalkService implements LoggerAware {
}

public function setLogger(Logger $logger) {
}

}
}


ZendDi – Interface Injection
<?php




ZendDi – Grundsätzliches
<?php


var_dump($service);

$service2 = $di->get('AcmeTalkService');
var_dump($service2); // gleiche Instanz wie $service

$service3 = $di->get(
'AcmeTalkService',
array(
'repo' => new phpbnl12TalkRepository()
)
);
var_dump($service3); // neue Instanz


ZendDi – Builder Definition
<?php
// Dependency beschreiben
$dep = new ZendDiDefinitionBuilderPhpClass();
$dep->setName('AcmeTalkRepository');

// Klasse beschreiben
$class = new ZendDiDefinitionBuilderPhpClass();
$class->setName('AcmeTalkService');

// Injection Methode beschreiben
$im = new ZendDiDefinitionBuilderInjectionMethod();
$im->setName('__construct');
$im->addParameter('repo', 'AcmeTalkRepository');
$class->addInjectionMethod($im);

// Builder konfigurieren
$builder = new ZendDiDefinitionBuilderDefinition();
$builder->addClass($dep);
$builder->addClass($class);


ZendDi – Builder Definition
<?php

// zur DefinitionList hinzufügen
$defList = new ZendDiDefinitionList($builder);
$di = new ZendDiDi($defList);

var_dump($service);


Symfony2
<?php
namespace AcmeTalkBundleController;
use SymfonyBundleFrameworkBundleControllerController;
use SensioBundleFrameworkExtraBundleConfigurationRoute;
use SensioBundleFrameworkExtraBundleConfigurationTemplate;

class TalkController extends Controller {
/**
* @Route("/", name="_talk")
* @Template()
*/
public function indexAction() {
$service = $this->get('acme.talk.service');
return array();
}
}


Symfony2 – Konfigurationsdatei
Datei services.xml in src/Acme/DemoBundle/Resources/config
<?xml version="1.0" ?>
<container xmlns="http://symfony.com/schema/dic/services"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://symfony.com/schema/dic/services
http://symfony.com/schema/dic/services/services-1.0.xsd">

</container>


Symfony2 – Constructor Injection

<services>
<service id="acme.talk.repo"
class="AcmeTalkBundleServiceTalkRepository" />

<service id="acme.talk.service"
class="AcmeTalkBundleServiceTalkService">
<argument type="service" id="acme.talk.repo" />
</service>
</services>
</container>


Symfony2 – Setter Injection

<services>
<service id="acme.talk.logger"
class="AcmeTalkBundleServiceLogger" />


<call method="setLogger">
<argument type="service" id="acme.talk.logger" />
</call>
</service>
</services>
</container>


Symfony2 – Setter Injection (optional)

<services>
class="AcmeTalkBundleServiceLogger" />


<argument type="service" id="acme.talk.logger"
on-invalid="ignore" />
</call>
</service>
</services>
</container>


Symfony2 – Property Injection

<services>

<property name="talkRepository" type="service"
id="acme.talk.repo" />
</service>
</services>
</container>


Symfony2 – private / öffentliche Services

<services>
class="AcmeTalkBundleServiceLogger" public="false" />


<argument type="service" id="acme.talk.logger" />
</call>
</service>
</services>
</container>


Symfony2 – Vererbung

<services>
<service id="acme.talk.serviceparent"
class="AcmeTalkBundleServiceTalkService" abstract="true">
</service>

<service id="acme.talk.service" parent="acme.talk.serviceparent" />

<service id="acme.talk.service2" parent="acme.talk.serviceparent" />
</services>
</container>


Symfony2 – Scoping

<services>

class="AcmeTalkBundleServiceTalkService" scope="prototype">
</service>
</services>
</container>


Flow3 – Constructor Injection
<?php
namespace AcmeDemoController;

use TYPO3FLOW3Annotations as FLOW3;

/**
* @FLOW3Scope("session")
*/
class StandardController extends TYPO3FLOW3MVCControllerActionController {
/**
* @var AcmeDemoServiceTalkServiceInterface
*/
protected $talkService;

public function __construct(
AcmeDemoServiceTalkService $talkService) {
$this->talkService = $talkService;
}

}
}


Flow3 – Setter Injection (manuell)
<?php


/**
*/
/**
*/

public function setTalkService(
}

}
}


Flow3 – Setter Injection (manuell)
Datei Objects.yaml in Packages/Application/Acme.Demo/Configuration
# @package Acme
AcmeDemoControllerStandardController:
properties:
talkService:
object: AcmeDemoServiceTalkService


Flow3 – Setter Injection (automatisch)
<?php


/**
*/
/**
*/

public function injectTalkService(
}

}
}


Flow3 – Setter Injection (automatisch)
<?php


/**
*/
/**
*/

public function injectSomethingElse(
}

}
}


Flow3 – Property Injection
<?php


/**
*/
/**
* @var AcmeDemoServiceTalkService
* @FLOW3Inject
*/

}
}


Flow3 – Property Injection (mittels Interface)
<?php


/**
*/
/**
* @FLOW3Inject
*/

}
}


Flow3 – Property Injection (mittels Interface)
Datei Objects.yaml in Packages/Application/Acme.Demo/Configuration
# @package Acme
AcmeDemoServiceTalkServiceInterface:
className: 'AcmeDemoServiceTalkService'


Flow3 – Scoping
<?php


/**
*/
/**
* @FLOW3Inject
*/

}
}


Vorteile


Vorteile

Lose Kopplung,
gesteigerte Wiederverwendbarkeit !


Vorteile

Codeumfang reduzieren,
Fokus auf das Wesentliche!


Vorteile

Hilft Entwicklern den Code
besser zu verstehen!


Nachteil – Kein JSR330 für PHP

Bucket, Crafty, FLOW3, Imind_Context,
PicoContainer, Pimple, Phemto,
Stubbles, Symfony 2.0, Sphicy, Solar,
Substrate, XJConf, Yadif, ZendDi , Lion
Framework, Spiral Framework, Xyster
Framework, …


Nachteil – Entwickler müssen umdenken

Konfiguration ↔ Laufzeit


Nachteil – Keine IDE Unterstützung!

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

Real World Dependency Injection SE - phpugrhh

More Related Content

What's hot (19)

More from Stephan Hochdörfer (20)

Recently uploaded (20)

Real World Dependency Injection SE - phpugrhh