Design Patterns avec PHP 5.3, Symfony et Pimple

Simplifiez-vous les Design
Patterns avec PHP 5.3
Hugo Hamon – 12/07/12

Observateur

Dependency Injection

Inversion de Contrôle

Un sujet, l’objet
observable, émet un signal
à des modules qui jouent
le rôle d’observateurs.

Le Dispatcheur est un objet
qui gère les connexions
entre le sujet observé et ses
observateurs (écouteurs).

# composer.json

{
"require": {
"php": ">=5.3.3",
"symfony/event-dispatcher": "2.1.*"
}
}

use SymfonyComponentEventDispatcherEvent;
use SymfonyComponentEventDispatcherEventDispatcher;
use AFUPArticleListener;

$dispatcher = new EventDispatcher();

// Déclaration des écouteurs
$listener1 = array(new ArticleListener(), 'onDelete');
$listener2 = array(new ArticleListener(), 'onSave');

// Enregistrement des écouteurs
$dispatcher->addListener('article.delete', $listener1);
$dispatcher->addListener('article.pre_save', $listener2);

// Notification des écouteurs
$dispatcher->dispatch('article.pre_save', new Event());

use AFUPModelArticle;

$article = new Article();
$article->setTitle('AFUP Design Patterns');
$article->setContent('Some **content**');
$article->save();

echo $article->getHtmlContent();

<p>
Some <strong>content</strong>
</p>

namespace AFUPModel;

use PropelRuntimeConnectionConnectionInterface;
use dflydevmarkdownMarkdownParser;

class Article extends AFUPModelBaseArticle
{
public function save(ConnectionInterface $con = null)
{
$parser = new MarkdownParser();
$html = $parser->transformMarkdown($this->getContent());
$this->setHtmlContent($html);

$ret = parent::save($con);

$this->updateLuceneIndex();

return $ret;
}
}


use AFUPModelBaseArticle as BaseArticle;

class Article extends BaseArticle
{
private $dispatcher;

public function setDispatcher(EventDispatcher $dispatcher)
{
$this->dispatcher = $dispatcher;
}
}


// ...
use PropelRuntimeConnectionConnectionInterface;
use AFUPEventArticleEvent;

class Article extends BaseArticle
{
// ...
public function save(ConnectionInterface $con = null)
{
$event = new ArticleEvent($this);
$this->dispatcher->dispatch('article.pre_save', $event);

$ret = parent::save($con);
$this->dispatcher->dispatch('article.post_save', $event);

return $ret;
}
}

namespace AFUPEvent;

use SymfonyComponentEventDispatcherEvent;

class ArticleEvent extends Event
{
private $article;

public function __construct(Article $article)
{
$this->article = $article;
}

public function getArticle()
{
return $this->article;
}
}

namespace AFUPListener;

use dflydevmarkdownMarkdownParser;

class ArticleListener
{
public function onPreSave(ArticleEvent $event)
{
$article = $event->getArticle();
$markdown = $article->getContent();

$parser = new MarkdownParser();
$html = $parser->transformMarkdown($markdown);
$article->setHtmlContent($html);
}
}


use ZendSearchLuceneDocument;
use ZendSearchLuceneDocumentField;
use AFUPModelArticlePeer;

class LuceneListener
{
public function onPostSave(ArticleEvent $event)
{

// ...
}
}


// ...
class LuceneListener
{
public function onPostSave(ArticleEvent $event)
{
$index = ArticlePeer::getLuceneIndex();

// remove existing entries
foreach ($index->find('pk:'.$article->getId()) as $hit) {
$index->delete($hit->id);
}

$doc = new Document();
$doc->addField(Field::Keyword('pk', $article->getId()));
$doc->addField(Field::UnStored('title', $article->getTitle()));
$doc->addField(Field::UnStored('content', $article->getContent()));

$index->addDocument($doc);
$index->commit();
}
}

Enregistrer les
écouteurs

use AFUPListenerArticleListener;
use AFUPListenerLuceneListener;

// Déclaration des écouteurs
$listener1 = array(new ArticleListener(), 'onPreSave');
$listener2 = array(new LuceneListener(), 'onPostSave');

// Enregistrement des écouteurs
$dispatcher = new EventDispatcher();
$dispatcher->addListener('article.pre_save', $listener1);
$dispatcher->addListener('article.post_save', $listener2);

$article = new Article();

$article->setDispatcher($dispatcher);

$article->setTitle('AFUP Design Patterns');

$article->setMarkdownContent(
'Some **markdown** content'
);

