Domain Driven Design - Revision history

Root at 20:52, 20 October 2025

2025-10-20T20:52:14Z

← Older revision		Revision as of 21:52, 20 October 2025
Line 60:		Line 60:

	public function setEmail($newEmail) {		public function setEmail($newEmail) {
	$this-~~>~~email = $newEmail;		$this->email = $newEmail;
	}		}

	public function getUserId() {		public function getUserId() {
	return $this-~~>~~userId;		return $this->userId;
	}		}

Line 98:		Line 98:

	public function __construct($amount, $currency) {		public function __construct($amount, $currency) {
	$this-~~>~~amount = $amount;		$this->amount = $amount;
	$this-~~>~~currency = $currency;		$this->currency = $currency;
	}		}

Line 141:		Line 141:

	public function __construct(PDO $pdo) {		public function __construct(PDO $pdo) {
	$this-~~>~~pdo = $pdo;		$this->pdo = $pdo;
	}		}

	public function findById(int $id): ?Order {		public function findById(int $id): ?Order {
	$stmt = $this-~~>~~pdo-~~>~~prepare('SELECT * FROM orders WHERE id = :id');		$stmt = $this->pdo->prepare('SELECT * FROM orders WHERE id = :id');
	$stmt-~~>~~execute(['id' =~~>~~ $id]);		$stmt->execute(['id' => $id]);
	$row = $stmt-~~>~~fetch();		$row = $stmt->fetch();

	if (!$row) return null;		if (!$row) return null;
Line 196:		Line 196:

	public function __construct($orderId, \DateTime $orderDate) {		public function __construct($orderId, \DateTime $orderDate) {
	$this-~~>~~orderId = $orderId;		$this->orderId = $orderId;
	$this-~~>~~orderDate = $orderDate;		$this->orderDate = $orderDate;
	}		}

	public function getOrderId() {		public function getOrderId() {
	return $this-~~>~~orderId;		return $this->orderId;
	}		}

	public function getOrderDate() {		public function getOrderDate() {
	return $this-~~>~~orderDate;		return $this->orderDate;
	}		}
	}</syntaxhighlight>		}</syntaxhighlight>
