Command Bus To Awesome Town

Command Bus To
DPC 2015
Awesome Town
Ross Tuck

$store->purchaseGame($gameId, $customerId);

Domain Model
Service
Controller
View

class BUYBUYBUYController
{
public function buyAction(Request $request)
{
$form = $this->getForm();
$form->bindTo($request);
if ($form->isTotallyValid()) {
return $this->redirect('thanks_for_money');
}
return ['so_many_errors' => $form->getAllTheErrors()];
}
}

class Store
{
public function purchaseGame($gameId, $customerId)
{
Assert::notNull($gameId);
Assert::notNull($customerId);
$this->security->allowsPurchase($customerId);
$this->logging->debug('purchasing game');
try {
$this->db->beginTransaction();
$purchase = new Purchase($gameId, $customerId);
$this->repository->add($purchase);
$this->db->commitTransaction();
} catch(Exception $e) {
$this->db->rollbackTransaction();
throw $e;
}
}
}

class Store
{
public function purchaseGame($gameId, $customerId)
{
$purchase = new Purchase($gameId, $customerId);
}
}

->purchaseGame($gameId, $customerId);
$store

purchaseGame($gameId, $customerId);
$store->

purchaseGame $gameId, $customerId ;
$store-> ( )

purchaseGame $gameId $customerId
$store-> ( , );

Data

Intent
Information

PurchaseGame $gameId $customerId

PurchaseGame($gameId, $customerId);

new PurchaseGame($gameId, $customerId);

->getGameId();
->getCustomerId();

People Paperwork→
Machines Messages→

Reserve Seat
Schedule Appointment

struct purchase_game {
int game_id;
int customer_id;
}

[
'game_id' => 42,
'customer_id' => 11
]

class PurchaseGame
{
public $gameId;
public $customerId;
}

class PurchaseGame
{
private $gameId;
private $customerId;
public function __construct($gameId, $customerId)
{
$this->gameId = $gameId;
$this->customerId = $customerId;
}
public function getGameId()
{
return $this->gameId;
}
public function getCustomerId()
{
return $this->customerId;
}
}

class PurchaseController
{
public function purchaseGameAction(Request $request)
{
$form = $this->createForm('purchase_game');
$form->bind($request);
if ($form->isValid()) {
$command = $form->getData();
}
}
}

...but no ability to carry out.

class PurchaseGameHandler
{
public function handle(PurchaseGame $command)
{
Assert::notNull($command->getGameId());
Assert::notNull($command->getCustomerId());
$this->security->allowsPurchase($command->getCustomerId());
try {
$purchase = new Purchase(
$command->getGameId(),
$command->getCustomerId()
);
throw $e;
}
}
}

{
{
try {
);
throw $e;
}
}
}

$handler->handle(new PurchaseGame($gameId, $customerId));
“Extract To Message”

Command Message vs Command Pattern

$command = new PurchaseGame($gameId, $customerId);
$handler->handle($command);
Handler version

$command->execute();
Classical version

$command = new PurchaseGame($gameId, $customerId, $repository,
$db, $logger, $security);
$command->execute();
Classical version

●
Game ID
●
Customer ID
Purchase THIS game Purchase ANY game
●
Repository
●
Security
●
Logger
●
DB

class PurchaseController
{
public function purchaseGameAction()
{
// form stuff lol
$command = $form->getData();
$this->handler->handle($command);
}
}
Controller
Must be
the RIGHT handler

Handler
Command Bus
Command
♥♥
♥
♥
♥

new CommandBus(
[
PurchaseGame::class => $purchaseGameHandler,
RegisterUser::class => $registerUserHandler
]
);

$commandBus->handle($command);

●
Over the Network
●
In a queue
●
Execute in process

class CommandBus
{
private $handlers = [];
public function __construct($handlers) {
$this->handlers = $handlers;
}
public function handle($command)
{
$name = get_class($command);
if (!isset($this->handlers[$name])) {
throw new Exception("No handler for $name");
}
$this->handlers[$name]->handle($command);
}
}

class CommandBus
{
}
{
}
$this->handlers[$name]->execute($command);
}
}

class CommandBus
{
}
{
}
$this->handlers[$name]->__invoke($command);
}
}

class CommandBus
{
}
{
}
$methodName = 'handle'.$name;
$this->handlers[$name]->{$methodName}($command);
}
}

class CommandBus
{
private $container = [];
public function __construct($container) {
$this->container = $container;
}
{
$name = get_class($command)."Handler";
if (!$this->container->has($name)) {
}
$this->container->get($name)->handle($command);
}
}

Command Bus Uniform Interface→

Command Bus 3
Command Bus 2
Command Bus

Command Bus 1
Command Bus 3
Command Bus 2

Command Bus 3
Logging Command Bus
Command Bus

Transaction Command Bus
Logging Command Bus
Command Bus

interface CommandBus
{
public function handle($command);
}

class MyCommandBus
{
}
{
}
}
}

class MyCommandBus implements CommandBus
{
}
{
}
}
}

