Domain Driven
Design
Using Laravel
by
Waqar Alamgir

Managing
Complexity
AKA Engineering

Functional
Requirement

Lets Look at some Concepts
1. MVC Design Pattern
2. Entities
3. Active Records

MVC Design
Pattern

Entities
“Many objects are found
fundamentally by their
attributes but rather by a
thread of continuity and
identity” – Eric Evans

Person
Waqar Alamgir
Age 26
From Karachi
Waqar Alamgir
Age 26
From Karachi

Active Records

Person
Waqar Alamgir
Age 26
From Karachi
Waqar Alamgir
Age 26
From Karachi
ID NAME AGE LOCATION
1 Waqar Alamgir 26 Karachi
2 Waqar Alamgir 26 Karachi

Laravel Framewrok
Laravel is a free, open source PHP web application
framework, designed for the development of model–view–
controller (MVC) web applications. Laravel is listed as
the most popular PHP framework in 2013.
Eloquent ORM (object-relational mapping) is an advanced
PHP implementation of the active record pattern.
Better Routing.
Restful controllers provide an optional way for separating
the logic behind serving HTTP GET and POST requests.
Class auto loading.
Migrations provide a version control system for database
schemas.

That’s not DDD

Philosophy
In building large scale web applications MVC
seems like a good solution in the initial
design phase. However after having built a
few large apps that have multiple entry
points (web, cli, api etc) you start to find
that MVC breaks down. Start using Domain
Driven Design.

A Common Application
PRESENTATION LAYER
Controllers
Artisan Commands
Queue Listeners
SERVICE LAYER
Sending Email
Queuing up Jobs
Repository Implementations
COMMANDS / COMMAND BUS
DOMAIN
Entities
Repository Interface

What is Command
Meat of the application
Controller
Artisan Command
Queue Worker
Whatever

What is Command
Meat of the application
Commands
i.e. Register Member
Command

What is Command
Meat of the application
Commands
i.e. Register Member
Command

Advantages
1. No business policy in your controller
2. Your code shows intent
3. A single dedicated flow per user case
4. A single point of entry per user case
5. Easy to see which use cased are implemented

Register Command
class RegisterMemberCommand
{
public $displayName;
public $email;
public $password;
public function __construct($displayName , $email ,
$password)
{
$this->displayName = $displayName;
$this->email = $email;
$this->password = $password;
}
}

Register Command
class RegisterMemberCommand
{
public $displayName;
public $email;
public $password;
public function __construct($displayName , $email ,
$password)
{
$this->displayName = $displayName;
$this->email = $email;
$this->password = $password;
}
}

The Final Destination
Register Member
Handler
Register Member
Command
Meat of the application

The Final Destination
Register Member
Handler
Register Member
Command
Meat of the application
Command Bus

Implementing
Command Bus

class ExecutionCommandBus implements CommandBus
{
private $container;
private $mapper;
public function __construct(Container $container , Mapper
$mapper)
{
$this->container = $container;
$this->mapper = $mapper;
}
public function execute($command)
{
$this->getHandler($command)->handle($command);
}
public function getHandler($command)
{
$class = $this->mapper-
>getHandlerClassFor($command);
return $this->container->make($class);
}
}

How Does The
Mapper Know?

One Handle Per
Command

Let’s Look at
very basic
Register Member
Command
*with out any sequence*

class RegisterMemberHandler implements Handler
{
private $memberRepository;
public function __construct(MemberRepository
$memberRepository)
{
$this->memberRepository = $memberRepository;
}
public function handle($command)
{
$member = Member::register(
$command->displayName,
$command->email,
$command->password
);
$this->memberRepository->save($member);
}
}

class Member extends Eloquent
{
public static function register($displayName , $email ,
$password)
{
$member = new static([
‘display_name’ => $displayName,
‘email’ => $email,
‘password’ => $password
]);
return $member;
}
}

Flow Review

Flow Review
PRESENTATION
LAYER
Command
SERVICE
LAYER
COMMAND BUS Command Handler
DOMAIN
Entities
Repositories

Simple Sequence

Simple Sequence
Member Registers
Subscribe to Mail
Chimp
Send Welcome Email
Queue up 7 Day Email

Domain Events
Trigger
Listeners
Raise Event
Typical PUB-SUB pattern
Dispatch Event

A Common Application
PRESENTATION LAYER
Controllers
Artisan Commands
Queue Listeners
SERVICE LAYER
Sending Email
Queuing up Jobs
Repository Implementations
COMMANDS / COMMAND BUS
Event Dispatcher
DOMAIN
Entities
Repository Interface
Domain Events

Events/ Listener
Breakdown
Member Registers
Subscribe to Mail
Chimp
Send Welcome Email
Queue up 7 Day Email

class MemberRegistered
{
public $member;
public function __construct(Member $member)
{
$this->member = $member;
}
}
class SendWelcomeEmail implements Listener
{
public function handle($event)
{
Mailer ::Queue(…);
}
}

Throwing Domain
Events

class EventGenerator
{
protected $pendingEvents = [];
public function raise($event)
{
$this->pendingEvents = $event;
}
public function releaseEvents()
{
$events = $this->pendingEvents;
$this->pendingEvents = [] ;
return $events;
}
}

class Member extends Eloquent
{
use EventGenerator ;
public static function register($displayName , $email ,
$password)
{
$member = new static([
‘display_name’ => $displayName,
‘email’ => $email,
‘password’ => $password
]);
$member->raise(new MemberRegistered($member)) ;
return $member;
}
}

Interface Dispatcher
{
public function addListener($eventName , Listener
$listener) ;
public function dispatch($events) ;
}
// Register Listeners
$dispatcher = new Dispatcher() ;
$dispatcher-> addListener(‘MemberRegistered’ , new
SubscribeToMailchimp) ;
$dispatcher-> addListener(‘MemberRegistered’ , new
SendWelcomeEmail) ;
$dispatcher-> addListener(‘MemberRegistered’ , new
SendOneWeekEmail) ;

class RegisterMemberHandler implements Handler
{
private $memberRepository;
private $dispatcher;
public function __construct(MemberRepository
$memberRepository , Dispatcher $dispatcher)
{
$this->memberRepository = $memberRepository;
$this-> dispatcher = $dispatcher ;
}
public function handle($command)
{
$member = Member::register(
$command->displayName, $command->email,
$command->password
);
$this->memberRepository->save($member);
$this->dispatcher->dispatch($member->
releaseEvents()) ;
}
}

More Information
About DDD
Domain-Driven Design: Tackling
Complexity in the Heart of
Software - Eric Evans
Implementing Domain-Driven
Design- Vaughn Vernon

Thank You!
Have more questions?
Email: walamgir@folio3.com
Twitter: @wajrcs