Clean architecture with ddd layering in php

Clean Architecture using DDD layering in PHP

Leonardo Proietti@_leopro_

1. Clean Architecture

Definition of Clean Architecture

Independent of FrameworksTestable

Independent of UIIndependent of Database

Independent of any external agency

Hey bro, I respect your opinion but ...

It isn't just my opinion

Do you know "Uncle Bob", isn't it?

I’m just another dwarf.

The Clean Architecture

The Dependency Rule

“This rule says that code dependencies can only point inwards. Nothing in an inner circle

can know anything at all about something in an outer circle.”

(http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.html)

The Dependency Rule

“This rule says that code dependencies can only point inwards. Nothing in an inner circle

can know anything at all about something in an outer circle.”

(http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.html)

2. Domain Driven Design

What is Domain Driven Design?

“it is a way of thinking and a set of priorities, aimed at accelerating software projects that

have to deal with complicated domains”

(Eric Evans, "Domain Driven Design")

“is a collection of principles and patterns that help developers craft elegant object systems”

(http://msdn.microsoft.com/en-us/magazine/dd419654.aspx)

“is a collection of principles and patterns that help developers craft elegant object systems”

(http://msdn.microsoft.com/en-us/magazine/dd419654.aspx)

“is an approach to software development for complex needs by connecting the

implementation to an evolving model”

(http://en.wikipedia.org/wiki/Domain-driven_design)

“is an approach to software development for complex needs by connecting the

implementation to an evolving model”

Mmhh interesting … but what does it mean?

Make yourself comfortable

3. DDD Core

Domain

“Every software program relates to some activity or interest of its user. That subject area

to which the user applies the program is the domain of the software”

“A model is a simplification. It is an interpretation of reality that abstracts the

aspects relevant to solving problem at hand and ignores extraneous detail.”

“A model is a simplification. It is an interpretation of reality that abstracts the

aspects relevant to solving problem at hand and ignores extraneous detail.”

Sounds familiar?

“A domain model [...] is not just the knowledge in a domain expert’s head; it is a rigorously organized and selective abstraction of that

knowledge.”

“A domain model [...] is not just the knowledge in a domain expert’s head; it is a rigorously organized and selective abstraction of that

knowledge.”

Next it’s maybe the most important thing in DDD

Ubiquitous Language

“the domain model can provide the backbone for that common language [...]. The vocabulary of that UBIQUITOUS LANGUAGE includes the names of classes and prominent operations”

Ubiquitous Language

It’s a shared jargon between domain experts and developers, based on Domain Model

Take care of Ubiquitous Language

What does “coffee” mean?

Alberto Brandolini AKA ziobrando

Ubiquitous Language

“changes to the language will be recognized as changes in the domain model”

Context

“The setting in which a word or statement appears that determines its meaning.”

4. DDD Building Blocks

Entity

An object with “clear identity and a life-cycle with state transitions that we care about.”

(http://dddsample.sourceforge.net/characterization.html)

Are these entities?

It depends.

“We don't assign seats on our flights, so feel free to sit in any available seat”

Value Object

“An object that contains attributes but has no conceptual identity. They should be treated as

immutable.”

Value Object

“A small simple object, like money or a date range, whose equality isn't based on identity.”

(http://martinfowler.com/eaaCatalog/valueObject.html)

Are these value objects?

In most of the contexts, but ...

Beware about Anemic Domain Model

Both Entity and Value Object should have data and behaviours.

(http://www.martinfowler.com/bliki/AnemicDomainModel.html)

Few other concepts

RepositoryAggregate

Domain Event

Repository

“A REPOSITORY represents all objects of a certain type as a conceptual set. It acts like a

collection, except with more elaborate querying capability”

Repository

“All repositories provide methods that allow client to request objects matching some

criteria”

Repository

“Although most queries return an object or a collection of objects, it also fits within the concept to return some types of summary

calculation”

Aggregate

“A DDD aggregate is a cluster of domain objects that can be treated as a single unit.”

(http://martinfowler.com/bliki/DDD_Aggregate.html)

Aggregate

“DDD aggregates are domain concepts (order, clinic visit, playlist), while collections are

generic.”

(http://martinfowler.com/bliki/DDD_Aggregate.html)

Domain Event

“Captures the memory of something interesting which affects the domain”

(http://martinfowler.com/eaaDev/DomainEvent.html)

How long does it take?

5. DDD Layering

Layering

“We need to decouple the domain objects from other functions of the system, so we can avoid

confusing the domain concepts wiht other concepts”

Layering

“We need to decouple the domain objects from other functions of the system, so we can avoid

confusing the domain concepts wiht other concepts”

Layering

(http://guptavikas.wordpress.com/2009/12/01/domain-driven-design-an-introduction/)

Layering

(http://dddsample.sourceforge.net/architecture.html)

Domain

“The domain layer is the heart of the software, and this is where the interesting stuff happens.”

Application

“The application layer is responsible for driving the workflow of the application, matching the

use cases at hand”

Interface

“This layer holds everything that interacts with other systems”

Interface

“This layer holds everything that interacts with other systems”

Controller Form

View API

Infrastructure

“In simple terms, the infrastructure consists of everything that exists independently of our application: external

libraries, database engine, application server, messaging backend and so on.”

Separation of concerns

Services

“Sometimes, it just isn’t a thing.”

Services

Domain ServicesApplication Services

Infrastructural Services

Domain Services

“If a SERVICE were devised to make appropriate debits and credits for a found

transfer, that capability would belong in the domain layer”

Application Services

“if the banking application can convert and export our transactions into a spreadsheet file

[...] that export is an application SERVICE”

Infrastructural Services

“a bank might have an application that sends an e-mail [...]. The interface that encapsulates

the email system, [...] is a SERVICE in the infrastructure layer”

6. Code First

Persistence Ignorance

“In DDD, we don't consider any databases. DDD is all about the domain, not about the

database, and Persistence Ignorance (PI) is a very important aspect of DDD”

(http://williamdurand.fr/2013/08/20/ddd-with-symfony2-making-things-clear/)

You aren't gonna need it.You don’t need a Database or a Framework to

modelling the Domain

You aren't gonna need it.You don’t need a Database or a Framework to

modelling the Domain

Where should I start then?!?

Understanding the Domain

Talking with domain experts

DDD is Agile, we should be iterative

7. Let’s code

Our starting domain

I need a tool to plan my trips.Every trip must have at least one route and every route has one or more leg.A leg has one date and one location.

Here, a complete sample code:https://github.com/leopro/trip-planner

You can follow the building steps, starting from the first commit.

Let’s focus on some steps

composer.json

{ "name": "my trip planner", "autoload": { "psr-0": { "": "src/" } }, "require": { "php": ">=5.3.3", "doctrine/collections": "v1.2", }, "require-dev": { "phpunit/phpunit": "4.0.*" }, "config": { "bin-dir": "bin" }}

composer.json

I don't need anything more to start

composer.json

Ok, I have a dependency on doctrine/collections ...

composer.json

… the missing (SPL) Collection/Array/OrderedMap interface

composer.json

Anyway, you can put a boundary

namespace Leopro\TripPlanner\Domain\Contract;

use Doctrine\Common\Collections\Collection as DoctrineCollection;

interface Collection extends DoctrineCollection {}

namespace Leopro\TripPlanner\Domain\Adapter;

use Doctrine\Common\Collections\ArrayCollection as DoctrineArrayCollection;use Leopro\TripPlanner\Domain\Contract\Collection;

class ArrayCollection extends DoctrineArrayCollection implements Collection {}

Domain

Our starting domain

namespace Leopro\TripPlanner\Domain\Tests;

use Leopro\TripPlanner\Domain\Entity\Trip;

class TripTest extends \PHPUnit_Framework_TestCase{ public function testCreateTripReturnATripWithFirstRoute() { $trip = Trip::create('my first planning'); $this->assertInstanceOf('Leopro\TripPlanner\Domain\Entity\Trip', $trip); $this->assertEquals(1, $trip->getRoutes()->count()); }}

namespace Leopro\TripPlanner\Domain\Entity;

use Leopro\TripPlanner\Domain\Adapter\ArrayCollection;

class Trip{ private $name, private $routes;

private function __construct($name, Route $route) { $this->name = $name; $this->routes = new ArrayCollection(array($route)); }

public function create($name) { return new self($name, new Route); }

public function getRoutes() { return $this->routes; }}

class Route{

Our starting domain

use Leopro\TripPlanner\Domain\Entity\Route;

class RouteTest extends \PHPUnit_Framework_TestCase{ public function testCreateRouteAddingALeg() { $route = Route::create('my first trip'); $route->addLeg('06-06-2014');

$this->assertEquals(1, $route->getLegs()->count()); }

class Route{ private $name; private $legs;

private function __construct($name) { $this->name = $name; $this->legs = new ArrayCollection(); }

public static function create($tripName) { return new self('first route for trip: ' . $tripName); }

public function addLeg($date) { $leg = Leg::create($date); $this->legs->add($leg); }

class Route{ private $name; private $legs;

private function __construct($name) { $this->name = $name; $this->legs = new ArrayCollection(); }

public static function create($tripName) { return new self('first route for trip: ' . $tripName); }

public function addLeg($date) { $leg = Leg::create($date); $this->legs->add($leg); }

Wait, we really want two legs with the same date?

The model is changing

I need a tool to plan my trips.Every trip must have at least one route and every route has one or more leg

and two leg with the same date for the same route are not allowed .

A leg has one date and one location.

/** * @expectedException \...\DateAlreadyUsedException */public function testNoDuplicationDateForTheSameRoute(){ $route = Route::create('my first trip'); $route->addLeg('06-06-2014'); $route->addLeg('06-06-2014');}

class Route{

public function addLeg($date){ $leg = Leg::create($date);

$dateAlreadyUsed = function($key, $element) use($leg) { return $element->getDate() == $leg->getDate(); };

if ($this->legs->exists($dateAlreadyUsed)) { throw new DateAlreadyUsedException($date . ' already used'); }

$this->legs->add($leg);}

Our starting domain

use Leopro\TripPlanner\Domain\Entity\Leg;

class LegTest extends \PHPUnit_Framework_TestCase{ public function testCreateLegReturnsALegWithDateAndLocation() { $leg = Leg::create('01/01/2014', 'd/m/Y', -3.386665, 36.736908);

$this->assertInstanceOf('Leopro\TripPlanner\Domain\Entity\Leg', $leg);

$location = $leg->getLocation(); $this->assertInstanceOf('Leopro\TripPlanner\Domain\Entity\Location', $location);

$point = $location->getPoint(); $this->assertInstanceOf('Leopro\TripPlanner\Domain\ValueObject\Point', $point); $this->assertEquals(-3.386665, $point->getLatitude()); $this->assertEquals(36.736908, $point->getLongitude()); }}

use Leopro\TripPlanner\Domain\ValueObject\Date;

class Leg{ private $date; private $location;

private function __construct(Date $date, Location $location) { $this->date = $date; $this->location = $location; }

public static function create($date, $dateFormat, $latitude, $longitude) { $date = new Date($date, $dateFormat); return new self( $date, Location::create($date->getFormattedDate(), $latitude, $longitude) ); }

use Leopro\TripPlanner\Domain\ValueObject\Point;

class Location{ private $name; private $point;

private function __construct($name, Point $point) { $this->name = $name; $this->point = $point; }

public static function create($name, $latitude, $longitude) { return new self($name, new Point($latitude, $longitude) ); }

public function getPoint() { return $this->point; }}

class PointTest extends \PHPUnit_Framework_TestCase{ public function testDistance() { $firstPoint = new Point(-3.386665, 36.736908); $secondPoint = new Point(-3.428112, 35.932846);

$this->assertEquals(89, $firstPoint->getCartographicDistance($secondPoint)); $this->assertEquals(98, $firstPoint->getApproximateRoadDistance($secondPoint)); }}

class PointTest extends \PHPUnit_Framework_TestCase{ public function testDistance() { $firstPoint = new Point(-3.386665, 36.736908); $secondPoint = new Point(-3.428112, 35.932846);

$this->assertEquals(89, $firstPoint->getCartographicDistance($secondPoint)); $this->assertEquals(98, $firstPoint->getApproximateRoadDistance($secondPoint)); }}

Value Object

getCartographicDistance()getApproximateRoadDistance()

namespace Leopro\TripPlanner\Domain\ValueObject;

class Point{ private $latitude; private $longitude;

public function __construct($latitude, $longitude) { $this->latitude = $latitude; $this->longitude = $longitude; }

public function getApproximateRoadDistance(Point $point, $degreeApproximation = 10) { $distance = $this->getCartographicDistance($point);

return round($distance + $distance * ($degreeApproximation / 100)); }

public function getCartographicDistance(Point $point){ $earthRadius = 3958.75;

$dLat = deg2rad($point->getLatitude() - $this->latitude); $dLng = deg2rad($point->getLongitude() - $this->longitude);

$a = sin($dLat / 2) * sin($dLat / 2) + cos(deg2rad($this->latitude)) * cos(deg2rad($point->getLatitude())) * sin($dLng / 2) * sin($dLng / 2);

$c = 2 * atan2(sqrt($a), sqrt(1 - $a)); $dist = $earthRadius * $c;

$meterConversion = 1.609344; $geopointDistance = $dist * $meterConversion;

return round($geopointDistance, 0);}

public function getCartographicDistance(Point $point){ $earthRadius = 3958.75;

$dLat = deg2rad($point->getLatitude() - $this->latitude); $dLng = deg2rad($point->getLongitude() - $this->longitude);

$a = sin($dLat / 2) * sin($dLat / 2) + cos(deg2rad($this->latitude)) * cos(deg2rad($point->getLatitude())) * sin($dLng / 2) * sin($dLng / 2);

$c = 2 * atan2(sqrt($a), sqrt(1 - $a)); $dist = $earthRadius * $c;

$meterConversion = 1.609344; $geopointDistance = $dist * $meterConversion;

return round($geopointDistance, 0);}

Got the point?

Application

namespace Leopro\TripPlanner\Application\Command;

use Leopro\TripPlanner\Application\UseCase\UseCaseInterface;

class CommandHandler{ private $useCases;

public function registerCommands(array $useCases) { foreach ($useCases as $useCase) { if ($useCase instanceof UseCaseInterface) { $this->useCases[$useCase->getManagedCommand()] = $useCase; } else { throw new \LogicException(‘...'); } } }

class CommandHandler{ //...

public function execute($command) { try {

$commandClass = get_class($command); if (!array_key_exists($commandClass, $this->useCases)) { throw new \LogicException($commandClass . ' is not a managed command'); }

$this->useCases[get_class($command)]->run($command); } catch (\Exception $e) { throw $e; } }}

class CommandHandler{ //...

public function execute($command) { try {

$commandClass = get_class($command); if (!array_key_exists($commandClass, $this->useCases)) { throw new \LogicException($commandClass . ' is not a managed command'); }

$this->useCases[get_class($command)]->run($command); } catch (\Exception $e) { throw $e; } }}

You can move the state of the domain, through commands

use Leopro\TripPlanner\Application\Contract\CommandInterface;use Leopro\TripPlanner\Domain\Adapter\ArrayCollection;

class CreateTripCommand implements CommandInterface{ private $name;

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

public function getRequest() { return new ArrayCollection( array( 'name' => $this->name ) ); }}

namespace Leopro\TripPlanner\Application\UseCase;

class CreateTripUseCase extends AbstractUseCase implements UseCaseInterface{ private $tripRepository;

public function __construct(TripRepository $tripRepository) { $this->tripRepository = $tripRepository; }

public function run(CommandInterface $command) { $this->exceptionIfCommandNotManaged($command);

$request = $command->getRequest();

$trip = Trip::createWithFirstRoute(new TripIdentity(uniqid()), $request->get('name'));

$this->tripRepository->add($trip);

return $trip; }}

namespace Leopro\TripPlanner\Application\UseCase;

class CreateTripUseCase extends AbstractUseCase implements UseCaseInterface{ private $tripRepository;

public function __construct(TripRepository $tripRepository) { $this->tripRepository = $tripRepository; }

public function run(CommandInterface $command) { $this->exceptionIfCommandNotManaged($command);

$request = $command->getRequest();

$trip = Trip::createWithFirstRoute(new TripIdentity(uniqid()), $request->get('name'));

$this->tripRepository->add($trip);

return $trip; }}

Defining a TripRepository interface ...

use Leopro\TripPlanner\Domain\Entity\Trip;use Leopro\TripPlanner\Domain\ValueObject\TripIdentity;

interface TripRepository{ /** * @param TripIdentity $identity * @return \Leopro\TripPlanner\Domain\Entity\Trip */ public function get(TripIdentity $identity);

/** * @param Trip $trip * @return void */ public function add(Trip $trip);}

use Leopro\TripPlanner\Domain\Entity\Trip;use Leopro\TripPlanner\Domain\ValueObject\TripIdentity;

interface TripRepository{ /** * @param TripIdentity $identity * @return \Leopro\TripPlanner\Domain\Entity\Trip */ public function get(TripIdentity $identity);

/** * @param Trip $trip * @return void */ public function add(Trip $trip);}

… and interfaces for Validator and Event Dispatcher

namespace Leopro\TripPlanner\Application\Contract;

interface Validator{ /** * @param $value * @return \Leopro\TripPlanner\Domain\Contract\Collection */ public function validate($value);}

interface EventDispatcher{ /** * @param array $listeners * @return EventListener[] */ public function registerListeners(array $listeners);

/** * @param $event */ public function notify($name, $event);}

About validation

In DDD, entities should be always valid.

About validation

But if you ask“where do I put validation?”you'll get different answers.

About validation

If you are using commands, validate the command itself, is a

good trade-off.

Infrastructure

Framework's revenge

composer.json

"require": { "php": ">=5.3.3", "doctrine/collections": "v1.2", "symfony/symfony": "~2.4", "doctrine/dbal": "dev-master", "doctrine/orm": "dev-master", "doctrine/doctrine-bundle": "dev-master", "twig/extensions": "~1.0", "symfony/assetic-bundle": "~2.3", "symfony/swiftmailer-bundle": "~2.3", "symfony/monolog-bundle": "~2.4", "sensio/distribution-bundle": "~2.3", "sensio/framework-extra-bundle": "~3.0", "sensio/generator-bundle": "~2.3", "incenteev/composer-parameter-handler": "~2.0", "doctrine/data-fixtures": "dev-master", "doctrine/migrations": "dev-master", "doctrine/doctrine-migrations-bundle": "dev-master", "doctrine/doctrine-fixtures-bundle": "dev-master"},

Mapping entities

app/config/config.yml

orm: auto_generate_proxy_classes: "%kernel.debug%" auto_mapping: false mappings: TripPlannerDomain: type: yml prefix: Leopro\TripPlanner\Domain\Entity dir: %kernel.root_dir%/../src/Leopro/TripPlanner/InfrastructureBundle/Resources/config/doctrine/entity is_bundle: false TripPlannerDomainValueObjects: type: yml prefix: Leopro\TripPlanner\Domain\ValueObject dir: %kernel.root_dir%/../src/Leopro/TripPlanner/InfrastructureBundle/Resources/config/doctrine/value_object is_bundle: false

InfrastructureBundle/Resources/config/entity/Route.orm.yml

Leopro\TripPlanner\Domain\Entity\Trip: type: entity table: trip embedded: identity: class: Leopro\TripPlanner\Domain\ValueObject\TripIdentity fields: name: type: string length: 250 manyToMany: routes: targetEntity: Leopro\TripPlanner\Domain\Entity\Route joinTable: name: trip_routes joinColumns: link_id: referencedColumnName: identity_id inverseJoinColumns: report_id: referencedColumnName: internalIdentity cascade: ["persist"]

Validate commands

InfrastructureBundle/Resources/config/validation.yml

Leopro\TripPlanner\Application\Command\CreateTripCommand: properties: name: - NotBlank: ~

Leopro\TripPlanner\Application\Command\AddLegToRouteCommand: properties: tripIdentity: - NotBlank: ~ routeIdentity: - NotBlank: ~ date: - NotBlank: ~ dateFormat: - NotBlank: ~ latitude: - NotBlank: ~ longitude: - NotBlank: ~

Configuring services

src/LeoPro/TripPlanner/InfrastructureBundle/Resources/config/services.xml

<service id="trip_repository" alias="trip_repository.doctrine"></service>

</services>

<service id="application.event_dispatcher" public="false" class="%application.event_dispatcher.class%"> </service>

</services>

<service id="infrastructure.validator" public="false" class="%infrastructure.validator.class%"> <argument type="service" id="validator"/> </service>

<service id="trip_repository.doctrine" public="false" class="%infrastructure.trip_repository.doctrine.class%"> <argument type="service" id="doctrine.orm.entity_manager"/> </service>

</services>

Adapter

Ops … some parts of the frameworks do not fit our

interfaces.

namespace Leopro\TripPlanner\InfrastructureBundle\Adapter;

use Leopro\TripPlanner\Application\Contract\Validator as ApplicationValidatorInterface;use Leopro\TripPlanner\Domain\Adapter\ArrayCollection;use Symfony\Component\Validator\Validator\ValidatorInterface;

class Validator implements ApplicationValidatorInterface{ private $validator;

public function __construct(ValidatorInterface $validator) { $this->validator = $validator; }

public function validate($value) { $applicationErrors = new ArrayCollection(); $errors = $this->validator->validate($value); foreach ($errors as $error) { $applicationErrors->set($error->getPropertyPath(), $error->getMessage()); }

return $applicationErrors; }}

Repository

namespace Leopro\TripPlanner\InfrastructureBundle\Repository;

use Doctrine\ORM\EntityManager;use Leopro\TripPlanner\Domain\Contract\TripRepository as TripRepositoryInterface;

class TripRepository implements TripRepositoryInterface{ private $em;

public function __construct(EntityManager $em) { $this->em = $em; }

public function get(TripIdentity $identity) { $qb = $this->em->createQueryBuilder() ->select('t') ->from("TripPlannerDomain:Trip", 't') ->where('t.identity.id = :identity');

$qb->setParameter('identity', $identity);

return $qb->getQuery()->getOneOrNullResult(); }

class TripRepository implements TripRepositoryInterface{ public function add(Trip $trip) { $this->em->persist($trip); $this->em->flush(); }}

Then it’s like a Doctrine repository?!?

No, it’s quite different

use Leopro\TripPlanner\Domain\Contract\TripRepository as TripRepositoryInterface;

class TripRepository implements TripRepositoryInterface{ private $myThirdPartApiClient;

public function __construct(ApiClient $myThirdPartApiClient) { $this->myThirdPartApiClient = $myThirdPartApiClient; }

public function get(TripIdentity $identity) { $this->myThirdPartApiClient->get($identity); }

public function add(Trip $trip) { $this->myThirdPartApiClient->store($trip); }

use Leopro\TripPlanner\Domain\Contract\TripRepository as TripRepositoryInterface;

class TripRepository implements TripRepositoryInterface{ private $myThirdPartApiClient;

public function __construct(ApiClient $myThirdPartApiClient) { $this->myThirdPartApiClient = $myThirdPartApiClient; }

public function get(TripIdentity $identity) { $this->myThirdPartApiClient->get($identity); }

public function add(Trip $trip) { $this->myThirdPartApiClient->store($trip); }

It’s another possible Repository implementation

Presentation

namespace Leopro\TripPlanner\PresentationBundle\Controller;

use Leopro\TripPlanner\PresentationBundle\Form\Type\CreateTripType;

class ApiController extends Controller{ /** * @Route("/", name="create_trip") * @Template */ public function createTripAction(Request $request) { $form = $this->createForm(new CreateTripType()); $form->handleRequest($request);

if ($form->isValid()) { $trip = $this->get('command_handler')->execute($form->getData());

return new Response('ok'); }

return array( 'form' => $form->createView(), ); }}

namespace Leopro\TripPlanner\PresentationBundle\Form\Type;

use Leopro\TripPlanner\Application\Command\CreateTripCommand;

class CreateTripType extends AbstractType{ public function buildForm(FormBuilderInterface $builder, array $options) { $builder ->add('name') ->add('save', 'submit'); }

public function setDefaultOptions(OptionsResolverInterface $resolver) { $resolver->setDefaults(array( 'data_class' => 'Leopro\TripPlanner\Application\Command\CreateTripCommand', 'empty_data' => function (FormInterface $form) { $command = new CreateTripCommand( $form->get('name')->getData() );

return $command; }, )); }}

One step to the finish line

What have I learned?

A clean architecture helps in avoiding the Big Ball of Mud.

Also starting with a very simple domain

Iteration by iteration

Complexity could grow

If our system is tightly coupled

and the domain is scattered

we are losing the chance of responding to changes.

Talking about testing ...

… independence from frameworks, database, UI ...

… means talking about business.

Let the code speak the language of the business

First, taking care of the model

Then choosing the right tool

We reached the finish line, well done.

Thank you :-)

Credits

● Eric Evans, - "Domain Driven Design"● “Uncle Bob” - http://blog.8thlight.com/uncle-bob/archive.html and books● http://williamdurand.fr/2013/08/20/ddd-with-symfony2-making-things-clear/● http://williamdurand.fr/2013/08/07/ddd-with-symfony2-folder-structure-and-

code-first/● http://verraes.net/2013/04/decoupling-symfony2-forms-from-entities/● http://www.whitewashing.

de/2012/08/22/building_an_object_model__no_setters_allowed.html● http://nicolopignatelli.me/valueobjects-a-php-immutable-class-library/● http://welcometothebundle.com/domain-driven-design-and-symfony-for-

simple-app/● http://www.slideshare.net/SteveRhoades2/implementing-ddd-concepts-in-

Credits

● http://devlicio.us/blogs/casey/archive/2009/02/16/ddd-aggregates-and-aggregate-roots.aspx

● http://www.slideshare.net/perprogramming/application-layer-33335917● http://lostechies.com/jimmybogard/2008/08/21/services-in-domain-driven-

design/● http://gorodinski.com/blog/2012/04/14/services-in-domain-driven-design-

ddd/● http://www.slideshare.net/jeppec/agile-ddd-cqrs● http://www.slideshare.net/thinkddd/practical-domain-driven-design-cqrs-

and-messaging-architectures● http://www.codeproject.com/Articles/339725/Domain-Driven-Design-Clear-

Your-Concepts-Before-Yo● http://lostechies.com/jimmybogard/2008/05/21/entities-value-objects-

aggregates-and-roots/

Credits

● http://www.slideshare.net/ziobrando/gestire-la-complessit-con-domain-driven-design

● http://lostechies.com/jimmybogard/2009/02/15/validation-in-a-ddd-world/● http://lostechies.com/jimmybogard/2009/09/03/ddd-repository-

implementation-patterns/● http://www.sapiensworks.com/blog/post/2012/04/18/DDD-Aggregates-

And-Aggregates-Root-Explained.aspx● http://www.udidahan.com/2009/06/29/dont-create-aggregate-roots/● http://jblewitt.com/blog/?p=241● http://www.sapiensworks.com/blog/post/2013/10/18/Modelling-Aggregate-

Roots-Relationships.aspx● http://www.sapiensworks.com/blog/post/2013/01/15/Domain-Driven-

Design-Aggregate-Root-Modelling-Fallacy.aspx

Credits

● http://lostechies.com/jamesgregory/2009/05/09/entity-interface-anti-pattern● http://www.slideshare.net/piotrpelczar/cqrs-28299581● http://richarddingwall.name/2009/10/13/life-inside-an-aggregate-root-part-

1/● http://lostechies.com/jimmybogard/2010/02/24/strengthening-your-domain-

aggregate-construction/● http://guptavikas.wordpress.com/2009/12/21/domain-driven-design-

creating-domain-objects/● http://gorodinski.com/blog/2012/05/19/validation-in-domain-driven-design-

ddd/● http://verraes.net/2013/12/related-entities-vs-child-entities/● http://devlicio.us/blogs/casey/archive/2009/02/20/ddd-the-repository-

pattern.aspx● http://gojko.net/2009/09/30/ddd-and-relational-databases-the-value-object-

dilemma/

Clean architecture with ddd layering in php

ignores extraneous

external agency

frameworks

domain driven

domain experts

accelerating

clean architecture

domain concepts

Internet

layering theme

Object-Oriented Design Layers. 2 Layering Mechanisms...

DDD Presentation for Feb 2019 Pre-App...

Layering in Networked computing. Learning outcomes...

DDD · 2020. 6. 25. · ddd ddddd ddddd dddd ddd dddd ddddd...

Yazılım Mühendİslİğİ ve Günümüz PHP...

DDD DDD DD SIXIÈME MODIFICATION DU DDD PLAN LOCAL … ddd.....

Light Layering

DDDD DDD DD DDD DDD DDD DD D DD

Php melb cqrs-ddd-predaddy

‘Layering Cardiff’

Protocol Layering

Compania DDD 2.pdf · Compania DDD ... o

Layering Masks

Shellac Layering

Hexagonal Architecture - PHP Barcelona Monthly Talk (DDD)