Rich Model And Layered Architecture in SF2 Application

RichModel
And Layered Architecture
Kirill chEbba Chebunin
(Creara.ru)
iam@chebba.org

Rich Model. ???

http://www.vexinthecity.com/2010/10/estee-lauder-christmas-collection-pure.html

© Kirill chEbba Chebunin. Creara 2012

Rich Model. Who?


Martin Fowler
– Anemic Domain Model
– Domain Model
– Transaction Script

Eric Evans
– Domain-Driven Design

Benjamin Eberlei
– Building an Object Model: No setters allowed


Rich Model. What?


About business objects – Entities

Data + Logic instead of pure Data (Anemic Model)

Real encapsulation

Consistent state

Business methods instead of Setters

Low level validation


Rich Model. How?
class Project
{
const STATUS_NEW = 'new';
const STATUS_ACTIVE = 'active';
const STATUS_BLOCKED = 'blocked';

private $name;
private $status;

public function setName($name)
{
$this->name = $name;
}

public function getName()
{
return $this->name;
}

public function setStatus($status)
{
$this->status = $status;
}

public function getStatus()
{
return $this->status;
}
}


Rich Model. How?
class Project http://rober-raik.deviantart.com/art/Fuck-You-263589802
{

private $name;
private $status;

{
}

{
return $this->name;
}

{
$this->status = $status;
}

{
return $this->status;
}
}

FUCK YOU, SETTERS!


Rich Model. How?
class Project class Project
{ {
const STATUS_NEW = 'new'; const STATUS_NEW = 'new';
const STATUS_ACTIVE = 'active'; const STATUS_ACTIVE = 'active';
const STATUS_BLOCKED = 'blocked'; const STATUS_BLOCKED = 'blocked';

private $name; private $name;
private $status; private $status;

public function setName($name) public function __construct($name)
{ {
$this->name = $name; $this->name = trim($name);
} $this->status = self::STATUS_NEW;
}
{ public function getName()
return $this->name; {
} return $this->name;
}
{ public function getStatus()
$this->status = $status; {
} return $this->status;
}
{ public function activate()
return $this->status; {
} if ($this->status === self::STATUS_BLOCKED) {
} throw new LogicException(
'Can not activate blocked project');
}

$this->status = self::STATUS_ACTIVE;
}
}


rd
Rich Model. 3 Party?


rd
Rich Model. 3 Party?


Doctrine2
– Persistence Layer
– Same as Serialization

Symfony2 Form
– Data Binder
– Born to use Accessors
– Data Transformers?

Symfony2 Validation
– External Validation
– Heavyweight for Internal Validation


Rich Model. Doctrine Side Effects
$entity = $this->em->find($className, $id);
try {
$this->update($entity, $data);
// Failed, no update was executed
} catch (ValidationException $e) {
// Do stuff on fail
}

// .................................

$entity->link($anotherEntity);
$this->em->flush();
// Old invalid updates will be executed


Rich Model. Solution.


Isolated Persistence Layer

Transactional Operations

Rich + Anemic Objects (DTO)

Service Layer (Facade)


Rich Model. DTO.
class ProjectData
{
/**
* @AssertNotBlank
* @AssertRegex(pattern="/[a-z0-9_]+/i")
*/
private $name;

{

return $this;
}

{
return $this->name;
}
}


Rich Model. Domain Interface.
interface Project
{

/**
* Get project name
*
* @return string
*/
public function getName();

/**
* Get project status
*
* @return string STATUS_* constant
*/
public function getStatus();
}


Rich Model. Service Layer.
interface ProjectService
{
/**
* Create new project
*
* @param ProjectData $data
*
* @return Project
* @throws ValidationException
*/
public function createProject(ProjectData $data);
}


Rich Model. Example.
class ProjectManager implements ProjectService
{
/* ... */

public function createProject(ProjectData $data)
{
$this->validate($data);
$project = new EntityProject($data->getName());
$this->em->persist($project);
$this->em->flush();

return $project;
}
}


Rich Model. Example.
class ProjectController extends Controller
{
public function createAction(Request $request)
{
$data = new ProjectData();
$form = $this->createForm(new ProjectType(), $data);
$form->bind($request);
if ($form->isValid()) {
return
$this->projectService->createProject($data);
}
return $form;
}
}


