9 min lecture • Guide 856 of 877
Patrons et Pratiques de Domain-Driven Design
Domain-Driven Design (DDD) est une approche de développement logiciel qui se concentre sur la modélisation de domaines métier complexes à travers des patrons stratégiques et tactiques. DDD aide les équipes à créer un logiciel qui s'aligne étroitement avec les besoins métier tout en maintenant excellence technique et adaptabilité.
Domain-Driven Design Stratégique
Contextes Limités
Les contextes limités définissent les limites dans lesquelles un modèle de domaine particulier s'applique :
Patrons de Mappage de Contexte :
Sales Context ──► Customer Context ──► Support Context
│ │ │
└─ Shared Kernel ────┼─ Customer ─────────┘
│
└─ Separate Ways
Relations de Contexte :
- Shared Kernel : Sous-ensemble commun de modèle de domaine partagé entre contextes
- Customer-Supplier : Un contexte dépend d'un autre
- Conformist : Suit le modèle d'un autre contexte
- Anti-Corruption Layer : Traduit entre différents modèles
Langage Ubiquitaire
Collaboration avec Expert de Domaine :
Business Analyst ──► Domain Expert ──► Developer ──► Code
│ │ │ │
└─ Business Terms ─────┼─ Ubiquitous ──┼─ Domain ─┘
│ Language │ Objects
└───────────────┘
Évolution du Langage :
- Commencez avec la terminologie métier
- Affinez à travers les conversations
- Reflétez les changements dans le code immédiatement
- Utilisez les mêmes termes dans la documentation, les tests et les discussions
Domain-Driven Design Tactique
Patrons de la Couche Domaine
Entités
Les entités représentent des objets domaine avec identité et cycle de vie :
Caractéristiques d'Entité :
class Customer {
private readonly id: CustomerId;
private name: PersonName;
private email: EmailAddress;
private status: CustomerStatus;
private addresses: Address[];
constructor(id: CustomerId, name: PersonName, email: EmailAddress) {
this.id = id;
this.name = name;
this.email = email;
this.status = CustomerStatus.ACTIVE;
this.addresses = [];
}
changeName(newName: PersonName): void {
if (this.status !== CustomerStatus.ACTIVE) {
throw new DomainError('Cannot change name of inactive customer');
}
this.name = newName;
this.addDomainEvent(new CustomerNameChanged(this.id, newName));
}
equals(other: Customer): boolean {
return this.id.equals(other.id);
}
}
Objets de Valeur
Les objets de valeur sont immuables et définis par leurs attributs :
Implémentation d'Objet de Valeur :
class Money {
private readonly amount: number;
private readonly currency: Currency;
constructor(amount: number, currency: Currency) {
if (amount < 0) {
throw new DomainError('Amount cannot be negative');
}
this.amount = amount;
this.currency = currency;
}
add(other: Money): Money {
if (!this.currency.equals(other.currency)) {
throw new DomainError('Cannot add different currencies');
}
return new Money(this.amount + other.amount, this.currency);
}
multiply(factor: number): Money {
return new Money(this.amount * factor, this.currency);
}
equals(other: Money): boolean {
return this.amount === other.amount && this.currency.equals(other.currency);
}
}
Agrégats
Les agrégats définissent des limites de cohérence et encapsulent les règles métier :
Patron Aggregate Root :
class Order {
private readonly id: OrderId;
private readonly customerId: CustomerId;
private status: OrderStatus;
private items: OrderItem[];
private totalAmount: Money;
constructor(id: OrderId, customerId: CustomerId) {
this.id = id;
this.customerId = customerId;
this.status = OrderStatus.DRAFT;
this.items = [];
this.totalAmount = Money.zero(Currency.USD);
}
addItem(productId: ProductId, quantity: number, unitPrice: Money): void {
if (this.status !== OrderStatus.DRAFT) {
throw new DomainError('Cannot modify confirmed order');
}
const existingItem = this.items.find(item => item.productId.equals(productId));
if (existingItem) {
existingItem.increaseQuantity(quantity);
} else {
this.items.push(new OrderItem(productId, quantity, unitPrice));
}
this.recalculateTotal();
}
confirm(): void {
if (this.items.length === 0) {
throw new DomainError('Cannot confirm empty order');
}
this.status = OrderStatus.CONFIRMED;
this.addDomainEvent(new OrderConfirmed(this.id, this.totalAmount));
}
}
Services de Domaine
Les services contiennent la logique métier qui ne s'intègre pas naturellement dans les entités ou objets de valeur :
Exemple de Service de Domaine :
class PricingService {
constructor(
private readonly discountRepository: DiscountRepository,
private readonly taxCalculator: TaxCalculator
) {}
calculateTotal(order: Order, customer: Customer): Money {
let subtotal = order.getSubtotal();
// Apply customer discounts
const customerDiscounts = this.discountRepository.findByCustomer(customer.id);
for (const discount of customerDiscounts) {
if (discount.appliesTo(subtotal)) {
subtotal = discount.applyTo(subtotal);
}
}
// Calculate taxes
const taxAmount = this.taxCalculator.calculateTax(subtotal, customer.address);
return subtotal.add(taxAmount);
}
}
Événements de Domaine
Les événements de domaine représentent des occurrences métier significatives :
Patron d'Événement de Domaine :
abstract class DomainEvent {
public readonly eventId: string;
public readonly aggregateId: string;
public readonly eventVersion: number;
public readonly occurredOn: Date;
constructor(aggregateId: string) {
this.eventId = uuidv4();
this.aggregateId = aggregateId;
this.eventVersion = 1;
this.occurredOn = new Date();
}
}
class OrderPlaced extends DomainEvent {
constructor(
public readonly orderId: OrderId,
public readonly customerId: CustomerId,
public readonly totalAmount: Money
) {
super(orderId.toString());
}
}
Couche Application
Patrons de Commande et Requête
Patron de Commande :
abstract class Command {
public readonly commandId: string;
public readonly timestamp: Date;
constructor() {
this.commandId = uuidv4();
this.timestamp = new Date();
}
}
class PlaceOrderCommand extends Command {
constructor(
public readonly customerId: CustomerId,
public readonly items: OrderItem[]
) {
super();
}
}
class CommandHandler {
constructor(
private readonly orderRepository: OrderRepository,
private readonly domainEventPublisher: DomainEventPublisher
) {}
async handle(command: PlaceOrderCommand): Promise<OrderId> {
const order = Order.create(command.customerId);
for (const item of command.items) {
order.addItem(item.productId, item.quantity, item.unitPrice);
}
await this.orderRepository.save(order);
await this.domainEventPublisher.publish(order.getDomainEvents());
return order.id;
}
}
Services d'Application
Couche de Service d'Application :
class OrderApplicationService {
constructor(
private readonly commandBus: CommandBus,
private readonly queryBus: QueryBus
) {}
async placeOrder(request: PlaceOrderRequest): Promise<PlaceOrderResponse> {
const command = new PlaceOrderCommand(
new CustomerId(request.customerId),
request.items.map(item => new OrderItem(
new ProductId(item.productId),
item.quantity,
new Money(item.unitPrice, Currency.USD)
))
);
const orderId = await this.commandBus.send(command);
return { orderId: orderId.toString() };
}
async getOrderDetails(orderId: string): Promise<OrderDetailsDto> {
const query = new GetOrderDetailsQuery(new OrderId(orderId));
return await this.queryBus.send(query);
}
}
Couche Infrastructure
Patron Repository
Implémentation de Repository :
interface OrderRepository {
save(order: Order): Promise<void>;
findById(id: OrderId): Promise<Order | null>;
findByCustomerId(customerId: CustomerId): Promise<Order[]>;
nextIdentity(): OrderId;
}
class SqlOrderRepository implements OrderRepository {
constructor(private readonly db: Database) {}
async save(order: Order): Promise<void> {
const data = this.mapToData(order);
await this.db.orders.upsert({
where: { id: order.id.toString() },
update: data,
create: data
});
}
async findById(id: OrderId): Promise<Order | null> {
const data = await this.db.orders.findUnique({
where: { id: id.toString() }
});
return data ? this.mapToDomain(data) : null;
}
}
Implémentation de Mappage de Contexte
Couche Anti-Corruption
Implémentation ACL :
class LegacySystemAdapter {
constructor(private readonly legacyApi: LegacyApiClient) {}
async getCustomer(customerId: string): Promise<Customer> {
const legacyCustomer = await this.legacyApi.getCustomer(customerId);
return new Customer(
new CustomerId(legacyCustomer.id),
new PersonName(legacyCustomer.firstName, legacyCustomer.lastName),
new EmailAddress(legacyCustomer.email)
);
}
async updateCustomer(customer: Customer): Promise<void> {
await this.legacyApi.updateCustomer({
id: customer.id.toString(),
firstName: customer.name.firstName,
lastName: customer.name.lastName,
email: customer.email.toString()
});
}
}
Tests de Modèles de Domaine
Tests Unitaires de Logique de Domaine
Test d'Entité :
describe('Customer', () => {
it('should change name when active', () => {
const customer = new Customer(
new CustomerId('123'),
new PersonName('John', 'Doe'),
new EmailAddress('john@example.com')
);
customer.changeName(new PersonName('Jane', 'Doe'));
expect(customer.name.firstName).toBe('Jane');
});
it('should not change name when inactive', () => {
const customer = new Customer(/* ... */);
customer.deactivate();
expect(() => {
customer.changeName(new PersonName('Jane', 'Doe'));
}).toThrow(DomainError);
});
});
Tests d'Intégration
Test de Repository :
describe('OrderRepository', () => {
let repository: OrderRepository;
let db: TestDatabase;
beforeEach(async () => {
db = await createTestDatabase();
repository = new SqlOrderRepository(db);
});
it('should save and retrieve order', async () => {
const order = Order.create(new CustomerId('123'));
order.addItem(new ProductId('456'), 2, new Money(10, Currency.USD));
await repository.save(order);
const retrieved = await repository.findById(order.id);
expect(retrieved?.id).toEqual(order.id);
expect(retrieved?.getTotalAmount()).toEqual(new Money(20, Currency.USD));
});
});
Anti-Patrons Courants de DDD
Modèle de Domaine Anémique
Anti-Patron :
// ❌ Anemic - no business logic
class Order {
id: string;
items: OrderItem[];
status: string;
// Just getters and setters
getTotal(): number {
return this.items.reduce((sum, item) => sum + item.price, 0);
}
}
Approche Correcte :
// ✅ Rich domain model
class Order {
// Business logic encapsulated
calculateTotal(): Money {
return this.items.reduce(
(total, item) => total.add(item.getLineTotal()),
Money.zero(this.currency)
);
}
}
Classes Dieu
Anti-Patron :
// ❌ God class - too many responsibilities
class OrderManager {
createOrder() { /* ... */ }
calculateTax() { /* ... */ }
sendEmail() { /* ... */ }
updateInventory() { /* ... */ }
}
Approche Correcte :
// ✅ Single responsibility classes
class OrderFactory { /* ... */ }
class TaxCalculator { /* ... */ }
class EmailService { /* ... */ }
class InventoryService { /* ... */ }
Intégration avec GitScrum
Modélisation de Domaine dans Gestion de Tâches
DDD pour Gestion de Projet :
- Modélisez les projets comme contextes limités
- Utilisez les événements de domaine pour les changements d'état de tâches
- Implémentez des agrégats pour les limites de sprint et de projet
Langage Ubiquitaire dans Communication d'Équipe
Compréhension Partagée :
- Définissez des termes clairs de domaine pour les tâches et workflows
- Utilisez une terminologie consistante entre membres d'équipe
- Reflétez les concepts de domaine dans les configurations du tableau GitScrum