class LoggingDecorator implements CommandBus
{
private $logger;
private $innerBus;
public function __construct(Logger $logger, CommandBus $innerBus)
{
$this->logger = $logger;
$this->innerBus = $innerBus;
}
{
$this->logger->debug('Handling command '.get_class($command));
$this->innerBus->handle($command);
}
}

{
private $logger;
private $innerBus;
{
}
{
$this->logger->debug('Executed command '.get_class($command));
}
}

{
private $logger;
private $innerBus;
{
}
{
$this->logger->debug('Handling command '.get_class($command));
$this->logger->debug('Executed command '.get_class($command));
}
}

$commandBus = new LoggingDecorator(
$logger,
new MyCommandBus(...)
);
$commandBus->handle($command);

{
{
try {
);
throw $e;
}
}
}

class TransactionDecorator implements CommandBus
{
private $db;
private $innerBus;
public function __construct($db, $innerBus)
{
$this->db = $db;
}
{
try {
} catch (Exception $e) {
throw $e;
}
}
}

{
{
);
}
}

interface PurchaseCommand
{
public function getCustomerId();
}

class PurchaseGame
{
private $gameId;
// constructors, getters, etc
}

class PurchaseGame implements PurchaseCommand
{
private $gameId;
// constructors, getters, etc
}

class AllowedPurchaseDecorator implements CommandBus
{
private $security;
private $innerBus;
public function __construct($security, $innerBus)
{
$this->security = $security;
}
{
if ($command instanceof PurchaseCommand) {
$this->security->allowPurchase($command->getCustomerId());
}
}
}

{
{
);
}
}

{
{
);
}
}
Stop cutting!

new AllowedPurchaseDecorator(
$security,
new TransactionDecorator(
$db,
new LoggingDecorator(
$logger,
new MyCommandBus(
[
PurchaseGame::class => $purchaseGameHandler
]
)
)
)
)

interface Middleware {
public function handle($command, callable $next);
}

class LoggingMiddleware implements Middleware
{
private $logger;
public function __construct($logger)
{
}
public function handle($command, callable $next)
{
$this->logger->debug('handling '.get_class($command));
next($command);
}
}

new CommandBus(
[
new AllowedPurchaseMiddleware($security),
new TransactionMiddleware($db),
new LoggingMiddleware($logger),
new CommandHandlerMiddleware($handlerMapping),
]
);

Thing #1
Handling Commands in Commands

Domain Model
Service
Controller
View
PurchaseGameSendConfirmation

If it needs to happen with the command…
JUST CALL IT

If it needs to happen after the command…
Wait for a domain event

Thing #2
Reading From Commands
Or the lack thereof

“Command Bus should never return anything.”

$commandBus->handle(new PurchaseGame($gameId, $customerId));

$commandBus->handle(new PurchaseGame($gameId, $customerId));
$id = $this
->domainEvents
->waitFor(GamePurchased::class)
->getId();

Thing #3
Reading with a Command Bus

$handler->handle(new PurchaseGame($gameId, $customerId));
$this->repository->findPurchaseById($id);
$this->readService->findPurchaseVerification($id);
$this->queryBus->find(new PurchaseById($id));

Thing #4
Command Buses Work Great in JS

commandBus.handle({
"command": "purchase_game",
"game_id": gameId,
"customer_id": customerId
});

Thing #5
Single Endpoint “REST”

function createBus($handlers) {
return function ($command) use ($handlers) {
$handlers[get_class($command)]($command);
};
}

$bus = createBus(
[
FooCommand::class => $someClosure,
BarCommand::class => $someOtherClosure
]
);
$cmd = new FooCommand();
$bus($cmd);

But you should use my library.

Command Bus Libraries are useless

Me
tactician-doctrine
tactician-logger
named commands
locking

@sagikazarmark
tactician-bernard
tactician-command-events

@rdohms
@xtrasmal
@Richard_Tuin
tactician-bundle

@GeeH
@mike_kowalsky
tactician-module

Prasetyo Wicaksono
Eugene Terentev
Jildert Miedema
Nigel Greenway
Frank de Jonge
Ivan Habunek
tactician-service-provider
yii2-tactician
laravel-tactician
tactician-container
tactician-awesome-advice
tactician-pimple

● Simplify Interfaces
● Metadata
● Tracking
● RAD

Command
Handler
Bus
Decorators
executes
connects extends

Images
● http://bj-o23.deviantart.com/art/NOT-Rocket-Science-324795055
● sambabulli.blogsport.de
● https://www.youtube.com/watch?v=XHa6LIUJTPw
● http://khongthe.com/wallpapers/animals/puppy-bow-227081.jpg
● https://www.flickr.com/photos/emptyhighway/7173454/sizes/l
● https://www.flickr.com/photos/jronaldlee/5566380424

domcode.org
Ross Tuck
@rosstuck
joind.in/14219
PHPArchitectureTour.com

Command Bus To Awesome Town

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Command Bus To Awesome Town

Similar to Command Bus To Awesome Town (20)

Recently uploaded

Recently uploaded (20)

Command Bus To Awesome Town