Simon Delicata

Lead développeur / Référent technique
Alptis Assurances

s.delicata@alptis.fr

http://www.afterglow.fr

Domain Driven Design : Tackling Complexity...

Eric Evans (2003)

• Ubiquitous language
• Bounded context
• Model Driven Design
• Layered Architecture
• Anti Corruption Layer
• Entities
• Value Objects
• Aggregates

Implementing Domain Driven Design

Vaughn Vernon (2013)

• Ubiquitous language
• Bounded context
• Model Driven Design
• Layered Architecture
• Anti Corruption Layer
• Entities
• Value Objects
• Aggregates
• Domain Events

Domain Event : Kesako ?

Représente un événement passé et daté

Lié à une entité ou un aggrégat

Contient les informations de l'évenement métier

interface DomainEventInterface
{
    public function getType();
    public function getRootEntityId();
    public function occurredOn();
    public function getInformations();
}

Pattern technique

• Entity
• Aggregates
• Repository
• Value Object
• Domain Event

Pattern stratégique

• Bounded Context
• ACL
• Ubiquitous Language
• ...

Des environnements métiers

Différents

Isolés

Avec leur propre Ubiquitous Language

E-Boutique

• Produit
• Commentaire
• Note
• Commande

Stock-Fournisseur

• Produit
• Fournisseur
• Prix
• Lieu (de stockage)

Même language

$a = "STRING";

dans des contexts différents

Identité

Comment synchroniser tout ça ?

Transactional Consistency

Server Down

Bad ux :(

Eventual Consistency

Les Domain Events à la rescousse !

Un peu de code

Exemple d'un domain event

class NomProduitChangedDomainEvent implements DomainEventInterface {

    public function __construct($produitId, $ancienNom, $nouveauNom) {
        $this->type = 'produit.nom.changed';
        $this->rootEntityId = $produitId;
        $this->occuredOn = new \DateTime();
        $this->informations = [
            'ancienNom' => $ancienNom,
            'nouveauNom' => $nouveauNom
        ];
    }

    public function getType() { return $this->type; }
    public function getRootEntityId() { return $this->rootEntityId; }
    public function occurredOn() { return $this->occuredOn; }
    public function getInformations() { return $this->informations; }
}

Dispatch depuis le stock

namespace Stock\Entity;

class Produit {

    private $nom;

    public function changeNom($nouveauNom) {
        $ancienNom = $this->nom;
        $this->nom = $nouveauNom;
        $this->dispatch(new NomProduitChangedDomainEvent(
            $this->getId(),
            $ancienNom,
            $nouveauNom
        ));
    }
}

Listener de l'e-boutique

namespace Eboutique\Listener;

class NomProduitChangedListener {

    public function __construct(EntityRepository $repository) {
        $this->repository = $repository;
    }

    public function handle(NomProduitChangedDomainEvent $event) {
        // Met à jour l'entité Produit du Bounded Context E-boutique
        $informations = $event->getInformations();
        $produit = $this->repository->get($event->getRootEntityId());
        $produit->changeNom($informations['nouveauNom']);
        $this->repository->save($produit);
    }
}

Meilleure expérience utilisateur

Robuste

Tolérant aux pannes

Scalabilité

BRAND NEW KILLER FEATURE !

Publish Subscribe

RabbitMQ

J'ai pas mis de chat, mais j'ai mis un lapin ca compte ?

Cluster

• cluster
• virtual host
• exchange
• queue
• fanout
• channel
• ack
• ...

Complexité

Publier des Domain Event sans Broker : C'est possible

Principe de base

Stocker toutes les modifications du système, plutôt que seulement son état actuel

Capturer les changements d'état sous forme d'event

Enregistrer les events dans un Event Store

Exemple d'architecture

Heu... Oui, mais du coup c'est quoi le rapport avec les Domain Events ?

Api REST

[
    {
        "_id":"a2ef4d345bf",
        "type":"adresse.changed",
        "entity_id": 5,
        "occurredOn": { "date": "2016-10-11 09:04:31.000000" },
        "nouvelle_adresse":"31 rue de la conf 69008 LYON"
    },
    {
        "_id":"bce462bb567",
        "type":"sexe.changed" // WTF ?
        "entity_id": 1,
        "occurredOn": { "date": "2016-10-09 09:00:31.000000" },
        "ancien_sexe": "F",
        "nouveau_sexe": "M"

    }
]

Pagination

Le dernier déjà traité

Cron

//Atention il faut qu'il soit synchrone
class DomainEventPersistanceListener {
    public function persistEvent(DomainEvent $domainEvent) {
        $this->repository->save($domainEvent);
    }
}

class EventRepository {
  public function findEvents($offset = false, $limit = false)
    {
        $results = $this->connection->db->events->find()->sort(array('occurredOn' => 1));
        $results->skip($offset);
        $results->limit($limit);
        return array_reverse($results);
    }
}

/** @Route("/events") */
public function lastEventsAction() {
    $last_page = $this->get('events_repository')->getLastPageNumber();
    $arResponse = [ 'events'=> $this->get('events_repo')->getLastEvents() ];
    if ($last_page>1) {
        $arResponse['previous_page'] = $last_page-1;
    }

    return new JsonResponse($arResponse);
}

/** @Route("/events/{page}") */
public function EventsAction($page) {
    $last_page = $this->get('events_repository')->getLastPageNumber();
    $arResponse = [ 'events'=>
    $this->get('events_repo')->getEventsByPage($page) ]
    if ($last_page>1) {
        $arResponse['previous_page'] = $last_page-1;
    }
    if ($page<$last_page) {
        $arResponse['next_page'] = $last_page+1;
    }
    $response = new JsonResponse($arResponse);
    $response->setMaxAge(31536000);
    return $response;
}

    //extrait de handle()
    $eventToDispatch = [];
    foreach ($this->getEvents() as $event) {
        if ($event['id']==$last_id) {
            break;
        }
        $eventsToDispatch[] = $event 
    }
    foreach(array_reverse($eventsToDispatch) as $event) {
        $this->dispatcher->dispatch($event);
    }

public function getEvents() {
    $events_api = json_decode(file_get_contents($url.'/events'));
    do {
        foreach($events_api['events'] as $event) {
            yield $event;
        }
        if (!isset($events_api['previous_page'])) {
            $events_api = false;
        } else {
            $events_api = json_decode(file_get_contents($events_api['previous_page']);
        }
    } while($events_api!==false);
}

namespace Eboutique\Listener;

class NomProduitChangedListener {

    public function __construct(EntityRepository $repository) {
        $this->repository = $repository;
    }

    public function handle(NomProduitChangedDomainEvent $event) {
        // Met à jour l'entité Produit du Bounded Context E-boutique
        $informations = $event->getEventInformations();
        $produit = $this->repository->get($event->getRootEntityId());
        $produit->changeNom($informations['nouveauNom']);
        $this->repository->save($produit);
    }
}