Real World Dependency Injection - phpugffm13

Real World Dependency Injection

Über mich

 Stephan Hochdörfer

 Head of IT der bitExpert AG, Mannheim

 PHP`ler seit 1999

 S.Hochdoerfer@bitExpert.de

 @shochdoerfer


Was sind Dependencies?



Applikation

Framework Bibliotheken



Controller

PHP Extensions Service / Model Utils

Datastore(s)


Sind Dependencies schlecht?



Dependencies sind nicht schlecht!



Nützlich und sinnvoll!



Fixe Dependencies sind schlecht!


„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


„new“ is evil!
<?php

public function __construct(IPageManager $pm) {
}

);
}
}


Wie verwaltet man Dependencies?


Automatismus notwendig!

Simple Container vs. Full stacked
DI Framework


Was ist Dependency Injection?



new DeletePage(new PageManager());



Consumer



Consumer Dependencies



Consumer Dependencies Container


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


Property Injection

"NEIN NEIN NEIN!"
David Zülke


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


Interne vs. Externe Konfiguration

Klassenkonfiguration
vs.
Instanzkonfiguration


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

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



WS-
WS-
Bookingmanager
Bookingmanager Webservice
Webservice
Konnektor
Konnektor

Zur Erinnerung:
Der Vertrag!



FS-
FS-
Bookingmanager
Bookingmanager Filesystem
Filesystem
Konnektor
Konnektor



FS-
FS-
Bookingmanager
Bookingmanager Filesystem
Filesystem
Konnektor
Konnektor

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?


Pimple


Pimple – Erste Schritte
<?php

class TalkService {
}

public function getTalks() {
}
}


Pimple – Erste Schritte
<?php
require_once '/path/to/Pimple.php';
require_once '/path/to/TalkService.php';

// create the Container
$container = new Pimple();

// define talkService object in container
$container['talkService'] = function ($c) {
return new TalkService();
};

// instantiate talkService from container
$talkService = $container['talkService'];


Pimple – Constructor Injection
<?php

interface GenericRepository {
public function readTalks();
}

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

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

}
}


Pimple – Constructor Injection
<?php


// define services in container
$container['talkRepository'] = function ($c) {
return new TalkRepository();
};
return new TalkService($c['talkRepository']);
};



Pimple – Setter Injection
<?php

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

class TalkService {
}

public function setLogger(Logger $logger) {
}

}
}


Pimple – Setter Injection
<?php


$container['logger'] = function ($c) {
return new Logger();
};
$container['talkRepository'] = function ($c) {
return new TalkRepository();
};
$service = new TalkService($c['talkRepository']);
$service->setLogger($c['logger']);
return $service;
};



Pimple – Allgemeines
<?php


$container['loggerShared'] = $c->share(function ($c) {
)};
$container['logger'] = function ($c) {
};

// instantiate logger from container
$logger = $container['logger'];

// instantiate shared logger from container (same instance!)
$logger2 = $container['loggerShared'];
$logger3 = $container['loggerShared'];


Bucket


Bucket – Constructor Injection
<?php

}

}
}

class TalkService {
}

}
}


Bucket – Constructor Injection
<?php
require_once '/path/to/bucket.inc.php';

$container = new bucket_Container();

$talkService = $container->create('TalkService');

// instantiate shared instances from container
$talkService2 = $container->get('TalkService');
$talkService3 = $container->get('TalkService');


ZendDi – Erste Schritte
<?php
namespace Acme;

class TalkService {
}

}
}


ZendDi – Erste Schritte
<?php

$di = new ZendDiDi();

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


ZendDi – Constructor Injection
<?php
namespace Acme;

}

}
}

class TalkService {
}

}
}


ZendDi – Constructor Injection
<?php




ZendDi – Setter Injection
<?php
namespace Acme;

class Logger {
}
}

class TalkService {
}

}

}
}


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

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

class TalkService implements LoggerAware {
}

}

}
}


ZendDi – Interface Injection
<?php




ZendDi – Grundsätzliches
<?php


var_dump($service);

$service2 = $di->get('AcmeTalkService');
var_dump($service2); // same instance as $service

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


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

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

// add injection method
$im = new ZendDiDefinitionBuilderInjectionMethod();
$im->setName('__construct');
$im->addParameter('repo', 'AcmeTalkRepository');
$class->addInjectionMethod($im);

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


ZendDi – Builder Definition

<?php

// add to Di
$defList = new ZendDiDefinitionList($builder);
$di = new ZendDiDi($defList);

var_dump($service);


ZendServiceManager to the resuce!


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
File 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 – Constructor Injection (manuell)
<?php


/**
*/
/**
*/

public function __construct(
}

}
}


Flow3 – Setter Injection (manuell)
<?php


/**
*/
/**
*/

public function setTalkService(
}

}
}


Flow3 – Setter Injection (manuell)
File 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)
File Objects.yaml in
Packages/Application/Acme.Demo/Configuration
# @package Acme
AcmeDemoServiceTalkServiceInterface:
className: 'AcmeDemoServiceTalkService'


Flow3 – Scoping
<?php


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

}
}


Vorteile

Lose Kopplung,
gesteigerte Wiederverwendbarkeit !


Vorteile

Codeumfang reduzieren,
Fokus auf das Wesentliche!


Vorteile

Hilft Entwicklern den Code
besser zu verstehen!


Nachteile – 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, …


Nachteile – Entwickler müssen umdenken

Konfiguration ↔ Laufzeit

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

Real World Dependency Injection - phpugffm13

More Related Content

What's hot (19)

Viewers also liked (6)

Similar to Real World Dependency Injection - phpugffm13 (20)

More from Stephan Hochdörfer (20)

Recently uploaded (20)

Real World Dependency Injection - phpugffm13