Line 215:		Line 215:
	public function place() {		public function place() {
	// ... logic to place the order		// ... logic to place the order
	$event = new OrderPlaced($this-~~>~~id, new \DateTime());		$event = new OrderPlaced($this->id, new \DateTime());
	// Dispatch the event		// Dispatch the event
	EventDispatcher::dispatch($event);		EventDispatcher::dispatch($event);
Line 250:		Line 250:

	public function applyBulkOrderDiscount(Order $order) {		public function applyBulkOrderDiscount(Order $order) {
	if ($this-~~>~~qualifiesForBulkOrderDiscount($order)) {		if ($this->qualifiesForBulkOrderDiscount($order)) {
	$order-~~>~~applyDiscount(0.10); // 10% discount		$order->applyDiscount(0.10); // 10% discount
	}		}
	}		}

	private function qualifiesForBulkOrderDiscount(Order $order): bool {		private function qualifiesForBulkOrderDiscount(Order $order): bool {
	foreach ($order-~~>~~getOrderLines() as $orderLine) {		foreach ($order->getOrderLines() as $orderLine) {
	if ($orderLine-~~>~~getQuantity() ~~>~~ 10) {		if ($orderLine->getQuantity() > 10) {
	return true;		return true;
	}		}
Line 332:		Line 332:

	private function __construct($customerId) {		private function __construct($customerId) {
	$this-~~>~~customerId = $customerId;		$this->customerId = $customerId;
	$this-~~>~~orderLines = [];		$this->orderLines = [];
	}		}

	public function addOrderLine($product, $quantity) {		public function addOrderLine($product, $quantity) {
	$this-~~>~~orderLines[] = [$product, $quantity];		$this->orderLines[] = [$product, $quantity];
	}		}

Line 352:		Line 352:
	$order = new Order($data['customerId']);		$order = new Order($data['customerId']);
	foreach ($data['orderLines'] as $line) {		foreach ($data['orderLines'] as $line) {
	$order-~~>~~addOrderLine($line['product'], $line['quantity']);		$order->addOrderLine($line['product'], $line['quantity']);
	}		}
	return $order;		return $order;
Line 364:		Line 364:
	<syntaxhighlight lang="php">$orderFactory = new OrderFactory();		<syntaxhighlight lang="php">$orderFactory = new OrderFactory();

	$newOrder = $orderFactory-~~>~~createNewOrder($customerId);		$newOrder = $orderFactory->createNewOrder($customerId);

	$savedOrderData = /* fetch from database or other source */;		$savedOrderData = /* fetch from database or other source */;
	$existingOrder = $orderFactory-~~>~~createOrderFromData($savedOrderData);</syntaxhighlight>		$existingOrder = $orderFactory->createOrderFromData($savedOrderData);</syntaxhighlight>
	Factories play a critical role in maintaining the integrity and consistency of your domain model. By centralizing the creation logic, they promote cleaner, more maintainable code and ensure that domain objects are always created in a consistent, valid state.		Factories play a critical role in maintaining the integrity and consistency of your domain model. By centralizing the creation logic, they promote cleaner, more maintainable code and ensure that domain objects are always created in a consistent, valid state.

Line 400:		Line 400:
	public function addOrderLine(Product $product, Quantity $quantity) {		public function addOrderLine(Product $product, Quantity $quantity) {
	// This might enforce invariants like ensuring the number of order lines doesn't exceed a limit.		// This might enforce invariants like ensuring the number of order lines doesn't exceed a limit.
	$this-~~>~~orderLines[] = new OrderLine($product, $quantity);		$this->orderLines[] = new OrderLine($product, $quantity);
	}		}

Line 411:		Line 411:

	public function __construct(Product $product, Quantity $quantity) {		public function __construct(Product $product, Quantity $quantity) {
	$this-~~>~~product = $product;		$this->product = $product;
	$this-~~>~~quantity = $quantity;		$this->quantity = $quantity;
	}		}

Root at 20:49, 20 October 2025

2025-10-20T20:49:58Z

← Older revision		Revision as of 21:49, 20 October 2025
Line 54:		Line 54:

	public function __construct($userId, $email, $password) {		public function __construct($userId, $email, $password) {
	$this-~~>~~userId = $userId;		$this->userId = $userId;
	$this-~~>~~email = $email;		$this->email = $email;
	$this-~~>~~password = $password;		$this->password = $password;
	}		}

Root at 20:46, 20 October 2025

2025-10-20T20:46:40Z

← Older revision		Revision as of 21:46, 20 October 2025
Line 93:		Line 93:
	* '''Self-validation''': Value Objects should always be in a valid state. This means any operation that would result in an invalid state should be prohibited.		* '''Self-validation''': Value Objects should always be in a valid state. This means any operation that would result in an invalid state should be prohibited.

	<syntaxhighlight>class Money {		<syntaxhighlight lang="php">class Money {
	private $amount;		private $amount;
	private $currency;		private $currency;
Line 129:		Line 129:
	Consider an Order aggregate root. We'll define a repository interface for it:		Consider an Order aggregate root. We'll define a repository interface for it:

	<syntaxhighlight>interface OrderRepository {		<syntaxhighlight lang="php">interface OrderRepository {
	public function findById(int $id): ?Order;		public function findById(int $id): ?Order;
	public function findAll(): array;		public function findAll(): array;
Line 137:		Line 137:
	Now, a simple implementation using PDO for a MySQL database might look something like:		Now, a simple implementation using PDO for a MySQL database might look something like:

	<syntaxhighlight>class MySqlOrderRepository implements OrderRepository {		<syntaxhighlight lang="php">class MySqlOrderRepository implements OrderRepository {
	private $pdo;		private $pdo;

Line 191:		Line 191:
	Defining an Event:		Defining an Event:

	<syntaxhighlight>class OrderPlaced {		<syntaxhighlight lang="php">class OrderPlaced {
	private $orderId;		private $orderId;
	private $orderDate;		private $orderDate;
Line 210:		Line 210:
	For raising an event, within your aggregate root or domain entity, you might have a method that does something significant (like placing an order). This method will also raise the event.		For raising an event, within your aggregate root or domain entity, you might have a method that does something significant (like placing an order). This method will also raise the event.

	<syntaxhighlight>class Order {		<syntaxhighlight lang="php">class Order {
	// ... other properties and methods		// ... other properties and methods

Line 222:		Line 222:
	For handling an event, an event listener would handle the action required when an event occurs.		For handling an event, an event listener would handle the action required when an event occurs.

	<syntaxhighlight>class NotifyCustomerOnOrderPlaced {		<syntaxhighlight lang="php">class NotifyCustomerOnOrderPlaced {
	public function handle(OrderPlaced $event) {		public function handle(OrderPlaced $event) {
	// Logic to notify the customer, maybe send an email or SMS.		// Logic to notify the customer, maybe send an email or SMS.
Line 247:		Line 247:
	Suppose you have a rule that when a customer orders more than 10 products of a specific kind, they get a discount. This doesn't naturally fit within the Order or the Product. Instead, this logic can be placed in a domain service:		Suppose you have a rule that when a customer orders more than 10 products of a specific kind, they get a discount. This doesn't naturally fit within the Order or the Product. Instead, this logic can be placed in a domain service:

	<syntaxhighlight>class DiscountService {		<syntaxhighlight lang="php">class DiscountService {

	public function applyBulkOrderDiscount(Order $order) {		public function applyBulkOrderDiscount(Order $order) {
Line 326:		Line 326:
	Suppose you have an Order domain object which has different ways to be instantiated. One way is to create a new order, and another is to recreate an order from stored data (e.g., from a database).		Suppose you have an Order domain object which has different ways to be instantiated. One way is to create a new order, and another is to recreate an order from stored data (e.g., from a database).

	<syntaxhighlight>class Order {		<syntaxhighlight lang="php">class Order {
	private $customerId;		private $customerId;
	private $orderLines;		private $orderLines;
Line 344:		Line 344:
	Now, you can have a Factory for creating Order instances:		Now, you can have a Factory for creating Order instances:

	<syntaxhighlight>class OrderFactory {		<syntaxhighlight lang="php">class OrderFactory {
	public function createNewOrder($customerId) {		public function createNewOrder($customerId) {
	return new Order($customerId);		return new Order($customerId);
Line 362:		Line 362:
	* '''createOrderFromData''': When you need to reconstitute an order from saved data. By using the Factory, the client code doesn't need to know the intricacies of how an Order is created:		* '''createOrderFromData''': When you need to reconstitute an order from saved data. By using the Factory, the client code doesn't need to know the intricacies of how an Order is created:

	<syntaxhighlight>$orderFactory = new OrderFactory();		<syntaxhighlight lang="php">$orderFactory = new OrderFactory();

	$newOrder = $orderFactory->createNewOrder($customerId);		$newOrder = $orderFactory->createNewOrder($customerId);
Line 393:		Line 393:
	Here's a simplified structure:		Here's a simplified structure:

	<syntaxhighlight>class Order { // Aggregate Root		<syntaxhighlight lang="php">class Order { // Aggregate Root
	private $id;		private $id;
	private $customer;		private $customer;

Root: /* Entity Example in PHP */

2025-10-20T20:45:02Z

Entity Example in PHP

← Older revision		Revision as of 21:45, 20 October 2025
Line 48:		Line 48:
	Let's consider a User entity for a clearer understanding:		Let's consider a User entity for a clearer understanding:

	<syntaxhighlight>class User {		<syntaxhighlight lang="php">class User {
	private $userId;		private $userId;
	private $email;		private $email;
Line 74:		Line 74:
	* '''Mutability''': We can see that the User entity can undergo changes, like changing the email or password.		* '''Mutability''': We can see that the User entity can undergo changes, like changing the email or password.
	* '''Encapsulation''': The entity encapsulates its own data and behavior like the setEmail method which act on the internal data.<span id="design-considerations"></span>		* '''Encapsulation''': The entity encapsulates its own data and behavior like the setEmail method which act on the internal data.<span id="design-considerations"></span>


	== Design Considerations ==		== Design Considerations ==

Root: /* Ubiquitous Language */

2025-10-20T20:34:08Z

Ubiquitous Language

Show changes

Maintenance script: Added category IT backend architecture

2025-10-19T17:51:16Z

Added category IT backend architecture

← Older revision		Revision as of 18:51, 19 October 2025
Line 504:		Line 504:
	<!-- From bodyContent 1542917.mraw -->		<!-- From bodyContent 1542917.mraw -->

			[[Category:IT backend architecture]]

Maintenance script: Maintenance script moved page UserDocumentation:Knowledge Central/KC IT/IT backend team/IT backend policies/IT backend architecture/Domain Driven Design to Domain Driven Design: Cleaned title and categorized

2025-10-19T17:51:15Z

Maintenance script moved page UserDocumentation:Knowledge Central/KC IT/IT backend team/IT backend policies/IT backend architecture/Domain Driven Design to Domain Driven Design: Cleaned title and categorized

← Older revision	Revision as of 18:51, 19 October 2025
(No difference)

imported>Unknown user at 10:02, 19 April 2025

2025-04-19T10:02:44Z

Show changes

imported>Unknown user at 10:02, 19 April 2025

2025-04-19T10:02:44Z

← Older revision	Revision as of 11:02, 19 April 2025
(No difference)

imported>Unknown user at 10:02, 19 April 2025

2025-04-19T10:02:44Z

New page