Rich domain model with symfony 2.5 and doctrine 2.5

Rich Domain Model with
Symfony2 and Doctrine2
Leonardo Proietti
@_leopro_
Symfony Day Italy
Milan, 10 October 2014

twitter.com/_leopro_
github.com/leopro
linkedin.com/in/leonardoproietti

domain = problem space
domain model = solution space

Domain
“A Domain [...] is what an organization
does and the world it does in.”
(Vaughn Vernon, “Implementing Domain-Driven Design”)

Domain Model
“A model is a simplification. It is an
interpretation of reality that abstracts the
aspects relevant to solving problem at hand
and ignores extraneous detail.”
(Eric Evans, "Domain Driven Design")

Domain Model
“In DDD, domain model refers to a
class.”
(Julie Lerman, http://msdn.microsoft.com/en-us/magazine/dn385704.aspx)

Domain Model
“An object model of the domain that
incorporates both behavior and data.”
(Martin Fowler, http://martinfowler.com/eaaCatalog/domainModel.html)

First, because it’s not anemic
Martin Fowler
http://martinfowler.com/bliki/AnemicDomainModel.html

<?php
class Anemic
{
private $shouldNotChangeAfterCreation;
private $shouldBeChangedOnlyOnEdit;
private $couldBeChangedAnytime;
public function setCouldBeChangedAnytime($couldBeChangedAnytime) {}
public function setShouldBeChangedOnlyOnEdit($shouldBeChangedOnlyOnEdit) {}
public function setShouldNotChangeAfterCreation($shouldNotChangeAfterCreation {}
}

<?php
class SomeService
{
public function doStuffOnCreation()
{
$anemic = new Anemic();
$anemic->setCouldBeChangedAnytime('abc');
$anemic->setShouldNotChangeAfterCreation('def');
$unitOfWork->persist($anemic);
$unitOfWork->flush();
}
}

<?php
class SomeService
{
public function doStuffOnEdit()
{
$anemic->setShouldBeChangedOnlyOnEdit(‘123’);
}
}

<?php
class SomeService
{
{
Loss of memory
}
}

<?php
class SomeService
{
{
$anemic->setShouldNotChangeAfterCreation('def');
}
}

<?php
class BehaviouralClass
{
public function __construct($shouldNotChangeAfterCreation, $couldBeChangedAnytime)
{
$this->shouldNotChangeAfterCreation = $shouldNotChangeAfterCreation;
$this->couldBeChangedAnytime = $couldBeChangedAnytime;
}
public function modify($shouldBeChangedOnlyOnEdit, $couldBeChangedAnytime = null)
{
$this->shouldBeChangedOnlyOnEdit = $shouldBeChangedOnlyOnEdit;
}
}

<?php
class BehaviouralClass
{
It's not still rich, lacks of ...
public function __construct($shouldNotChangeAfterCreation, $couldBeChangedAnytime)
{
$this->shouldNotChangeAfterCreation = $shouldNotChangeAfterCreation;
}
public function modify($shouldBeChangedOnlyOnEdit, $couldBeChangedAnytime = null)
{
$this->shouldBeChangedOnlyOnEdit = $shouldBeChangedOnlyOnEdit;
}
}

Ubiquitous Language
“the domain model can provide the backbone
for that common language [...]. The vocabulary
of that ubiquitius language includes the names
of classes and prominent operations”
(Eric Evans, "Domain Driven Design")

What does “coffee” mean?
Alberto Brandolini AKA @ziobrando

Our domain is an online game that simulate the soccer’s world.

What does “player” mean
in our domain?

The meaning of “player”
Within game engine context
a model of a real soccer player,
modelled with behaviours to fit the
requirements of the game engine.

Within data import context
a model of a real soccer player, but
modelled for a simple CRUD.

Within user profile context
a model of the user of the website,
who plays the game.

League Team
Calendar Player
Lineup
Coach
Core context

League Team
Calendar Player
Lineup
Coach
(the player in “user
context”)
Core context

Player
Game context User context
Uuid
Name
Roles
Uuid
Email
Password

<?php
class League
{
private $id;
private $name;
private $teams;
public function __construct(Uuid $uuid, $name)
{
$this->id = $uuid;
$this->name = $name;
$this->teams = new ArrayCollection();
}
public function registerTeam(Team $team)
{
$this->teams->add($team);
}
}

<?php
class League
{
private $id;
private $name;
private $teams;
A team must do a registration
public function __construct({
to the league
Uuid $uuid, $name)
$this->id = $uuid;
}
{
}
}

<?php
class League
{
private $id;
private $genericInfo;
private $teams;
public function __construct(Uuid $uuid,
LeagueGenericInfo $leagueGenericInfo)
{
$this->id = $uuid;
$this->genericInfo = $leagueGenericInfo;
}
// ...}

<?php
class LeagueGenericInfo
{
private $name;
private $description;
private $country;
public function __construct($country, $description, $name)
{
$this->country = $country;
$this->description = $description;
}
// … getters and behaviours}

<?php
{
private $name;
private $country;
Value object
{
$this->description = $description;
}
// … getters and behaviours}

Validation: invariants and input

<?php
class League
{
// ...
{
if (!$this->canLeagueAcceptAnotherRegistration()) {
throw new DomainException('Not more places available');
}
}
private function canLeagueAcceptAnotherRegistration()
{
if ($this->teams->count() == 8) {
return false;
}
return true;
}
}

<?php
class League
{
// ...
{
League protects its invariants
}
}
private function canLeagueAcceptAnotherRegistration()
{
if ($this->teams->count() == 8) {
return false;
}
return true;
}
}

<?php
class League
{
// ...
public function getTeams()
{
return $this->teams;
}
}

<?php
class League
{
// ...
private function getTeams()
{
return $this->teams;
}
}

<?php
{
private $name;
private $country;
private static $countries;
{
if(!isset(static::$countries)) {
static::$countries = require __DIR__.'/countries.php';
}
if (!array_key_exists($name, static::$countries)) {
throw new UnknownCountryException($country);
}
// .. thanks to Mathias Verraes for “Money” ;-)
}}

<?php
{
private $name;
private $country;
Input validation
private static $countries;
{
}
}
}}

<?php
{
private $name;
private $country;
Could be private static also $countries;
placed in commands
{
}
}
}}

<?php
class League
{
public function render()
{
$properties = [
'id' => $this->id,
'name' => $this->genericInfo->getName(),
'description' => $this->genericInfo->getDescription(),
'country' => $this->genericInfo->getCountry(),
];
$teams = new ArrayCollection();
foreach ($this->teams as $team) {
$teams->add($team->render());
}
$properties['teams'] = $teams;
return new ArrayCollection($properties);
}
}

<?php
class League
{
public function render()
{
$properties = [
'id' => $this->id,
'name' => $this->genericInfo->getName(),
'description' => $this->genericInfo->getDescription(),
'country' => $this->genericInfo->getCountry(),
];
Return a read-only object
$teams = new ArrayCollection();
foreach ($this->teams as $team) {
$teams->add($team->render());
}
$properties['teams'] = $teams;
return new ArrayCollection($properties);
}
}

<?php
class Team
{
private $id;
private $players;
public function __construct(Uuid $uuid)
{
$this->id = $uuid;
$this->players = new ArrayCollection();
}
public function firePlayer($id)
{
foreach ($this->players as $key => $player) {
if ($player->getId() == $id) {
$this->players->remove($key);
}
}
}
}

<?php
class Team
{
private $id;
private $players;
Traverse the collections
public function __construct(Uuid $uuid)
{
$this->id = $uuid;
$this->players = new ArrayCollection();
}
public function firePlayer(Player $playerToFire)
{
foreach ($this->players as $key => $player) {
if ($player->getId() == $playerToFire->getId()) {
$this->players->remove($key);
}
}
}
}

The Player should have a
relation towards the Team?

<?php
class LeagueTest extends PHPUnit_Framework_TestCase
{
/**
* @test
* @expectedException
*/
public function leagueMustHaveMaximumEightTeams()
{
// …
$genericInfo = new LeagueGenericInfo('it', 'my league', 'awesome league');
$league = new League($uuid, $genericInfo);
$team = $this->getMockBuilder('Team') // …
for ($x=0; $x<=8; $x++) {
$league->registerTeam($team);
}
}
}

<?php
class LeagueTest extends PHPUnit_Framework_TestCase
{
/**
* @test
* @expectedException
*/
public function leagueMustHaveMaximumEightTeams()
{
// …
The same Team
can do more than one registration
to the League?!?
$genericInfo = new LeagueGenericInfo('it', 'my league', 'awesome league');
$league = new League($uuid, $genericInfo);
$team = $this->getMockBuilder('Team') // …
for ($x=0; $x<=8; $x++) {
$league->registerTeam($team);
}
}
}

<?php
class League
{
//..
{
$this->canLeagueAcceptRegistrationOf($team);
}
private function canLeagueAcceptRegistrationOf(Team $applicantTeam)
{
}
foreach ($this->teams as $key => $team) {
if ($team->getId() == $applicantTeam->getId()) {
throw new DomainException('Team already registered');
}
}
}
}

