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

[email protected]

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

<?phpclass 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!



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!



public function __construct(IPageManager $pm) {$this->pageManager = $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



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

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

public function setSampleDao(ISampleDao $sampleDao){$this->sampleDao = $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

class MySampleService implements IMySampleService { private $sampleDao;

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

$this->sampleDao = $sampleDao; }}


Annotations<?php

class MySampleService implements IMySampleService { private $sampleDao;

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

$this->sampleDao = $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<?phpclass 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<?phprequire_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 ExporterPage Exporter



Page ExporterPage Exporter

Released / PublishedPages

Released / PublishedPages

WorkingcopyPages

WorkingcopyPages


Eine Klasse, mehrfache Ausprägung<?phpabstract class PageExporter { protected function setPageDao(IPageDao $pageDao) { $this->pageDao = $pageDao; }}


Eine Klasse, mehrfache Ausprägung<?phpabstract class PageExporter { protected function setPageDao(IPageDao $pageDao) { $this->pageDao = $pageDao; }}

Zur Erinnerung: Der Vertrag!



<?phpclass PublishedPageExporter extends PageExporter { public function __construct() { $this->setPageDao(new PublishedPageDao()); }}

class WorkingCopyPageExporter extends PageExporter { public function __construct() { $this->setPageDao(new WorkingCopyPageDao()); }}


"Only deleted code is good code!"Oliver Gierke



Eine Klasse, mehrfache Ausprägung<?phpclass PageExporter { public function __construct(IPageDao $pageDao) { $this->pageDao = $pageDao; }}


Eine Klasse, mehrfache Ausprägung<?xml version="1.0" encoding="UTF-8" ?><beans>

<bean id="ExportLive" class="PageExporter"><constructor-arg ref="PublishedPageDao" />

</bean>

<bean id="ExportWorking" class="PageExporter"><constructor-arg ref="WorkingCopyPageDao" />

</bean></beans>



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


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

}



Eine Klasse, mehrfache Ausprägung II<?xml version="1.0" encoding="UTF-8" ?><beans>

<bean id="EditHeadline" class="EditPart"><constructor-arg ref="PagePartDao" /><property name="Type" const="PType::Headline" />

</bean>

<bean id="EditContent" class="EditPart"><constructor-arg ref="PagePartDao" /><property name="Type" const="PType::Content" />

</bean>

</beans>


Externe Services mocken



BookingmanagerBookingmanager WS-Connector

WS-Connector WebserviceWebservice



BookingmanagerBookingmanager WS-Connector

WS-Connector WebserviceWebservice


Zur Erinnerung: Der Vertrag!


BookingmanagerBookingmanager FS-Connector

FS-Connector FilesystemFilesystem



BookingmanagerBookingmanager FS-Connector

FS-Connector FilesystemFilesystem

erfüllt denVertrag!


Sauberer, lesbarer Code


Sauberer, lesbarer Code<?phpclass DeletePage extends Mvc_Action_AAction {


public function __construct(IPageManager $pm) {$this->pageManager = $pm;

}



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

}


Keine Framework Abhängigkeit


Keine Framework Abhängigkeit<?phpclass MySampleService implements IMySampleService { private $sampleDao;

public function __construct(ISampleDao $sampleDao) {$this->sampleDao = $sampleDao;

}

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

}}



Wie sieht das nun in der Praxis aus?


Zend\Di – Erste Schritte


<?phpnamespace Acme;

class TalkService {public function __construct() {}

public function getTalks() {}

}

Zend\Di – Erste Schritte


<?php

$di = new \Zend\Di\Di();

$service = $di->get('Acme\TalkService');$service->getTalks();

Zend\Di – Constructor Injection



interface GenericRepository {public function readTalks();

}

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

}

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


}

Zend\Di – Constructor Injection


<?php



Zend\Di – Setter Injection



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

}

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

public function setLogger(Logger $logger) {}


}

Zend\Di – Setter Injection


<?php$di = new \Zend\Di\Di();$di->configure(

new Zend\Di\Configuration(array(

'definition' => array('class' => array(

'Acme\TalkService' => array('setLogger' => array('required' => true)

))

))

));

$service = $di->get('Acme\TalkService');var_dump($service);

Zend\Di – Interface Injection



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

}

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

}

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

public function setLogger(Logger $logger) {}


}

Zend\Di – Interface Injection


<?php



Zend\Di – Grundsätzliches


<?php



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

$service3 = $di->get('Acme\TalkService',array(

'repo' => new \phpbnl12\TalkRepository())

);var_dump($service3); // neue Instanz

Zend\Di – Builder Definition


<?php// Dependency beschreiben$dep = new \Zend\Di\Definition\Builder\PhpClass();$dep->setName('Acme\TalkRepository');

