Domain-Driven Design - Tactical Design Patterns

Domain-Driven Design
Tactical Design Patterns

View Slide

Christian Soronellas
Extreme Programmer
Technology Enthusiast
Web Developer

View Slide

View Slide

Agenda
Tactical Design Patterns I Tactical Design Patterns II
Value Objects
Entities
Domain Services
Repositories
Domain Events
Final Thoughts

View Slide

Value Objects

View Slide

First deﬁned by Ward Cunningham as
Whole Value

View Slide

Also deﬁned in Martin’s Fowler Patterns of
Enterprise Application Architecture

View Slide

“Beside using the handful of literal values offered by
the language, and an even smaller complement of
objects normally used as values, you will make and
use new objects that represent the meaningful
quantities of your business”

View Slide

“A small simple object, like money or a date range,
whose equality isn’t based on identity”

View Slide

class Currency { 
private $isoCode; 
 
public function __construct($isoCode) { 
$this->isoCode = $isoCode; 
} 
 
public function isoCode() { 
return $this->isoCode; 
} 
}

View Slide

class Money { 
private $amount; 
private $currency; 
 
public function __construct($amount, Currency $currency) { 
$this->amount = $amount; 
$this->currency = $currency; 
} 
 
public function amount() { 
return $this->amount; 
} 
 
public function currency() { 
return $this->currency; 
} 
}

View Slide

They mesure, quantify or describe things

View Slide

They are immutable

View Slide

class Money { 
// ... 
 
public function increaseBy(Money $aQuantity) { 
$this->assertMoneyHasSameCurrency($aQuantity); 
 
return new self( 
$this->amount + $aQuantity->amount, 
$this->currency 
); 
} 
}

View Slide

They promote side-effect free functions

View Slide

class Money { 
// ... 
 
 
return new self( 
$this->currency 
); 
} 
}

View Slide

They promote closure of operations

View Slide

class Money { 
// ... 
 
 
return new self( 
$this->currency 
); 
} 
}

View Slide

They form conceptual wholes

View Slide

class PostalCode { 
private $postalCode; 
 
public function __construct($aPostalCode) { 
$this->postalCode = $aPostalCode; 
} 
}

View Slide

class City { 
private $city; 
 
public function __construct($aCityName) { 
$this->city = $aCityName; 
} 
}

View Slide

class Address { 
private $street; 
private $city; 
 
public function __construct( 
$anStreet, 
PostalCode $aPostalCode, 
City $aCity 
) { 
$this->street = $anStreet; 
$this->postalCode = $aPostalCode; 
$this->city = $aCity; 
} 
}

View Slide

They generally boost good object-oriented design
by promoting proper encapsulation

View Slide

$amount1 = new Money(100, Currency::USD()); 
$amount2 = new Money(100, Currency::EUR()); 
 
false === assert( 
($amount1->currency()->isoCode() === $amount2->currency()->isoCode()) 
&& ($amount1->amount() === $amount2->amount()) 
);

View Slide

View Slide

class Currency { 
// ... 
 
public function equalsTo(self $anotherCurrency) { 
return $this->isoCode === $anotherCurrency->isoCode; 
} 
}

View Slide

class Money { 
// ... 
 
public function equalsTo(self $anotherMoney) { 
return $this->currency->equalsTo($anotherMoney->currency) 
&& $this->amount === $anotherMoney->amount; 
} 
}

View Slide

$amount1 = new Money(100, Currency::USD()); 
$amount2 = new Money(100, Currency::EUR()); 
 
false === assert($amount1->equalsTo($amount2));

View Slide

Use Embedded Value or Serialized LOB to persist Value
Objects

View Slide

Entities

View Slide

Some concepts in the ubiquitous language may
demand a thread of identity

View Slide

class Person { 
private $identificationNumber; 
private $name; 
 
public function __construct( 
$anIdentificationNumber, 
Name $aName 
) { 
$this->identificationNumber = $anIdentificationNumber; 
$this->name = $aName; 
} 
 
public function identificationNumber() 
{ 
return $this->identificationNumber; 
} 
 
public function name() 
{ 
return $this->name; 
} 
}

View Slide

