Models and Service Layers, Hemoglobin and Hobgoblins

Surgeon General's Warning
This talk is clocked at 1 slide per 12.8 seconds and features unsafe
amounts of code. Presenter is a registered Class 3 Fast Talker (equal
to 1 Gilmore Girls episode).
Viewing is not recommended for those hungover, expected to become
hungover or consuming excessive amounts of caffeine. Do not watch
and operate motor vehicles.
If you accidentally consume this talk, flush brain with kitten pictures
and seek emergency help in another talk. No hard feelings, seriously.
It's almost the end of the conference, after all. Why are we even here?
Notice in accordance with the PHP Disarmament Compact of 1992. Void where prohibited.

Models & Service Layers
Hemoglobin & Hobgoblins
ZendCon 2014
Ross Tuck

Freerange Codemonkey
Know-It-All
Hot-Air Balloon

Model
class TodoList {
function setName($name);
function getName();
function setStatus($status);
function getStatus();
function addTask($task);
function setTasks($tasks);
function getTasks();
}

array(
'name' => '',
'status' => '',
'tasks' => ''
);
Model

“In essence the problem with anemic domain
models is that they incur all of the costs of a
domain model, without yielding any of the
benefits.”
-Martin Fowler

Our industry standard i s a n a n t i p a t t ern.

Integration over implementation

Model
class Task {
function setDescription($desc);
function getDescription();
function setPriority($priority);
function getPriority();
}

An ORM that's not Doctrine 2.
A framework that's not Symfony2.
I promise.

Controller
function addTaskAction($req) {
$task = new Task();
$task->setDescription($req->get('desc'));
$task->setPriority($req->get('priority'));
$list = $this->todoRepo->findById($req->get('id'));
if (!$list) { throw new NotFoundException(); }
$task->setTodoList($list);
$this->repository->save($task);
$this->auditLog->logNewTask($task);
$this->mailer->sendMessage('New thingy!');
return $this->redirect('edit_page');
}

Anemic Model
Hard to Maintain
Testability
SRP wha?

In Defense Of CRUD.
No, seriously.

Easy to follow.
If you can keep it
in your head.

Sometimes it really is just data entry.
(but it usually isn't)
(but sometimes it is)

Not entirely a technical issue.

• Service Layer
• Service Container
• Web Service
• Service Oriented Architecture
• Domain Service
• Stateless Service
• Software-as-a-service
• Platform-as-a-service
• Whatever-as-a-service meme
• Delivery Service
• Laundry Service

Model
Service Layer
Controller
View

1) Multiple User Interfaces
Web + REST API
+ CLI
+ Workers

Service
class TodoService {
function addTask(TodoList $list, $desc, $priority) {
$task = new Task();
$task->setDescription($desc);
$task->setPriority($priority);
}
}

Service
class TodoService {
function findById($id) {
return $this->repository->findById($id);
}
}

Controller
$list = $this->todoService->findById($req->get('id'));
$this->todoService->addTask(
$list, $req->get('desc'), $req->get('priority')
);
}

Controller
);
CLI
function addTaskCommand($id, $desc, $priority) {
$list = $this->todoService->findById($id);
$this->todoService->addTask($list, $desc, $priority);

Controller
);
CLI

Service
class TodoService {
$todo = $this->repository->findById($id);
if (!$todo) {
throw new TodoNotFoundException();
}
return $todo;
}
}
not http exception

Controller
);
CLI

Controller
);
CLI
function addTaskCommand($name, $desc, $priority) {
$list = $this->todoService->findByName($name);

Controller
);
CLI
function addTaskCommand($name, $desc, $priority) {
$listId = $this->todoService->findIdByName($name);
$this->todoService->addTask($listId, $desc, $priority);

Service
class TodoService {
public function findLatestLists() {
return $this->repository->findLatestLists();
}
}

Service
class TodoService {
if ($this->cache->has('latest:lists')) {
return $this->cache->get('latest:lists');
}
$results = $this->repository->findLatestLists();
$this->cache->set('latest:lists', $results);
return $results;
}
}

Service
class TodoService {
function findById($id);
function addTask($todo, $desc, $priority);
function prance();
}

Model
class TodoList {
function getName();
}

Model
class TodoList {
function getName();
}
Where's mah logic?

Service
class TodoListService {
$task = new Task();
}
}

“Organizes business logic by procedures
where each procedure handles a single
request from the presentation.”
-Fowler

More flexible
Than CRUD,
at least

What does belong in a service layer?

Transactions
Security
Notifications
Bulk operations

Fat Model, Skinny Service Layer

addTask()
findById()
findLatestLists()
Service
write
read
read

Remodeling our Reading
by
Refactoring our Repository
Redux

Service
class TodoService {
$todo = $this->repository->findById($id);
if (!$todo) {
}
return $todo;
}
}

Repository
interface TodoRepository {
public function findById($id);
public function findLatestLists();
}

Repository
class TodoDbRepository implements TodoRepository {
public function findById($id) {
$todo = $this->db->select(...);
if (!$todo) {
}
return $todo;
}
}