Rich Model. Solution.

Client Code
Controller, Command, etc.

DTO

Domain
Interface

Service Interface

Persistence Layer


Rich Model. Profit?


rd
Rich Model. 3 Party Bundles.


Anemic Model

Managers

Direct ObjectManager Manipulation


Rich Model. FOSUser.


Rich Model. FOSUser. Problems.


User
– Property Setters
– Unnecessary Functions

Manager
– Low Level Methods


Rich Model. FOSUser. Solution.

Delegation instead of Inheritance

http://thevanwinkleproject.blogspot.com/2011_02_01_archive.html http://www.halloweencostumes.com/sweet-daddy-pimp-costume.html


Rich Model. FOSUser. Delegation.
class UserWrapper implements FOSUserInterface
{
private $user;
private $email;
private $enabled = false;

public function __construct(DomainUser $user = null)
{
if ($user) {
$this->setUser($user);
}
}

public function setUser(DomainUser $user)
{
$this->user = $user;
$this
->setEmail($user->getEmail())
->setEnabled($user->getStatus() == DomainUser::STATUS_ACTIVE)
;
}

// Other UserInterface methods
}


Rich Model. FOSUser. Delegation.
class FOSUserManager implements FOSUserManagerInterface
{
public function updateUser(UserInterface $wrapper)
{
$user = $wrapper->getUser();
$userService = $this->userService;

// User registration
if (!$user) {
$user = $userService->registerUser($wrapper->getRegistrationData());
// Update simple fields
} else {
$user = $userService->updateUser($id, $wrapper->getUserData());
}

$wrapper->setUser($user);
}

// Other UserManagerInterface methods
}


Rich Model. SonataAdmin.

http://southpark.wikia.com/wiki/File:ScauseForApplause00031.png


Rich Model. Admin Architecture.


SonataAdminBundle
– Base CRUD View Functions
– Dashboard, Menu, etc.
– Interfaces for Storage Implementations

ORM/ODM/... Bundles
– Storage Implementations registered in Admin
– Direct Object Manager Manipulation


Rich Model. Admin Interfaces.

We have interfaces! Implement them!
class CustomModelManager implements ModelManagerInterface
{
/* ... */

/**
* {@inheritDoc}
*/
public function modelTransform($class, $instance)
{
// Method is not used in Admin
}

/**
* {@inheritDoc}
*/
public function getParentFieldDescription($parentAssociationMapping, $class)
{
// Method is not used in Admin
}
}


Rich Model. Admin Interfaces.


Rich Model. Admin.Custom Model.
interface Model
{
/**
* Create mew object instance
*
* @return mixed
*/
public function createInstance();

/**
* Save new object
*
* @param object $object
*
* @throws RuntimeException
*/
public function create($object);

/**
* Update existing object
*
* @param $object
* @throws RuntimeException
*/
public function update($object);

// Some other methods
}


Rich Model. Admin.Custom Model.
class UserModel implements Model
{

public function createInstance()
{
return new UserWrapper();
}

public function create($wrapper)
{
$user = $this->userService->registerUser(
$wrapper->getRegistrationData()
);
}

public function update($wrapper)
{
$user = $this->userService->updateUser(
$wrapper->getUserData()
);
}

// Some other methods
}


Rich Model. PROFIT!


Rich Model. Summary.


Object Logic in Object Class

Separate Domain Objects from View Object

Isolated Business Layer (Service Layer)

Delegation instead of Inheritance

Read 3rd Party Code


Rich Model. Pros & Cons.


OOPed (KISS, DRY, Patterns, blah, blah, blah)

Pros:
– Less side effects
– Less code duplication
– Less chances to shoot your leg
– Easy serialization
– Easy API creation
– Etc, etc, etc.

Cons:
– More code
– Codebase required
– Hi shit sort out level


Rich Model. Questions?


Rich Model And Layered Architecture in SF2 Application

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Rich Model And Layered Architecture in SF2 Application

Similar to Rich Model And Layered Architecture in SF2 Application (20)

Recently uploaded

Recently uploaded (20)

Rich Model And Layered Architecture in SF2 Application