Domain Driven Design – DDD além da teoria!, por Paulo Victor Gomes

Domain-Driven
Design além da teoria
Paulo Victor L. L. Gomes

Presentation licensed by
Share - Keep license - noncommercial
http://creativecommons.org/licenses/by-nc-sa/3.0/

Domain-Driven Design?
Domain-Driven Design é uma
abordagem para o Desenvolvimento
de Software que estabelece uma forte
ligação entre a implementação e o
modelo evolutivo dos conceitos de
negócio. Implementação X Negócios

Fundamentação
Onde colocar a
regra de negócio?

Primeira resposta
“Vai escrevendo código ai,
quando precisar coloque
na camada de
apresentação, no banco
de dados nos controles,
modelos, na configuração
do webserver e não
esquece do xml e aquele
if maroto no
APPLICATION_ENV”

Fundamentação
Encapsule, Daniel San

Orientação a Objetos
Meu framework já usa
Orientação a Objetos.
Esse papo é muito
antigo e eu já superei
esse problema.

Olha meu código...
public function imagodAction() {
$local=VdModel::getLocalStorageAdapter();$items=$purchase->getItemCollection()->getItems();$Items=$this-
>cart->getItems();$index=array();$catalogHelper=newGodHelper();$quantityCartByidentifier=array();
$itemsRemove=array();foreach($itemsas$salespurchaseItem){$quantityCartByidentifier[$salespurchaseItem-
>getidentifier()]=(isset($quantityCartByidentifier[$salespurchaseItem->getidentifier()])?
$quantityCartByidentifier[$salespurchaseItem->getidentifier()]+1:1);foreach($itemsas$salespurchaseItem){if
($salespurchaseItem->getBundleidentifier()&&!isset($index[$salespurchaseItem->getBundleidentifier()]))
{'uniqueAttributes'=>CatalogHelper::getSimpleUniqueAttributes($product,$salespurchaseItem-
>getidentifier()),'color_cart'=>isset($product['meta']['color_family'])?$product['meta']
['color_family']:'','shipment_delivery_time'=>$salespurchaseItem->getShipmentTotalDeliveryTime(),)),
'bundleproducts'=>array($simples[$salespurchaseItem->getidentifier()]=>(isset($simples[$salespurchaseItem-
>getidentifier()])?$simples[$salespurchaseItem->getidentifier()]+1:1)),);$bundleproduct=$local->get
('product',(strstr($salespurchaseItem->getBundleidentifier(),'-',true)));
//resolveproducturable$product=$local->get('product',($simples[$salespurchaseItem->getidentifier()]));
$simple=$product['simples'][$salespurchaseItem->getidentifier()];$identifierHandle=$salespurchaseItem-
>getBundleidentifier();if(isset($bundleproduct['products'][$simples[$salespurchaseItem->getidentifier()]]
['quantity_items'])){$quantityItems=$bundleproduct['products'][$simples[$salespurchaseItem-
>getidentifier()]]['quantity_items'];}else{$quantityItems=1;$itemsRemove[]=$salespurchaseItem-
>getBundleidentifier();}$index[$identifierHandle]['salespurchaseItem']->setShipmentTotalDeliveryTime(max
($index[$identifierHandle]['salespurchaseItem']->getShipmentTotalDeliveryTime(),$salespurchaseItem-
>getShipmentTotalDeliveryTime()));$index[$identifierHandle]['stock']=min($simple['meta']['quantity'],$index
[$identifierHandle]['stock']);$index[$identifierHandle]['cart_rule_discount']+=$salespurchaseItem-
>getCartRuleDiscount();if(isset($index[$identifierHandle]['bundleproducts'][$simples[$salespurchaseItem-
>getidentifier()]])){if($index[$identifierHandle]['bundleproducts'][$simples[$salespurchaseItem-
>getidentifier()]]<$quantityItems){$index[$identifierHandle]['salespurchaseItem']->setUnitPrice($index
[$identifierHandle]['salespurchaseItem']->getUnitPrice()+$salespurchaseItem->getUnitPrice());$index
[$identifierHandle]['salespurchaseItem']->setPaidPrice($index[$identifierHandle]['salespurchaseItem']-

Quando pensamos em POO logo
pensamos em Classes, Encapsulamento,
Polimorfismo, Herança...
POO é mais que isso, a essência da
POO é alinhamento do código com o
negócio, reutilização, mínimo de
acoplamento, linguagem natural...

Como eu uso? De onde eu
começo?
sudo apt-get install ddd (#sqn)
Domain Driven Design

O desafio proposto...
Comunicação entre equipe de produto e
desenvolvimento

Linguagem Ubíqua
Definições de Ubíqua
“O termo foi usado pela primeira vez pelo cientista Norte-Americano Mark Weiser
em 1988 e publicado em 1991 no seu artigo The Computer for the 21st Century”
“termo usado para descrever a onipresença da informática no cotidiano das
pessoas”
“Computação ubíqua tem como objetivo tornar a interação homem computador
invisível, ou seja, integrar a informática com as ações e comportamentos naturais
das pessoas”
Para que um software atenda um domínio, é necessário que se estabeleça, em
primeiro lugar, uma linguagem Ubíquia ou seja, linguagem comum, com termos
bem definidos, que fazem parte do domínio do negócio e que são usados por
todas as pessoas que fazem parte do processo de desenvolvimento.

Projeto Dirigido pelo Modelo (Model Driven Design – MDD). A ideia por
trás de MDD é a de que o seu modelo abstrato deve ser uma representação
perfeita do seu domínio.
MDD – Model Driven Design
UML ajuda muito nessa fase mas, use com cuidado!

DDD na prática
Camada de domínio. Para modelar essa parte, utilizamos alguns Padrões propostos em DDD.
Chamados de blocos de construção, utilizados para representar nosso modelo abstrato. Esses blocos
podem ser:
Entidades - classes de objetos que necessitam de uma identidade.
Objetos de Valores - objetos que só carregam valores, mas que não possuem distinção
de identidade.
Agregados - compostos de Entidades ou Objetos de Valores que são encapsulados numa
única classe
Fábricas - classes responsáveis pelo processo de criação dos Agregados ou dos Objetos
de Valores
Serviços - classes que contêm lógica de negócio, mas que não pertencem a nenhuma
Entidade ou Objetos de Valores.
Repositórios - classes responsáveis por administrar o ciclo de vida dos outros objetos,
normalmente Entidades, Objetos de Valor e Agregados.

Objeto de Valor (Value Object)
Muitos objetos não possuem nenhuma identidade conceitual. Esses objetos descrevem alguma
característica de alguma coisa.

Características
- Medir
- Quantificar
- Descrever
Imutabilidade
“This is one of the most important aspects of a Value Object to grasp. Object values should not be
able to be altered over their life-time. Because of this immutability, Value Objects are easy to reason,
test and are free of undesired/unexpected side-effects.” (Carlos Buenosvinos, Christian Soronellas
and Keyvan Akbary DDD in PHP)

class Currency
{
private $isoCode;
public function __construct($anIsoCode)
{
$this->setIsoCode($anIsoCode);
}
private function setIsoCode($anIsoCode)
{
if (!preg_match('/^[A-Z]{3}$/', $anIsoCode)) {
throw new InvalidArgumentException();
}
$this->isoCode = $anIsoCode;
}
public function isoCode()
{
return $this->isoCode;
}
}

class Money
{
private $amount;
private $currency;
public function __construct($anAmount, Currency $aCurrency)
{
$this->setAmount($anAmount);
$this->setCurrency($aCurrency);
}
private function setAmount($anAmount)
{
$this->amount = (int) $anAmount;
}
private function setCurrency(Currency $aCurrency)
{
$this->currency = $aCurrency;
}
}

class Money
{
/……/
public static function fromMoney(Money $aMoney)
{
return new self(
$aMoney->amount(),
$aMoney->currency()
);
}
public static function ofCurrency(Currency $aCurrency)
{
return new self(0, $aCurrency);
}
}

class Money
{
/……/
public function increaseAmountBy($anAmount)
{
return new self(
$this->amount() + $anAmount,
$this->currency()
);
}
public function add(Money $money)
{
if (!$money->currency()->equals($this->currency())) {
throw new InvalidArgumentException();
}
return new self(
$money->amount() + $this->amount(),
$this->currency()
);
}
}

$a = new Currency('BRL');
$b = new Currency('BRL');
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
$c = new Currency('EUR');
var_dump($a == $c); // bool(false)
var_dump($a === $c); // bool(false)

class MoneyTest extends PHPUnit_Test_TestCase
{
Const BRAZIL_CURRENCY = "BRL";
public function testCopiedMoneyShouldRepresentSameValue()
{
$aMoney = new Money(100, new Currency(self::BRAZIL_CURRENCY));
$copiedMoney = Money::fromMoney($aMoney);
$this->assertTrue($aMoney->equals($copiedMoney));
}
public function testOriginalMoneyShouldNotBeModifiedOnAddition()
{
$aMoney->add(new Money(20, new Currency(self::BRAZIL_CURRENCY)));
$this->assertEquals(100, $aMoney->amount());
}
public function testMoneysShouldBeAdded()
{
$newMoney = $aMoney->add(new Money(20, new Currency(self::BRAZIL_CURRENCY)));
$this->assertEquals(120, $newMoney->amount());
}
}

Persistindo Objetos de Valor
Objetos de valor não são persistidos por conta própria, até por que eles não
possuem identificação. Geralmente um Objeto de Valor é gravado como atributos
de um agregado que possue identificação lógica no sistema.

<?php
class Product
{
private $productId;
private $name;
private $price;
public function __construct(
$aProductId,
$aName,
Money $aPrice
) {
$this->setProductId($aProductId);
$this->setName($aName);
$this->setPrice($aPrice);
}
// ...
}

<?php
interface ProductRepository {
/**
* @param Product $aProduct
* @return bool
*/
public function add(Product $aProduct);
/.../
}

$productRepository = $this->get('repository.product');
$product = new Product(
$productRepository->nextIdentity(),
'Camiseta PHP Experience 2015',
new Money(999, new Currency('BRL'))
);
$productRepository->add($product);

class DbalProductRepository extends DbalRepository implements
ProductRepository
{
public function add(Product $aProduct)
{
$sql = 'INSERT INTO products VALUES (?, ?, ?, ?)';
$stmt = $this->connection()->prepare($sql);
$stmt->bindValue(1, $aProduct->id());
$stmt->bindValue(2, $aProduct->name());
$stmt->bindValue(3, $aProduct->price()->amount());
$stmt->bindValue(4, $aProduct->price()->currency()->isoCode());
$stmt->execute();
// ...
}
}

class DbalProductRepository extends DbalRepository implements
ProductRepository
{
public function productOfId($anId)
{
$sql = 'SELECT * FROM products WHERE id = ?';
$stmt = $this->connection()->prepare($sql);
$stmt->bindValue(1, $anId);
$res = $stmt->execute();
// ...
return new Product(
$row['id'],
$row['name'],
new Money(
$row['price_amount'],
new Currency(
$row['price_currency']
)
)
);
}
}

Entidade (Entity)
Muitos objetos não são fundamentalmente definidos por seus atributos, mas sim por uma linha de
continuidade e identidade

class Person {
private $identificationNumber;
private $firstName;
private $lastName;
public function __construct($anIdentificationNumber, $aFirstName, $aLastName) {
$this->identificationNumber = $anIdentificationNumber;
$this->firstName = $aFirstName;
$this->lastName = $aLastName;
}
public function identificationNumber() {
return $this->identificationNumber;
}
public function firstName() {
return $this->firstName;
}
public function lastName() {
return $this->lastName;
}
}

namespace DomainEntity;
class Product
{
private $id;
private $name;
private $description;
private $ean;
private $price;
private $measure;
private $category;
private $specification;
public function __construct(Category $category,
VOSpecification $specification,
VOPrice $price,
VOMeasure $measure,
$id)
{
$this->category = $category;
$this->id = $id;
$this->measure = $measure;
$this->price = $price;
$this->specification = $specification;
}
}

Pequenos exemplos sobre isolamento de domínio

Pequena explicação
BISO
BUSINESS ISOLATION
github.com/pvgomes/zend2biso
github.com/pvgomes/symfony2biso
github.com/pvgomes/biso

Referência
Domain-Driven Design in PHP
Real examples written in PHP showcasing DDD Architectural
Styles, Tactical Design, and Bounded Context Integration.
Carlos Buenosvinos, Christian Soronellas and Keyvan Akbary
http://leanpub.com/ddd-in-php

Perguntas?
https://www.slideshare.net/profpv/ddd-in-php

Domain Driven Design – DDD além da teoria!, por Paulo Victor Gomes

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (14)

Semelhante a Domain Driven Design – DDD além da teoria!, por Paulo Victor Gomes

Semelhante a Domain Driven Design – DDD além da teoria!, por Paulo Victor Gomes (20)

Mais de iMasters

Mais de iMasters (20)

Domain Driven Design – DDD além da teoria!, por Paulo Victor Gomes