Dependency Injection in PHP - dwx13

Dependency Injection
Was, wie, warum?
Stephan Hochdörfer, bitExpert AG

Dependency Injection – Was, wie warum?
Über mich
 Stephan Hochdörfer
 Head of IT der bitExpert AG, Mannheim
 PHP`ler seit 1999
 S.Hochdoerfer@bitExpert.de
 @shochdoerfer

DI ist nicht alles. Es geht um mehr.

Separation of Concerns

Design by Contract

"[...] zur Laufzeit die Abhängigkeiten
eines Objekts diesem von einem
anderen Objekt als Referenzen zur
Verfügung gestellt werden."
(Wikipedia)

Was sind Dependencies?

Sind Dependencies schlecht?

Dependencies: Starke Kopplung

Keine Wiederverwendung!

Keine Isolation, nicht testbar!

Dependency Wahnsinn!

Was ist Dependency Injection?

new DeletePage(new PageManager());

Consumer

Consumer Dependencies

Consumer Dependencies Container

s
„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!

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

Wie verwaltet man Dependencies?
Simple Container vs. Full stacked
DI Framework

Der Container nimmt uns die Arbeit ab!

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

Property Injection

Property Injection
"NEIN NEIN NEIN!"
David Zülke

Wie funktioniert das „Wiring“?

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

Interne vs. Externe Konfiguration
Klassenkonfiguration
vs.
Instanzkonfiguration

Was bringt mir das? Beispiel bitte.

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 ExporterPage Exporter
Released / Published
Pages
Released / Published
Pages
Workingcopy
Pages
Workingcopy
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) {
}
}

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

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 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 siehst 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
// define services in container
$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;
};

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;
interface GenericRepository {
public function readTalks();
}
class TalkRepository implements GenericRepository {
public function readTalks() {
}
}
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 AcmeTalkRepository()
)
);

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

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
<?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>
File services.xml in src/Acme/DemoBundle/Resources/config

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>
<service id="acme.talk.logger"
class="AcmeTalkBundleServiceLogger" />
<call method="setLogger">
<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>

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)
File Objects.yaml in Packages/Application/Acme.Demo/Configuration
# @package Acme
AcmeDemoControllerStandardController:
properties:
talkService:
object: AcmeDemoServiceTalkService

Flow3 – Setter Injection (automatisch)
<?php
/**
*/
/**
*/
public function injectTalkService(
}
}
}

Fokus aufs Wesentliche. Keine Ablenkung.

Wiederverwendung steigern.

Hilft den Code besser zu verstehen.

Wieder Spaß bei der Arbeit ;)

Kein Standard. Kein Tooling.

Es braucht Zeit um DI zu verstehen.

Konfiguration vs. Laufzeit

Dependency Injection in PHP - dwx13

More Related Content

What's hot (19)

Similar to Dependency Injection in PHP - dwx13 (20)

More from Stephan Hochdörfer (20)

Recently uploaded (20)

Dependency Injection in PHP - dwx13