$article->save();

class Mailer
{
public function send(Message $message)
{
try {
$transport = new SMTPTransport(
'smtp.foo.com', 1234, 'mailer', 'p$wD^'
);
return $transport->send($message);
} catch (TransportException $e) {
$logger = Logger::getInstance();
$logger->log('Unable to send message to...');
$logger->logException($e);
throw $e;
}
}
}

$message = new Message();
$message->setFrom('me@example.com');
$message->setTo('you@example.com');
$message->setSubject('Bonjour ...');
$message->setBody('Hello ...');

$mailer = new Mailer();
$mailer->send($message);

$transport = new SMTPTransport(
'smtp.foo.com',
1234,
'mailer',
'p$wD^'
);

Je veux utiliser
un transport
diﬀérent…

Je veux configurer
le SMTP en dev et
en prod…

$logger = Logger::getInstance();
$logger->log('Unable to...');
$logger->logException($e);

Si je veux changer
la configuration
du logger?

Je veux tester mon
code avec PHPUnit
et je n’y arrive
pas…

Injecter ses
dépendances au
Mailer

Injection par
les propriétés

class Mailer
{
public $transport;

{
try {
$this->transport->send($message);
// ...
}
}
}

$message = Message();
$message->setTo('you@example.com');
$message->setSubject('Bonjour ...');
$message->setBody('Hello ...');

$transport = new SMTPTransport('...');

$mailer = new Mailer();
$mailer->transport = $transport;

class Mailer
{
private $transport;

function __construct(Transport $t)
{
$this->transport = $t;
}
}

// ...


$mailer = new Mailer($transport);

class Mailer
{
private $logger;

function setLogger(Logger $logger)
{
$this->logger = $logger;
}
}

class Mailer
{
// ...
{
try {
$this->transport->send($message);
if (null !== $this->logger) {
$this->logger->log('...');
$this->logger->logException($e);
throw $e;
}
}
}
}

// ...

$logger = new FileLogger('/to/dev.log');

$mailer = new Mailer($transport);
$mailer->setLogger($logger);

Découplage
avec les
interfaces

class Mailer
{
function __construct(TransportInterface $t)
{
$this->transport = $t;
}

function setLogger(LoggerInterface $logger)
{
$this->logger = $logger;
}
}

class SMTPTransport implements TransportInterface
{
}

class MailTransport implements TransportInterface
{
}

class NullTransport implements TransportInterface
{
}

Configurabilité
Modularité
Testabilité

Construction
un peu plus
Complexe

# composer.json
{
"require": {
"pimple/pimple": "1.0.*"
}
}

Global Configuration
+ Lazy Services
= Container

Paramètres
Globaux de
Configuration

$pimple = new Pimple();

$pimple['logger.file'] = '/path/to/dev.log';
$pimple['logger.severity'] = 200;

$pimple['transport.smtp.host'] = 'smtp.foo.com';
$pimple['transport.smtp.port'] = 1234;
$pimple['transport.smtp.user'] = 'mailer';
$pimple['transport.smtp.passwd'] = '^p4$$W0rD*';

$pimple['logger'] = $pimple->share(function ($c) {

if (!is_writable($c['logger.file'])) {
throw new Exception('...');
}

$logger = new Logger($c['logger.file']);

if (isset($c['logger.severity'])) {
$logger->setSeverity($c['logger.severity']);
}

return $logger;
});

$pimple['mailer.transport'] = $pimple
->share(function ($c) {

return new SMTPTransport(
$c['transport.smtp.host'],
$c['transport.smtp.port'],
$c['transport.smtp.user'],
$c['transport.smtp.passwd']
);
});

$pimple['mailer'] = $pimple->share(function ($c) {

$mailer = new Mailer($c['mailer.transport']);

if (isset($c['logger'])) {
$mailer->setLogger($c['logger']);
}

return $mailer;
});

Initialisation des
services à la
demande

$pimple = new Pimple();
$pimple['logger.file'] = '/path/to/dev.log';
$pimple['logger.severity'] = 200;
// ...

// ...

// Création à la demande du mailer
$pimple['mailer']->send($message);

Design Patterns avec PHP 5.3, Symfony et Pimple

Design Patterns avec PHP 5.3, Symfony et Pimple

Recommended

More Related Content

What's hot (20)

Similar to Design Patterns avec PHP 5.3, Symfony et Pimple (14)

More from Hugo Hamon (11)

Recently uploaded (20)

Design Patterns avec PHP 5.3, Symfony et Pimple