class Order { 
private $id; 
private $amount; 
 
public function __construct($anId, Amount $amount) { 
$this->id = $anId; 
} 
 
public function id() { 
return $this->id; 
} 
 
} 
}

View Slide

Model the entity identity as a an object rather 
than a primitive type

View Slide

class OrderId { 
private $id; 
 
public function __construct($anId) { 
} 
 
} 
 
public function equalsTo(self $anOrderId) { 
return $anOrderId->id === $this->id; 
} 
}

View Slide

The identity operation

View Slide

Persistence mechanism provides identity

View Slide

CREATE TABLE òrders` ( 
ìd` INT(11) NOT NULL AUTO_INCREMENT, 
àmount` DECIMAL(10, 5) NOT NULL, 
PRIMARY KEY (ìd`) 
) ENGINE=InnoDB;

View Slide

$anOrder = new Order(/* ... */); 
assert(null === $anOrder->id());

View Slide

$entityManager->persist($anOrder); 
$entityManager->flush(); 
 
assert(null !== $anOrder->id());

View Slide

Client provides identity

View Slide

EAN13

View Slide

ISBN

View Slide

class ISBN { 
private $isbn; 
 
public function __construct($anIsbn) { 
$this->isbn = $anIsbn; 
} 
 
public function isbn() { 
return $this->isbn; 
} 
}

View Slide

class Book { 
private $isbn; 
private $title; 
 
public function __construct(ISBN $anIsbn, $aTitle) { 
$this->isbn = $anIsbn; 
$this->title = $aTitle; 
} 
}

View Slide

$book = new Book( 
ISBN::create('978-0-300-14424-6'), 
'Domain-Driven Design with PHP by Examples' 
);

View Slide

Application provides identity

View Slide

UUID 
(Universally unique identiﬁer)

View Slide

https://github.com/ramsey/uuid

View Slide

use Rhumsaa\Uuid\UUID; 
 
$order = new Order( 
OrderId::create(UUID::uuid4()), 
new Amount(100, Currency::EUR()) 
);

View Slide

Validating entities

View Slide

State should be protected using a  
design-by-contract approach.

View Slide

class EmailAddress { 
private $address; 
 
public function __construct($anAddress) { 
$this->setAddress($anAddress); 
} 
 
private function setAddress($anAddress) { 
$this->assertNotNull($anAddress); 
$this->assertLengthGreaterThan($anAddress, 0); 
$this->assertLengthLowerThan($anAddress, 100); 
$this->assertIsValidEmailAddress($anAddress); 
 
$this->address = $anAddress; 
} 
}

View Slide

// ... 
 
private function assertNotNull($anAddress) { 
if (null === $anAddress) { 
throw new InvalidArgumentException(); 
} 
} 
}

View Slide

// ... 
 
private function assertLengthGreaterThan($anAddress, $min) { 
if (strlen($anAddress) <= $min) { 
} 
} 
}

View Slide

// ... 
 
private function assertLengthLowerThan($anAddress, $max) { 
if (strlen($anAddress) >= $max) { 
} 
} 
}

View Slide

// ... 
 
private function assertIsValidEmailAddress($anAddress) { 
if (false === filter_var($anAddress, FILTER_VALIDATE_EMAIL)) { 
} 
} 
}

View Slide

Sometimes even having all properties valid, the object
could still be in an inconsistent state.

View Slide

class Location { 
private $country; 
private $city; 
 
public function __construct(Country $country, City $city, PostalCode $postalCode) { 
$this->setCountry($country); 
$this->setCity($city); 
$this->setPostalCode($postalCode); 
} 
 
public function country() { 
return $this->country; 
} 
 
public function city() { 
return $this->city; 
} 
 
public function postalCode() { 
return $this->postalCode; 
} 
 
// ... 
}

View Slide

abstract class Validator { 
private $validationHandler; 
 
public function __construct(ValidationHandler $validationHandler) { 
$this->validationHandler = $validationHandler; 
} 
 
protected function handleError($error) { 
$this->validationHandler->handleError($error); 
} 
 
abstract public function validate($aDomainObject); 
}

View Slide