// Klasse beschreiben$class = new \Zend\Di\Definition\Builder\PhpClass();$class->setName('Acme\TalkService');

// Injection Methode beschreiben$im = new \Zend\Di\Definition\Builder\InjectionMethod();$im->setName('__construct');$im->addParameter('repo', 'Acme\TalkRepository');$class->addInjectionMethod($im);

// Builder konfigurieren$builder = new \Zend\Di\Definition\BuilderDefinition();$builder->addClass($dep);$builder->addClass($class);

Zend\Di – Builder Definition


<?php

// zur DefinitionList hinzufügen$defList = new \Zend\Di\DefinitionList($builder);$di = new \Zend\Di\Di($defList);



Symfony2


<?phpnamespace Acme\TalkBundle\Controller;use Symfony\Bundle\FrameworkBundle\Controller\Controller;use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;

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

Symfony2 – Konfigurationsdatei


<?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/serviceshttp://symfony.com/schema/dic/services/services-1.0.xsd">

</container>

Datei services.xml in src/Acme/DemoBundle/Resources/config

Symfony2 – Constructor Injection


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

<services><service id="acme.talk.repo"

class="Acme\TalkBundle\Service\TalkRepository" />

<service id="acme.talk.service" class="Acme\TalkBundle\Service\TalkService">

<argument type="service" id="acme.talk.repo" /></service>

</services></container>

Symfony2 – Setter Injection





<services><service id="acme.talk.logger"

class="Acme\TalkBundle\Service\Logger" />

<service id="acme.talk.repo" class="Acme\TalkBundle\Service\TalkRepository" />


<argument type="service" id="acme.talk.repo" /><call method="setLogger">

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

</service></services>

</container>

Symfony2 – Setter Injection (optional)






class="Acme\TalkBundle\Service\Logger" />




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

</call></service>


Symfony2 – Property Injection








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


</container>

Symfony2 – private / öffentliche Services






class="Acme\TalkBundle\Service\Logger" public="false" />




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


</container>

Symfony2 – Vererbung





<services><service id="acme.talk.serviceparent"

class="Acme\TalkBundle\Service\TalkService" abstract="true"><property name="talkRepository" type="service"

id="acme.talk.repo" /></service>

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

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

</container>

Symfony2 – Scoping







<service id="acme.talk.service"class="Acme\TalkBundle\Service\TalkService" scope="prototype"><property name="talkRepository" type="service"

id="acme.talk.repo" /></service>



Flow3 – Constructor Injection


<?phpnamespace Acme\Demo\Controller;

use TYPO3\FLOW3\Annotations as FLOW3;

/** * @FLOW3\Scope("session") */class StandardController extends \TYPO3\FLOW3\MVC\Controller\ActionController {

/** * @var \Acme\Demo\Service\TalkServiceInterface */protected $talkService;

public function __construct(\Acme\Demo\Service\TalkService $talkService) {$this->talkService = $talkService;

}

public function indexAction() {}

}

Flow3 – Setter Injection (manuell)






public function setTalkService(\Acme\Demo\Service\TalkService $talkService) {$this->talkService = $talkService;

}


}

Flow3 – Setter Injection (manuell)


Datei Objects.yaml in Packages/Application/Acme.Demo/Configuration# @package AcmeAcme\Demo\Controller\StandardController: properties: talkService: object: Acme\Demo\Service\TalkService

Flow3 – Setter Injection (automatisch)






public function injectTalkService(\Acme\Demo\Service\TalkService $talkService) {$this->talkService = $talkService;

}


}

Flow3 – Setter Injection (automatisch)






public function injectSomethingElse(\Acme\Demo\Service\TalkService $talkService) {$this->talkService = $talkService;

}


}

Flow3 – Property Injection





/** * @var \Acme\Demo\Service\TalkService * @FLOW3\Inject */protected $talkService;


}

Flow3 – Property Injection (mittels Interface)





/** * @var \Acme\Demo\Service\TalkServiceInterface * @FLOW3\Inject */protected $talkService;


}

Flow3 – Property Injection (mittels Interface)


# @package AcmeAcme\Demo\Service\TalkServiceInterface: className: 'Acme\Demo\Service\TalkService'

Datei Objects.yaml in Packages/Application/Acme.Demo/Configuration

Flow3 – Scoping





/** * @var \Acme\Demo\Service\TalkServiceInterface * @FLOW3\Inject */protected $talkService;


}

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, Zend\Di , Lion Framework, Spiral Framework, Xyster

Framework, …


Nachteil – Entwickler müssen umdenken

Konfiguration ↔ Laufzeit



Nachteil – Keine IDE Unterstützung!

Vielen Dank!

Image Creditshttp://www.sxc.hu/photo/1028452

Technology

Real World Dependency Injection SE - phpugrhh