Contextos delimitados e mapeamento de contextos
Divida domínios grandes em contextos delimitados que se comuniquem com segurança.
Contextos delimitados e mapeamento de contextos é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.
DDD estratégico
Padrões táticos modelam objetos dentro de um domínio; o DDD estratégico decide como dividir um sistema grande em partes que possam evoluir de forma independente. O conceito central é o Contexto delimitado — um limite explícito dentro do qual um modelo de domínio e sua linguagem são consistentes. O Mapeamento de contextos descreve como esses contextos se relacionam. Isso costuma ter mais impacto do que o projeto de qualquer classe isolada.
A linguagem ubíqua
Dentro de um contexto delimitado, a equipe compartilha uma linguagem ubíqua — os mesmos termos usados na conversa, no código e no modelo. O detalhe importante é que uma palavra pode ter significados diferentes em contextos diferentes. Um Customer em Vendas (potenciais clientes, descontos) não é o mesmo que um Customer em Suporte (chamados, acordos de nível de serviço). Um contexto delimitado torna esse limite explícito, em vez de forçar um único modelo compartilhado e inchado.
Mesma palavra, modelos diferentes
O mesmo conceito de negócio recebe um modelo específico para cada contexto. Um Product no Catálogo se preocupa com descrições e mídia; no Estoque, preocupa-se com quantidade disponível e localização. Cada contexto define apenas o que precisa.
<?php
namespace Catalog;
final class Product {
public function __construct(
public readonly string $sku,
public readonly string $description
) {}
}
namespace Inventory;
final class Product {
public function __construct(
public readonly string $sku,
public readonly int $onHand
) {}
}
namespace App;
$c = new \Catalog\Product('A1', 'Blue mug');
$i = new \Inventory\Product('A1', 42);
echo $c->description, ' / ', $i->onHand, PHP_EOL;
Por que não um modelo único grande
Tentar fazer um Customer canônico atender a todas as equipes produz uma classe onipotente, com requisitos conflitantes, disputas entre equipes e alterações frágeis. Contextos delimitados permitem que cada equipe seja responsável por seu modelo e sua linguagem, faça implantações independentes e traduza os conceitos nas bordas. O limite é o ponto em que você assume um pequeno custo de integração para evitar um grande custo de acoplamento.
Mapas de contexto
Um Mapa de contexto é uma visão geral dos seus contextos delimitados e dos relacionamentos entre eles. Ele registra tanto a integração técnica quanto o relacionamento de equipe/político (quem depende de quem, quem pode impor alterações). O DDD nomeia vários padrões recorrentes de relacionamento, que examinaremos a seguir.
Conformista no código
Os relacionamentos costumam ser direcionais — um contexto a montante influencia um contexto a jusante (Customer/Fornecedor, Conformista, Camada anticorrupção). Um contexto a jusante Conformista não tem poder de negociação, então simplesmente adota o modelo do contexto a montante tal como ele é: consome diretamente o formato externo e aceita o acoplamento.
<?php
// Upstream's shape, used verbatim downstream (Conformist)
final class UpstreamUser {
public function __construct(public readonly int $userId, public readonly string $login) {}
}
final class Greeter { // conforms: depends directly on upstream type
public function greet(UpstreamUser $u): string {
return "Hello {$u->login} (#{$u->userId})";
}
}
echo (new Greeter())->greet(new UpstreamUser(7, 'jane')), PHP_EOL;
Camada anticorrupção
Uma ACL traduz um modelo externo ou legado para o modelo limpo do seu contexto, para que conceitos estrangeiros nunca façam leak para dentro. É o padrão Adaptador aplicado no limite de um contexto, protegendo sua linguagem ubíqua.
<?php
// Our clean domain model
final class Customer {
public function __construct(public readonly string $id, public readonly string $name) {}
}
// Legacy/external shape we must not let leak in
$legacy = ['CUST_NO' => '0042', 'FULL_NM' => 'Jane Doe'];
final class LegacyCustomerAcl {
public function toDomain(array $row): Customer {
return new Customer($row['CUST_NO'], $row['FULL_NM']);
}
}
$customer = (new LegacyCustomerAcl())->toDomain($legacy);
echo $customer->id, ' ', $customer->name, PHP_EOL;
Núcleo compartilhado no código
- Núcleo compartilhado: dois contextos compartilham um pequeno subconjunto sob responsabilidade conjunta (abaixo, um tipo
Moneycomum) — altere-o somente por acordo. - Parceria: duas equipes vencem ou fracassam juntas.
- Caminhos separados: a integração não vale o custo.
- Serviço de protocolo aberto / linguagem publicada: o contexto a montante oferece um protocolo estável e documentado para vários consumidores.
<?php
namespace Shared; // small, jointly-owned kernel
final class Money {
public function __construct(public readonly int $cents, public readonly string $cur) {}
public function format(): string { return number_format($this->cents / 100, 2) . ' ' . $this->cur; }
}
namespace Billing; // depends on the shared kernel
use Shared\Money;
function invoiceTotal(): Money { return new Money(4999, 'USD'); }
namespace Payroll; // also depends on the SAME shared kernel
use Shared\Money;
function salary(): Money { return new Money(500000, 'USD'); }
Integração de contextos em PHP
Na prática, os contextos se integram por meio de contratos bem definidos: um método de tradução, um cliente de API que encapsula uma linguagem publicada ou mensagens. O lado receptor mapeia o objeto de transferência de dados externo para seu próprio modelo, fazendo com que o acoplamento termine no limite.
<?php
// Published Language DTO from an upstream Open Host Service
final class PricingDto {
public function __construct(public readonly string $sku, public readonly int $cents) {}
}
// Our downstream model
final class CatalogPrice {
public function __construct(public readonly string $sku, public readonly float $amount) {}
}
final class PricingTranslator {
public function translate(PricingDto $dto): CatalogPrice {
return new CatalogPrice($dto->sku, $dto->cents / 100);
}
}
$p = (new PricingTranslator())->translate(new PricingDto('A1', 1599));
echo $p->amount, PHP_EOL; // 15.99
Contextos e arquitetura
Contextos delimitados se mapeiam naturalmente para unidades de implantação: um monólito modular com limites claros entre módulos ou microsserviços separados. O limite deve ser traçado em torno da capacidade de negócio (capability), não das camadas técnicas. Microsserviços que dividem um único contexto fortemente acoplado criam um monólito distribuído; limites de contexto bem alinhados produzem serviços que mudam de forma independente.
Eventos como ponto de integração
Na prática, uma forma limpa de integrar contextos sem compartilhar modelos é trocar eventos. O contexto a montante publica um evento pequeno e estável (uma linguagem publicada); o contexto a jusante assina esse evento e o mapeia para seu próprio modelo — sem nunca importar as classes do contexto a montante.
<?php
// Published Language: a minimal stable contract
final class OrderPlacedEvent {
public function __construct(public readonly string $orderId, public readonly int $cents) {}
}
// Downstream (Shipping context) maps it to its own model
final class Shipment {
public function __construct(public readonly string $forOrder) {}
}
final class ShippingListener {
public function on(OrderPlacedEvent $e): Shipment {
return new Shipment($e->orderId); // ignores fields it doesn't need
}
}
$shipment = (new ShippingListener())->on(new OrderPlacedEvent('o1', 1300));
echo 'shipment for ', $shipment->forOrder, PHP_EOL;
Verificação rápida
Relacionamentos entre contextos.
Recapitulação
Você passou do DDD tático ao estratégico. Um Contexto delimitado é o limite dentro do qual um modelo e sua linguagem ubíqua permanecem consistentes, livrando as equipes de um único modelo compartilhado e inchado. Um Mapa de contexto documenta os relacionamentos — Customer/Fornecedor, Conformista, Camada anticorrupção, Núcleo compartilhado, Parceria, Caminhos separados, Serviço de protocolo aberto/Linguagem publicada — registrando tanto a integração técnica quanto a dinâmica entre as equipes. Trace limites em torno das capacidades de negócio, traduza os conceitos nas bordas e seu sistema poderá evoluir em partes que podem ser implantadas de forma independente.
Perguntas Frequentes
A aula “Contextos delimitados e mapeamento de contextos” é grátis?
Sim — o texto completo de “Contextos delimitados e mapeamento de contextos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.
O que vou aprender em “Contextos delimitados e mapeamento de contextos”?
Divida domínios grandes em contextos delimitados que se comuniquem com segurança. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar PHP Academy?
Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Contextos delimitados e mapeamento de contextos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de PHP Academy?
Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Blocos básicos de DDD: entidades e objetos de valor
- Agregados, repositórios e fábricas
- Eventos e serviços de domínio
- Contextos delimitados e mapeamento de contextos