<?php
class League
{
//..
{
$this->canLeagueAcceptRegistrationOf($team);
}
And so on ...
private function canLeagueAcceptRegistrationOf(Team $applicantTeam)
{
}
foreach ($this->teams as $key => $team) {
if ($team->getId() == $applicantTeam->getId()) {
throw new DomainException('Team already registered');
}
}
}
}

We are using the entities of
the Persistence Model as
entities of our Domain
Awareness
Model

League.orm.yml
League:
type: entity
table: league
embedded:
id:
class: ValueObjectUuid
genericInfo:
class: ValueObjectLeagueGenericInfo
oneToMany:
contratti:
targetEntity: Team
mappedBy: league
fetch: EXTRA_LAZY

League.orm.yml
League:
type: entity
table: league
embedded:
id:
class: ValueObjectUuid
genericInfo:
class: ValueObjectLeagueGenericInfo
oneToMany:
contratti:
targetEntity: Team
mappedBy: league
fetch: EXTRA_LAZY
Uuid.orm.yml
Uuid:
type: embeddable
id:
uuid:
type: string
length: 36

<?php
class TeamRepository implements TeamRepositoryInterface
{
private $em;
public function __construct(EntityManager $em)
{
$this->em = $em;
}
}

Persisting entities
<?php
{
public function add(Team $team)
{
$this->em->persist($team);
$this->em->flush();
}
}