Repository
$todo = $this->db->select(...);
if (!$todo) {
}
return $todo;
}
}
raw db connection

Repository
$todo = $this->repository->find($id);
if (!$todo) {
}
return $todo;
}
}
FIXED

Repository
interface EntityRepository {
public function createQueryBuilder($alias);
public function createResultSetMappingBuilder($alias);
public function createNamedQuery($queryName);
public function createNativeNamedQuery($queryName);
public function clear();
public function find($id, $lockMode, $lockVersion);
public function findAll();
public function findBy($criteria, $orderBy, $limit, $offset);
public function findOneBy($criteria, $orderBy);
public function __call($method, $arguments);
public function getClassName();
public function matching(Criteria $criteria);
}

Repository
}
$results = $this->repository->query(...);
return $results;
}
}

Repository Decorator Decorator object
class CachingTodoRepository implements TodoRepository {
}
$results = $this->innerRepository->findLatestLists();
return $results;
}
}
TodoDbRepository

DI Layer
new TodoService(
new CachingTodoRepository(
new TodoDbRepository(
$entityManager->getRepository('TodoList')
)
)
)

Mo' classes
Mo' decoupling and reduced overall design issues

Controller
$this->todoService->matching(array(
new ListIsClosedCriteria(),
new HighPriorityCriteria()
));

Interlude: Services here...
...services there...
...services everywhere!

TaskService
Task
TodoListService
TodoList
TagService
Tag
TaskRepository TodoListRepository TagRepository

Task
TodoService
TodoList
Tag

Task
UserService
TodoService
TodoList
Tag
User

Task
TodoService
TodoList
Tag
UserService
User

Service
public function findByUser(User $user) {
return $this->repository->findByUser($user);
}
}

Service
public function findByUser(UserId $userId) {
return $this->repository->findByUser($userId);
}
}

Task
TodoService
TodoList
Tag
Interfaces!
UserService
User

Services aren't only for entities

Model
class TodoList {
function addTask(Task $task) {
$this->tasks[] = $task;
}
}

Model
class TodoList {
function addTask($desc, $priority) {
$task = new Task();
}
}

Model
class TodoList {
$task = new Task($desc, $priority);
}
}

Model
class TodoList {
$task = new Task($desc, $priority, $this);
}
}
ORM allowance

Service
$list->addTask($desc, $priority);
$this->repository->save($list);
}
}

Model
class TodoList {
$task = new Task($desc, $priority);
if (count($this->tasks) > 10) {
$this->status = static::UNREALISTIC;
}
}
}

$this->auditLog->logTooAmbitious($task);
$this->mailer->sendMessage('Too unrealistic');
}
Service

Model
$this->raise(
new TaskAddedEvent($this->id, $desc, $priority)
);
}
}

Event
class TaskAddedEvent {
protected $description;
protected $priority;
function __construct($desc, $priority) {
$this->description = $desc;
$this->priority = $priority;
}
}

Model
class TodoList {
protected $pendingEvents = array();
protected function raise($event) {
$this->pendingEvents[] = $event;
}
public function releaseEvents() {
$events = $this->pendingEvents;
$this->pendingEvents = array();
return $events;
}
}
Excellent Trait

Service
}
}

Service
$events = $list->releaseEvents();
$this->eventDispatcher->dispatch($events);
}
}

Event Listeners
class EmailListener {
function onTaskAdded($event) {
$taskDesc = $event->getDescription();
$this->mailer->sendMessage('New thingy: '.$taskDesc);
}
function onUserRegistered($event) {
$this->mailer->sendMessage('welcome sucka!');
}
}

Model
$this->raise(
);
$this->raise(new WasTooAmbitiousEvent($this->id));
}
}

Model
$this->raise(
);
$this->raise(new WasTooAmbitiousEvent($this->id));
}
}
Logic is here!

Service
protected $dependency1;
}
Big ball of mud
in the making

Event Listeners
class EmailListener {
function onTaskAdded($event) {
$taskName = $event->task->getName();
$this->mailer->sendMessage('New thingy: '.$taskName);
}
function onUserRegistered($event) {
$this->mailer->sendMessage('welcome sucka!');
}
}
Thin. Easy to test

TodoService
Serialize & Send,
Sucka!
PrintingService

Humans hate debugging events.
Dev Logging.
Debug commands.

Consuming Application Services

Controller
);
}

Controller
$list->addTask($req->get('desc'), $req->get('priority'));
}

Controller
$list->rename('blah');
}

Controller
$list->rename('blah');
$this->todoService->addTask(...);
}

Service
class TodoService {
$todoList = $this->repository->findById($id);
return $todoList;
}
}

Service
class TodoService {
$todoList = $this->repository->findById($id);
return new TodoDTO($todoList);
}
}

TodoDTO
class TodoDTO {
public function getName();
public function getStatus();
public function getMostRecentTask();
}

Service
class TodoService {
function generateReport() {
$data = $this->repository->performSomeCrazyQuery();
return new AnnualGoalReport($data);
}
}

Reverse it: DTOs not for output...

Command
class AddTaskCommand {
public $description;
public $priority;
public $todoListId;
}