class LocationValidator extends Validator { 
 
public function validate($aLocation) { 
$aCity = $aLocation->city(); 
$aPostalCode = $aLocation->postalCode(); 
 
if (!$this->location->getCountry()->hasCity($aCity)) { 
$this->handleError('City not found!'); 
} 
 
if (!$this->location->getCity()->isPostalCodeValid($aPostalCode)) { 
$this->handleError('Invalid postal code!'); 
} 
} 
 
}

View Slide

Persisting Entities

View Slide

Active Record vs Data Mapper

View Slide

Active Record example

View Slide

class Order extends Eloquent { 
protected $table = 'orders'; 
}

View Slide

// Find all orders 
$orders = Order::all(); 
 
// Find an specific Order 
$anOrder = Order::find(1); 
 
// Find all orders whose amount is greater than 100 EUR 
$orders = Order::where('amount', '>', 100)->take(10)->get(); 
 
// Create and save a new order 
$aNewOrder = Order::create(/* ... */); 
$aNewOrder->save();

View Slide

An Active Record is ﬁne mostly for CRUD applications 
or for simple domains

View Slide

Active Record couples the design of the database to the
design of the object-oriented system

View Slide

Advanced things like collections or inheritance are tricky to
implement

View Slide

Most of the implementations force the use, through
inheritance, of some sort of constructions
to impose their conventions.

View Slide

class Order extends Eloquent { 
 
protected $table = 'orders'; 
 
}

View Slide

Data Mapper example

View Slide

class Order { 
private $id; 
private $amount; 
 
public function __construct(OrderId $id, Amount $amount) { 
$this->id = $id; 
} 
 
} 
 
} 
}

View Slide

$orderMapper = new OrderMapper($databaseConnection); 
 
$order = new Order(/* ... */); 
 
$orderMapper->save($order);

View Slide

Data Mapper promotes real separation of concerns  
by decoupling persistence from 
domain concerns.

View Slide

Surrogate Identity

View Slide

abstract class IdentifiableDomainObject { 
private $id; 
 
protected function id() { 
} 
 
protected function setId($anId) { 
} 
}

View Slide

class Order extends IdentifiableDomainObject { 
private $orderId; 
 
public function orderId() { 
if (null === $this->orderId) { 
$this->orderId = new OrderId($this->id()); 
} 
 
return $this->orderId; 
} 
}

View Slide

Services

View Slide

Stateless operations that satisfy a domain task

View Slide

Usually they are all those operations that don’t
ﬁt naturally in an aggregate nor in
a value object.

View Slide

A user authenticates itself?

View Slide

A cart is promoted as an order by itself when the
purchase is made?

View Slide

class AuthenticationService { 
// ... 
 
public function authenticate($aUsername, $aPassword) { 
// ... 
} 
}

View Slide

class PurchaseService { 
// ... 
 
public function createOrderFrom(Cart $aCart) { 
// ... 
} 
}

View Slide

Anemic domain models 
vs. 
Rich domain models

View Slide