Avoid collection hydration
(foreach, toArray)
<?php
{
public function getWithoutPlayers($id)
{
$qb = $this->em->createQueryBuilder();
$qb
->select('t', 'p')
->from("Team", 't')
->leftJoin('t.players', 'p', Join::WITH, $qb->expr()->andX(
$qb->expr()->eq('p.id.uuid', ':pid')
))
->where('c.id.uuid = :id')
->setMaxResults(1);
$qb->setParameter('id', $id);
$qb->setParameter('pid', null);
return $qb->getQuery()->getOneOrNullResult();
}
}

Retrieve an object joined with empty collection
<?php
{
public function getWithPlayers($id)
{
$qb
->select('t', 'p')
->from("Team", 't')
->leftJoin(t.players', 'p', Join::WITH, $qb->expr()->andX(
$qb->expr()->eq('p.status', ':status')
))
->where('t.id.uuid = :id');
$qb->setParameter('status', 'on_the_market');
$qb->setParameter('id', $id);
return $qb->getQuery()->getOneOrNullResult();
}
}

Get paginated list of Teams with Player joined
<?php
use DoctrineORMToolsPaginationPaginator;
{
public function paginate($first, $max)
{
$qb
->select('t', 'p')
->from("Team", 't')
->leftJoin('t.players', 'p')
->setFirstResult($first)
->setMaxResults($max);
$paginator = new Paginator($qb->getQuery());
return $paginator->getIterator();
}
}

<?php
class FirePlayerCommand implements Command
{
public $teamId;
public $playerId;
public function getRequest()
{
return new Request(
[
'teamId' => $this->teamId,
'playerId' => $this->playerId
]
);
}
}

<?php
class Request extends ArrayCollection implements RequestInterface
{
public function __construct(array $values)
{
parent::__construct($values);
}
public function get($key, $default = null)
{
if (!parent::containsKey($key)) {
throw new DomainException();
}
$value = parent::get($key);
if (!$value && $default) {
return $default;
}
return $value;
}
}

<?php
class CommandHandler
{
private $dispatcher;
private $useCases;
public function __construct(EventDispatcherInterface $dispatcher)
{
$this->dispatcher = $dispatcher;
}
public function registerUseCases($useCases)
{
foreach ($useCases as $useCase) {
if ($useCase instanceof UseCase) {
$this->useCases[$useCase->getManagedCommand()] = $useCase;
} else {
throw new LogicException('');
}
}
}
// ...}

<?php
class CommandHandler
{
// ...
public function execute(Command $command)
{
try {
$this->dispatcher
->dispatch(Events::PRE_COMMAND, new CommandEvent($command));
$this->useCases[get_class($command)]->run($command);
$response = new Response();
$this->dispatcher
->dispatch(Events::POST_COMMAND, new PostCommandEvent($command, $response));
return $response;
} catch (DomainException $e) {
$this->dispatcher
->dispatch(Events::EXCEPTION, new ExceptionEvent($command, $e));
return new Response($e->getMessage(), Response::STATUS_KO);
}
}
}

<?php
class FirePlayerUseCase implements UseCase
{
private $repository;
public function __construct(TeamRepositoryInterface $repository)
{
$this->repository = $repository;
}
public function run(Command $command)
{
$request = $command->getRequest();
$team = $this->repository->get(
$request->get('teamId')
);
$team->firePlayer(
$request->get('playerId')
);
$this->repository->add($team);
}
}

Commands and Use Cases could be used standalone

<?php
class CommandHandlerCompilerPass implements CompilerPassInterface
{
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition('command_handler')) {
return;
}
$definition = $container->getDefinition('command_handler');
$taggedServices = $container->findTaggedServiceIds('use_case');
$useCases = array();
foreach ($taggedServices as $id => $attributes) {
$useCases[] = new Reference($id);
}
$definition->addMethodCall(
'registerUseCases',
array($useCases)
);
}
}