Controller
$command = new AddTaskCommand();
$command->description = $req->get('description');
$command->priority = $req->get('priority');
$command->todoListId = $req->get('todo_id');
$this->todoService->execute($command);
}
}

Handler Foo
Controller Service Handler Bar
Handler Baz

Controller Service
Handler Baz

Service
}

Service
function execute($command) {
}
}

Service
get_class($command);
}
}

Service
$command->getName();
}
}

Service
$command->execute();
}
}

Handler
class TodoListHandler {
function handleAddTask($cmd) {
$list = $this->repository->findById($cmd->todoListId);
$list->addTask($cmd->description, $cmd->priority);
}
function handleCompleteTask($command)
function handleRemoveTask($command)
}

Service
class CommandBus {
}
}

Service
class MyCommandBus implements CommandBus {
}
}

Service
class ValidatingCommandBus implements CommandBus {
if (!$this->validator->isValid($command)) {
throw new InvalidCommandException();
}
$this->innerCommandBus->execute($command);
}
}

Command
use SymfonyComponentValidatorConstraints as Assert;
class AddTaskCommand {
/** @AssertLength(max="50") */
public $description;
public $priority;
public $todoListId;
}

Logging
Transactions
Event Dispatching

Fewer Dependencies per class.
Simple layers.
Easy to test.

Model
Service Layer
Commands ViewModels
Controller
View

forms
templates
validators
CRUD for the framework.
Domain Model for the chewy center.
tough logic
semantics
testing

On the surface, it looks the same.

Controller
$command = new AddTaskCommand();
$command->description = $req->get('description');
$command->priority = $req->get('priority');
$command->todoListId = $req->get('todo_id');
$this->commandBus->execute($command);
}
}

Commands = Change Data
Queries = Read Data

Model
class TodoList {
function rename($name);
function addTask($desc, $priority);
function getName();
}

Write Model
class TodoListModel {
}
Read Model
class TodoListView {
function getName();
}

Model
class TodoList {
function getName();
function getParticipatingUsers();
}

Write Model
}
Read Model
function getName();
}

Write Model
}
Read Model
function getName();
}
ORM entity
1 Model
SQL query
N Models

Read and Write are two different systems.

Handler
}
}

Handler
Service
public function findByUser(User $user) {
return $this->repository->findByUser($user);
}
}
}
}

$todoList = new TodoList();
$this->repository->save($todoList);
$todoList->getId();
Controller

$command = new CreateTodoCommand(UUID::create());
$commandBus->execute($command);
$command->uuid;
Controller

github.com/beberlei/litecqrs-php/
github.com/qandidate-labs/broadway
github.com/gregoryyoung/m-r

Big mental leap.
Usually more LOC.
Not for every domain.
Can be mixed.

Easy to Scale.
Bears Complexity.
Async Operations.
Event Sourcing.

Instead of storing the current state in the db...

Snapshots
Debugging
Audit Log
Business Intelligence
Online/Offline users
Retroactively Fix Bugs

Google it.
Or ask me afterwards.

"A foolish consistency is the hobgoblin of
little minds."
- Ralph Waldo Emerson

Strong techniques, weakly held.

Further Reading
• codebetter.com/gregyoung
• martinfowler.com/tags/domain driven design.html
• shawnmc.cool/domain-driven-design
• whitewashing.de
• verraes.net

Thanks To:
• Warnar Boekkooi @boekkooi
• Daan van Renterghem @DRvanR
• Matthijs van den Bos @matthijsvandenb

Image Credits
• http://www.flickr.com/photos/calgaryreviews/6427412605/sizes/l/
• http://msnbcmedia.msn.com/j/MSNBC/Components/Slideshows/_production/twisp_090511_
/twisp_090511_02.ss_full.jpg
• http://shotthroughawindow.wordpress.com/2011/07/22/hp7b/
• http://www.sxc.hu/photo/605471
• http://martinfowler.com/bliki/images/cqrs/cqrs.png
• http://www.flickr.com/photos/83346641@N00/5578975430/in/photolist-9uZH2y-8rTZL1-di
xjR-ffBPiv-8SbK8K-ffS4md-6UeEGP
• http://www.flickr.com/photos/lac-bac/7195938394/sizes/o/
• http://tdzdaily.org/wp-content/uploads/2013/03/Dumb-and-Dumber.png
• http://upload.wikimedia.org/wikipedia/commons/1/17/Charlton_Heston_in_The_Ten_Comm
andments_film_trailer.jpg
• http://commons.wikimedia.org/wiki/File:Trench_construction_diagram_1914.png
• http://www.flickr.com/photos/jeffreyww/4747314852/sizes/l/
• http://www.flickr.com/photos/jdhancock/3540861791/sizes/l/
• http://www.flickr.com/photos/superfantastic/50088733/sizes/l

joind.in/12101
Ross Tuck rosstuck.com
@rosstuck

Models and Service Layers, Hemoglobin and Hobgoblins

More Related Content

Viewers also liked

Similar to Models and Service Layers, Hemoglobin and Hobgoblins

Recently uploaded

Models and Service Layers, Hemoglobin and Hobgoblins