CREATE TABLE òrders` ( 
ÌD` INTEGER NOT NULL AUTO_INCREMENT, 
`CUSTOMER_ID` INTEGER NOT NULL, 
ÀMOUNT` DECIMAL(17, 2) NOT NULL DEFAULT '0.00', 
`STATUS` TINYINT NOT NULL DEFAULT 0, 
`CREATED_AT` DATETIME NOT NULL, 
ÙPDATED_AT` DATETIME NOT NULL, 
PRIMARY KEY (ÌD`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATION;

View Slide

class Order { 
// ... 
 
public function setId($id){$this->id = $id;} 
public function getId(){return $this->id;} 
 
public function setCustomerId($customerId){$this->customerId = $customerId;} 
public function getCustomerId(){return $this->customerId;} 
 
public function setAmount($amount){$this->amount = $amount;} 
public function getAmount(){return $this->amount;} 
 
public function setStatus($status){$this->status = $status;} 
public function getStatus(){return $this->status;} 
 
public function setCreatedAt($createdAt){$this->createdAt = $createdAt;} 
public function getCreatedAt(){return $this->createdAt;} 
 
public function setUpdatedAt($updatedAt){$this->updatedAt = $updatedAt;} 
public function getUpdatedAt(){return $this->updatedAt;} 
}

View Slide

// fetch an order from the database 
$anOrder = $orderRepository->find(1); 
 
// Update order status 
$anOrder->setStatus(Order::STATUS_ACCEPTED); 
 
// Update updatedAt field 
$anOrder->setUpdatedAt(new DateTimeImmutable()); 
 
// Save the order to the database 
$orderRepository->save($anOrder);

View Slide

class ChangeOrderStatusService { 
private $orderRepository; 
 
public function __construct(OrderRepository $orderRepository) { 
$this->orderRepository = $orderRepository; 
} 
 
public function execute($anOrderId, $anOrderStatus) { 
$anOrder = $this->orderRepository->find($anOrderId); 
 
$anOrder->setStatus($anOrderStatus); 
 
 
$this->orderRepository->save($anOrder); 
} 
}

View Slide

$changeOrderStatusService = new ChangeOrderStatusService( 
$orderRepository 
); 
 
$changeOrderStatusService->execute(1, Order::STATUS_ACCEPTED);

View Slide

An anemic domain model breaks encapsulation

View Slide

class ChangeOrderStatusService { 
 
public function __construct(OrderRepository $orderRepository) { 
$this->orderRepository = $orderRepository; 
} 
 
public function execute($anOrderId, $anOrderStatus) { 
$anOrder = $this->orderRepository->find($anOrderId); 
 
$anOrder->setStatus($anOrderStatus); 
 
 
$this->orderRepository->save($anOrder); 
} 
}

View Slide

An anemic domain brings a false sense of
code reuse

View Slide

class Order { 
// ... 
 
public function accept() 
{ 
$this->setStatus(self::STATUS_ACCEPTED); 
$this->setUpdatedAt(new DateTimeImmutable()); 
} 
}

View Slide

Repositories

View Slide

Mediates between the domain and data mapping layers
using a collection-like interface for
accessing domain objects

View Slide

For each type of object that needs global access, create
an object that can provide the illusion of an in-memory
collection of all objects of that type

View Slide

Repositories are mainly used to mediate with persistent
stores.

View Slide

Collection-Oriented Repositories

View Slide

Good approach if the persistence mechanism 
tracks object changes.

View Slide

OrderId::create(1), 
); 
 
$orderRepository->add($order); 
$order->changeAmount(new Amount(200, Currency::EUR()); 
 
assert($order == $orderRepository->orderOfId(OrderId::create(1)));

View Slide

interface OrderRepository { 
function orderOfId(OrderId $anOrderId); 
function ordersOfUser(UserId $aUserId); 
function add(Order $anOrder); 
function remove(Order $anOrder); 
}

View Slide

use Doctrine\ORM\EntityRepository; 
 
class DoctrineOrderRepository extends EntityRepository implements OrderRepository { 
function orderOfId(OrderId $anOrderId) { 
return $this->find($anOrderId->id()); 
} 
 
function ordersOfUser(UserId $aUserId) { 
$queryBuilder = $this->getEntityManager()->createQueryBuilder(); 
$query = $queryBuilder 
->select('o') 
->from('Order', 'o') 
->join('User', 'u') 
->where('u.id = ?1') 
->getQuery(); 
;
$query->setParameters([1 => $aUserId->id()]); 
 
return $query->getResult(); 
} 
 
function add(Order $anOrder) { 
$this->getEntityManager()->persist($anOrder); 
} 
 
function remove(Order $anOrder) { 
$this->getEntityManager()->remove($anOrder); 
} 
}

View Slide

Hides persistence details

View Slide

Persistence-Oriented Repositories

View Slide

Good approach if the persistence mechanism 
does not track object changes implicitly or explicitly.

View Slide

OrderId::create(1), 
); 
 
$orderRepository->save($order); 
 
// later on 
 
$order = $orderRepository->orderOfId(OrderId::create(1)); 
$order->changeAmount(new Amount(200, Currency::EUR()); 
 
$orderRepository->save($order);

View Slide

interface OrderRepository { 
function orderOfId(OrderId $anOrderId); 
function save(Order $anOrder); 
function remove(Order $anOrder); 
}

View Slide

class RedisOrderRepository implements OrderRepository { 
function orderOfId(OrderId $anOrderId) { 
return $this->unserialize( 
$this->redis->get( 
$this->computeKey($anOrderId) 
) 
); 
} 
 
function save(Order $anOrder) { 
$this->redis->set( 
$this->computeKey($anOrder->id()), 
$this->serialize($anOrder) 
); 
} 
 
function remove(Order $anOrder) { 
$this->redis->del( 
$this->computeKey($anOrder->id()) 
); 
} 
}

View Slide

Repositories vs. DAOs

View Slide

How do we use them?

View Slide

class OrderApplicationService { 
 
public function __construct(OrderRepository $anOrderRepository) { 
$this->orderRepository = $anOrderRepository; 
} 
 
public function payOrder($orderId, $amount) { 
// ... 
} 
}

View Slide

$orderApplicationService = new OrderApplicationService( 
new DoctrineOrderRepository($entityManager) 
); 
 
$orderApplicationService->payOrder(/* ... */);

View Slide

Domain Events

View Slide

Something happened that domain experts care about.

View Slide

When the user signs up, a conﬁrmation e-mail has
to be sent.

View Slide

class UserSignedUp { 
// ... 
 
public function username() { 
return $this->username; 
} 
 
public function password() { 
return $this->password; 
} 
 
public function birthday() { 
return $this->birthday; 
} 
}

View Slide

Notify the customer vía e-mail
when the order has been paid

View Slide

class OrderPaid { 
// ... 
 
public function orderId() { 
return $this->orderId; 
} 
 
} 
}

View Slide

They are relevant occurrences expressed in 
past tense

View Slide

class Order { 
// ... 
 
public function pay() { 
// ... 
} 
}

View Slide

The order was paid

View Slide

OrderPaid

View Slide

Domain Events should include whatever is necessary
to trigger the Event again.

View Slide

Domain Events are immutable.

View Slide

Use a lightweight Observer to publish them.

View Slide

class DomainEventPublisher { 
// ... 
 
private function __construct() { 
$this->subscribers = []; 
} 
 
public static function instance() { 
if (null === $this->instance) { 
$this->instance = new self(); 
} 
 
return $this->instance; 
} 
}

View Slide

// ... 
 
public function publish($aDomainEvent) { 
foreach ($this->subscribers as $aSubscriber) { 
if (get_class($aDomainEvent) === $aSubscriber->subscribedTo()) { 
$aSubscriber->handle($aDomainEvent); 
} 
} 
} 
}

View Slide

// ... 
 
public function subscribe(DomainEventSubscriber $aSubscriber) { 
$this->subscribers[] = $aSubscriber; 
} 
}

View Slide

class Order { 
// ... 
 
public function pay() { 
// ... 
 
DomainEventPublisher::instance()->publish( 
new OrderPaid( 
$this->id(), 
$this->amount() 
) 
); 
} 
}

View Slide

class InvoiceForOrderPaidSubscriber implements DomainEventSubscriber { 
private $notifier; 
private $repository; 
 
public function handle($anEvent) { 
$anOrder = $this->repository->find($anEvent->orderId()); 
 
$this->notifier->sendInvoiceFor($anOrder); 
} 
 
public function subscribedTo() { 
return OrderPaid::class; 
} 
}

View Slide

class OrderApplicationService { 
// ... 
 
public function payOrder($orderId) { 
DomainEventPublisher::instance()->subscribe( 
$this->invoiceForOrderPaidSubscriber 
); 
 
$anOrder = $this->repository->find($orderId); 
$anOrder->pay(); 
} 
}

View Slide

How we do notify our business intelligence context 
about the new order created?

View Slide

If we have a gamiﬁcation context to reward our customers 
for his purchases, how do we notify them?

View Slide

Domain Events are a domain-wide concept.

View Slide

Domain Events are an integration mechanism.

View Slide

Sum up

View Slide

Tactical design patterns are just a tool.

View Slide

Tactical design patterns enable us to express 
the model in an elegant object-oriented 
way.

View Slide

They are not mandatory to practice DDD.

View Slide

¡Thanks!
@theUniC

View Slide

Domain-Driven Design - Tactical Design Patterns

Domain-Driven Design - Tactical Design Patterns

Christian

More Decks by Christian

Other Decks in Technology

Featured

Transcript