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

[email protected]

@shochdoerfer


Was sind Dependencies?


Applikation

Framework Bibliotheken



Controller

Service / Model

Datastore(s)

UtilsPHP Extensions


Sind Dependencies schlecht?



Dependencies sind nicht schlecht!



Nützlich und sinnvoll!



Fixe Dependencies sind schlecht!


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



„new“ is evil!



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



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

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;

}}


Property Injection


"NEIN NEIN NEIN!"David Zülke


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;

}}


Interne vs. Externe Konfiguration


Klassenkonfiguration vs.

Instanzkonfiguration

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

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!


Eine Klasse, mehrfache Ausprägung<?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>


Eine Klasse, mehrfache Ausprägung<?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-Konnektor

WS-Konnektor WebserviceWebservice



BookingmanagerBookingmanager WS-Konnektor

WS-Konnektor WebserviceWebservice


Zur Erinnerung: Der Vertrag!


BookingmanagerBookingmanager FS-Konnektor

FS-Konnektor FilesystemFilesystem



BookingmanagerBookingmanager FS-Konnektor

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


Pimple

Pimple – Erste Schritte


<?php

class TalkService {public function __construct() {}

public function getTalks() {}

}

Pimple – Erste Schritte


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




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


Pimple – Setter Injection


<?php

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

}


public function setLogger(Logger $logger) {}


}

Pimple – Setter Injection




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


Pimple – Allgemeines




// define services in container$container['loggerShared'] = $c->share(function ($c) { return new Logger();)};$container['logger'] = function ($c) { return new Logger();};

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


}


}



}

Bucket – Constructor Injection


<?phprequire_once '/path/to/bucket.inc.php';require_once '/path/to/TalkService.php';

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

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

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

Zend\Di – Erste Schritte


<?phpnamespace Acme;

class TalkService {public function __construct() {}


}

Zend\Di – Erste Schritte


<?php

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

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

Zend\Di – Constructor Injection




}


}



}

Zend\Di – Constructor Injection


<?php



Zend\Di – Setter Injection




}




}

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




}

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

}

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



}

Zend\Di – Interface Injection


<?php



Zend\Di – Grundsätzliches


<?php



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

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

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

);var_dump($service3); // new instance

Zend\Di – Builder Definition


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

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

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

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

Zend\Di – Builder Definition


<?php

// add to Di$defList = new \Zend\Di\DefinitionList($builder);$di = new \Zend\Di\Di($defList);



Zend\ServiceManager to the resuce!

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>

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






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

}


}

Flow3 – Setter Injection (manuell)






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

}


}

Flow3 – Setter Injection (manuell)


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

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

Flow3 – Scoping





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


}

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,

Zend\Di , Lion Framework, Spiral Framework, Xyster Framework, …


Nachteile – Entwickler müssen umdenken

Konfiguration Laufzeit↔


Vielen Dank!

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

Technology

Real World Dependency Injection - phpugffm13