<?php
class MyController extends Controller
{
public function modifyLeagueAction(Request $request, $id)
{
$reader = $this->get('reader');
$league = $reader->getLeague($id);
$command = ModifyLeagueCommand::fromArray($league);
$form = $this->createForm(new ModifyLeagueType(), $command);
$form->handleRequest($request);
if ($form->isValid()) {
$commandHandler = $this->get('command_handler');
$response = $commandHandler->execute($command);
if ($response->isOk()) {
//...
}
}
return array(
'form' => $form->createView()
);
}
}

<?php
class MyController extends Controller
{
public function modifyLeagueAction(Request $request, $id)
{
$reader = $this->get('reader');
Consider using a service for
$league = $reader->getLeague($id);
reading $command = ModifyLeagueCommand::operations, fromArray($league);
instead
$form = $this->createForm(new ModifyLeagueType(), $command);
use $form->the handleRequest($repository request);
directly
if ($form->isValid()) {
$commandHandler = $this->get('command_handler');
$response = $commandHandler->execute($command);
if ($response->isOk()) {
//...
}
}
return array(
'form' => $form->createView()
);
}
}

<?php
class ModifyLeagueType extends CreateNewsType
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder
->add('leagueId’, ‘’hidden')
->add('name')
->add('save', 'submit')
;
}
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(array(
'data_class' => ModifyLeagueCommand::CLASS,
));
}
}

<?php
class ModifyLeagueCommand implements Command
{
public $leagueId;
public $name;
public function getRequest()
{
return new Request(
[
leagueId => $this->leagueId,
name => $this->name
]
);
}
}

Command validation
ModifyLeagueCommand:
properties:
leagueId:
- NotBlank: ~
name:
- NotBlank: ~

Using CQRS and Event Sourcing things change deeply

Rich domain model with symfony 2.5 and doctrine 2.5

https://joind.in/talk/view/12214

Credits
A special thanks to @_orso_ the first who told me about rich models
- Eric Evans - "Domain Driven Design"
- Vaughn Vernon - “Implementing Domain-Driven Design”
- http://www.slideshare.net/ziobrando/gestire-la-complessit-con-domain-driven-design
- http://verraes.net/2013/12/related-entities-vs-child-entities/
- http://www.whitewashing.de/2012/08/22/building_an_object_model__no_setters_allowed.html
- http://www.infoq.com/articles/ddd-contextmapping
- http://nicolopignatelli.me/valueobjects-a-php-immutable-class-library/
- http://welcometothebundle.com/domain-driven-design-and-symfony-for-simple-app/
- http://www.slideshare.net/perprogramming/application-layer-33335917
- http://lostechies.com/jimmybogard/2008/08/21/services-in-domain-driven-design/
- http://www.slideshare.net/thinkddd/practical-domain-driven-design-cqrs-and-messaging-architectures
- http://lostechies.com/jimmybogard/2009/02/15/validation-in-a-ddd-world/
- http://gojko.net/2009/09/30/ddd-and-relational-databases-the-value-object-dilemma/

Credits
- http://verraes.net/2013/06/unbreakable-domain-models/
- http://www.mehdi-khalili.com/orm-anti-patterns-part-4-persistence-domain-model
- http://martinfowler.com/bliki/BoundedContext.html
- http://www.substanceofcode.com/2007/01/17/from-anemic-to-rich-domain-model/
- http://gorodinski.com/blog/2012/04/25/read-models-as-a-tactical-pattern-in-domain-driven-design-ddd/
- http://www.sapiensworks.com/blog/post/2013/05/01/DDD-Persisting-Aggregate-Roots-In-A-Unit-Of-Work.aspx
- http://simon-says-architecture.com/2011/09/06/ddd-by-the-book/
- http://scaledagileframework.com/domain-modeling/
- http://www.codeproject.com/Articles/555855/Introduction-to-CQRS

Rich domain model with symfony 2.5 and doctrine 2.5

More Related Content

Rich domain model with symfony 2.5 and doctrine 2.5

Editor's Notes