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

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Rich Model And Layered Architecture in SF2 Application

Similaire à Rich Model And Layered Architecture in SF2 Application (20)

Dernier

Dernier (20)

Rich Model And Layered Architecture in SF2 Application