Kernpunkte
Einer der typischsten Aspekte der DDD-Architektur der traditionellen domänengesteuerten Design (DDD) ist die obligatorische Agnostizität des Domänenmodells. In konservativeren Entwürfen, einschließlich einiger Implementierungen, die auf aktiven Aufzeichnungen oder Datentabellen -Gateways basieren (um eine ziemlich irreführende Einfachheit zu verfolgen, endet häufig die Infrastrukturverschmutzungslogik), gibt es immer ein klares Konzept der zugrunde liegenden Speichermechanismen, normalerweise relationalen Datenbanken. Andererseits ist das Domänenmodell von Anfang an konzeptionell auf eine streng „speicherische agnostische“ Natur ausgelegt, wodurch eine seiner Persistenzlogik über seine Grenzen hinaus verschiebt wird. Obwohl die DDD in Anbetracht der direkten Bezugnahme auf eine „Datenbank“ in der realen Welt etwas schwer fassbar ist, ist es wahrscheinlich, dass mindestens eine Datenbank hinter den Kulissen läuft, da das Domänenmodell irgendwann in irgendeiner Form bestehen muss. Daher ist es üblich, eine Zuordnungsschicht zwischen dem Modell und der Datenzugriffsschicht bereitzustellen. Dies fördert nicht nur aktiv die Aufrechterhaltung eines beträchtlichen Maßes an Isolation zwischen den Schichten, sondern schützt auch alle komplexen Details im Client -Code, bei dem Domänenobjekte zwischen Lücken in Problemschichten hin und her verschoben werden. mea culpa Um fair zu sein, ist es fair zu sagen, dass die Behandlung von Singularität in der Data Mapper -Schicht eine beträchtliche Belastung ist und die Strategie "Einmal/dauerhafter Gebrauch" häufig angewendet wird. Trotzdem funktioniert das obige Muster unter ziemlich einfachen Bedingungen gut, wo nur eine kleine Anzahl von Domänenklassen von einer kleinen Anzahl von Mappern verarbeitet werden. Wenn das Modell jedoch anschwillt und komplexer wird, kann die Situation unangenehmer werden, da es im Laufe der Zeit auf jeden Fall zusätzliche Mapper hinzugefügt wird. Dies deutet kurz darauf hin, dass das Öffnen der Tür zur Persistenzvernachlässigung in der Praxis schwierig sein kann, wenn ein reiches Domänenmodell verwendet wird, das aus mehreren komplexen Aggregatwurzeln besteht, zumindest wenn Sie keine teuren Objektdiagramme an mehreren Stellen erstellen oder auf den Pfad der Sünde der wiederholten Implementierung beginnen. Schlimmer noch, in großen Systemen, die teure aggregierte Root -Sets aus der Datenbank extrahieren müssen, die unterschiedliche Bedingungen entsprechen, kann der gesamte Abfrageprozess selbst zu einem aktiven, produktiven Enabler einer solchen fehlerhaften Vervielfältigung werden, wenn sie über einen einzelnen Einstiegspunkt nicht ordnungsgemäß konzentriert ist.In diesem komplexen Anwendungsfall wird eine zusätzliche Abstraktionsebene (häufig als Lagerung in DDD -Jargon bezeichnet) implementiert, die zwischen dem Data Mapper und dem Domänenmodell effektiv minimiert, während die Semantik des realen Speichers auf das Modell ausgesetzt wird. Im Gegensatz zu Mappers (die Teil der Infrastruktur sind) ist die Lagerhaltung selbst durch die Sprache des Modells gekennzeichnet, da es eng mit dem Modell verbunden ist. Und aufgrund seiner implizite Abhängigkeit von Mappern behält es auch Persistenz -Unwissenheit bei und sorgt somit ein höheres Abstraktionsniveau, näher an Domänenobjekten. Leider kann nicht jede mögliche Anwendung die Vorteile der Lagerhaltung problemlos implementieren, sodass sie nur dann implementiert werden lohnt, wenn die Situation dies erfordert. In jedem Fall wäre es sehr vorteilhaft, ein kleines Lagerhaus von Grund auf neu zu bauen, damit Sie sehen können, wie es intern funktioniert, und aufzeigen, was genau unter seiner ziemlich esoterischen Hülle steht.
Vorläufige Präparate durchführen
Der Prozess der Implementierung der Lagerung kann sehr komplex sein, da er tatsächlich alle Details der Injektion und Verarbeitung von Daten Mappers nach einer vereinfachten Sammel-API verbirgt, die wiederum einen anhaltenden Adapter injiziert, und so weiter. Diese kontinuierliche Injektion von Abhängigkeiten, verbunden mit einer großen Menge an Logik, erklärt, warum die Lagerung häufig als einfaches Aussehen angesehen wird, auch wenn einige Perspektiven derzeit vom Konzept unterscheiden. In beiden Fällen sollten wir den ersten Schritt unternehmen, um aufzustehen und funktionale Lagerung auszuführen, besteht darin, ein grundlegendes Domänenmodell zu erstellen. Das Modell, das ich hier verwenden möchte, ist für die Modellierung des allgemeinen Benutzers mit der Grundstruktur wie folgt verantwortlich:
<?php namespace Model;
interface UserInterface
{
public function setId($id);
public function getId();
public function setName($name);
public function getName();
public function setEmail($email);
public function getEmail();
public function setRole($role);
public function getRole();
}<?php namespace Model;
class User implements UserInterface
{
const ADMINISTRATOR_ROLE = "Administrator";
const GUEST_ROLE = "Guest";
protected $id;
protected $name;
protected $email;
protected $role;
public function __construct($name, $email, $role = self::GUEST_ROLE) {
$this->setName($name);
$this->setEmail($email);
$this->setRole($role);
}
public function setId($id) {
if ($this->id !== null) {
throw new BadMethodCallException(
"The ID for this user has been set already.");
}
if (!is_int($id) || $id throw new InvalidArgumentException(
"The user ID is invalid.");
}
$this->id = $id;
return $this;
}
public function getId() {
return $this->id;
}
public function setName($name) {
if (strlen($name) 30) {
throw new InvalidArgumentException(
"The user name is invalid.");
}
$this->name = htmlspecialchars(trim($name), ENT_QUOTES);
return $this;
}
public function getName() {
return $this->name;
}
public function setEmail($email) {
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException(
"The user email is invalid.");
}
$this->email = $email;
return $this;
}
public function getEmail() {
return $this->email;
}
public function setRole($role) {
if ($role !== self::ADMINISTRATOR_ROLE
&& $role !== self::GUEST_ROLE) {
throw new InvalidArgumentException(
"The user role is invalid.");
}
$this->role = $role;
return $this;
}
public function getRole() {
return $this->role;
}
}In diesem Fall ist das Domänenmodell eine eher Skelettschicht, die kaum höher ist als ein einfacher Datenhalter, der sich selbst überarbeiten kann, was die Daten und das Verhalten einiger fiktiver Benutzer nur durch isolierte Schnittstellen und einfache Implementierer definiert. Um es einfach und leicht zu verstehen, werde ich das Modell so optimiert halten. Wenn das Modell bereits in einer einfachen Isolation ausgeführt wird, machen wir es reicher, indem wir eine andere Klasse hinzufügen, die die Sammlung von Benutzerobjekten umgeht. Diese "Add-On" -Komponente ist nur ein klassischer Array-Wrapper, der zählbare, arrayAccess- und iteratoraggregate SPL-Schnittstellen implementiert:
<?php namespace ModelCollection;
use MapperUserCollectionInterface,
ModelUserInterface;
class UserCollection implements UserCollectionInterface
{
protected $users = array();
public function add(UserInterface $user) {
$this->offsetSet($user);
}
public function remove(UserInterface $user) {
$this->offsetUnset($user);
}
public function get($key) {
return $this->offsetGet($key);
}
public function exists($key) {
return $this->offsetExists($key);
}
public function clear() {
$this->users = array();
}
public function toArray() {
return $this->users;
}
public function count() {
return count($this->users);
}
public function offsetSet($key, $value) {
if (!$value instanceof UserInterface) {
throw new InvalidArgumentException(
"Could not add the user to the collection.");
}
if (!isset($key)) {
$this->users[] = $value;
}
else {
$this->users[$key] = $value;
}
}
public function offsetUnset($key) {
if ($key instanceof UserInterface) {
$this->users = array_filter($this->users,
function ($v) use ($key) {
return $v !== $key;
});
}
else if (isset($this->users[$key])) {
unset($this->users[$key]);
}
}
public function offsetGet($key) {
if (isset($this->users[$key])) {
return $this->users[$key];
}
}
public function offsetExists($key) {
return ($key instanceof UserInterface)
? array_search($key, $this->users)
: isset($this->users[$key]);
}
public function getIterator() {
return new ArrayIterator($this->users);
}
}ist in der Tat vollständig optional, diesen Satz von Arrays innerhalb der Grenzen des Modells zu legen, da die Verwendung eines normalen Arrays nahezu die gleichen Ergebnisse erzielen kann. In diesem Fall ist es jedoch einfacher, auf unabhängige Sammelklassen auf die aus der Datenbank extrahierte Benutzerobjekte über eine objektorientierte API zuzugreifen. In Anbetracht der Tatsache, dass das Domänenmodell die in der Infrastruktur eingereichte Speichermodell vollständig ignorieren muss, sollten wir eine Mapping -Schicht implementieren, die sie gut von der Datenbank trennt. Das Folgende sind die Elemente, die diese Ebene ausmachen:
<?php namespace Model;
interface UserInterface
{
public function setId($id);
public function getId();
public function setName($name);
public function getName();
public function setEmail($email);
public function getEmail();
public function setRole($role);
public function getRole();
}<?php namespace Model;
class User implements UserInterface
{
const ADMINISTRATOR_ROLE = "Administrator";
const GUEST_ROLE = "Guest";
protected $id;
protected $name;
protected $email;
protected $role;
public function __construct($name, $email, $role = self::GUEST_ROLE) {
$this->setName($name);
$this->setEmail($email);
$this->setRole($role);
}
public function setId($id) {
if ($this->id !== null) {
throw new BadMethodCallException(
"The ID for this user has been set already.");
}
if (!is_int($id) || $id throw new InvalidArgumentException(
"The user ID is invalid.");
}
$this->id = $id;
return $this;
}
public function getId() {
return $this->id;
}
public function setName($name) {
if (strlen($name) 30) {
throw new InvalidArgumentException(
"The user name is invalid.");
}
$this->name = htmlspecialchars(trim($name), ENT_QUOTES);
return $this;
}
public function getName() {
return $this->name;
}
public function setEmail($email) {
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException(
"The user email is invalid.");
}
$this->email = $email;
return $this;
}
public function getEmail() {
return $this->email;
}
public function setRole($role) {
if ($role !== self::ADMINISTRATOR_ROLE
&& $role !== self::GUEST_ROLE) {
throw new InvalidArgumentException(
"The user role is invalid.");
}
$this->role = $role;
return $this;
}
public function getRole() {
return $this->role;
}
}Unbox, die von UsMapper ausgeführte Aufgaben sind recht einfach und beschränkt sich darauf, einige allgemeine Finder aufzudecken, die dafür verantwortlich sind, Benutzer aus der Datenbank zu extrahieren und die entsprechende Entität über die Methode createUser () wieder aufzubauen. Wenn Sie sich zuvor in einige Mapper eingeteilt haben und sogar Ihr eigenes Mapping -Meisterwerk geschrieben haben, ist das oben genannte sicherlich leicht zu verstehen. Das einzige subtile Detail, das es wert ist, hervorzuheben, ist wahrscheinlich, dass die UserCollectionInterface in der Mapping -Schicht und nicht im Modell platziert wurde. Ich mache dies absichtlich, weil auf diese Weise die Abstraktion (Protokoll), von der die Benutzersammlung abhängt, explizit von einem UsMapper auf höherer Ebene deklariert und gehören, was mit dem durch das Prinzip der Abhängigkeitsinversion geförderten Leitfaden übereinstimmt. Wenn der bereits eingerichtete Mapper eingerichtet ist, können wir ihn direkt außerhalb der Box verwenden und einige Benutzerobjekte aus dem Speicher extrahieren, damit das Modell sofort hydratisiert werden kann. Dies scheint zwar auf den ersten Blick der richtige Weg zu sein, aber wir sind tatsächlich die Anwendungslogik mit unnötiger Infrastruktur verdorben, da Mapper tatsächlich Teil der Infrastruktur sind. Was ist, wenn es in Zukunft notwendig ist, Benutzerentitäten auf der Grundlage domänenspezifischer Bedingungen abzufragen (nicht nur häufige Bedingungen, die vom Finder des Mapper ausgesetzt sind)? In diesem Fall muss eine zusätzliche Ebene über der Mapping -Ebene platziert werden, die nicht nur eine höhere Datenzugriffsebene liefert, sondern auch den Abfragelogikblock durch einen einzelnen Punkt führt. Letztendlich ist das die enorme Menge an Vorteilen, die wir von Lagerung erwarten.
Implementieren Sie Benutzerlager
In einer Produktionsumgebung kann Wareehousing fast alles implementieren, was man sich auf seiner Oberfläche vorstellen kann, um die Illusion des Speichersatzes von aggregierten Wurzeln dem Modell auszusetzen. In diesem Fall können wir jedoch nicht so naiv erwarten, diesen teuren Luxus kostenlos zu genießen, da das von uns erstellte Lagerhaus eine eher künstliche Struktur sein wird, die für die Extraktion von Benutzern aus der Datenbank verantwortlich ist:
<?php namespace ModelCollection;
use MapperUserCollectionInterface,
ModelUserInterface;
class UserCollection implements UserCollectionInterface
{
protected $users = array();
public function add(UserInterface $user) {
$this->offsetSet($user);
}
public function remove(UserInterface $user) {
$this->offsetUnset($user);
}
public function get($key) {
return $this->offsetGet($key);
}
public function exists($key) {
return $this->offsetExists($key);
}
public function clear() {
$this->users = array();
}
public function toArray() {
return $this->users;
}
public function count() {
return count($this->users);
}
public function offsetSet($key, $value) {
if (!$value instanceof UserInterface) {
throw new InvalidArgumentException(
"Could not add the user to the collection.");
}
if (!isset($key)) {
$this->users[] = $value;
}
else {
$this->users[$key] = $value;
}
}
public function offsetUnset($key) {
if ($key instanceof UserInterface) {
$this->users = array_filter($this->users,
function ($v) use ($key) {
return $v !== $key;
});
}
else if (isset($this->users[$key])) {
unset($this->users[$key]);
}
}
public function offsetGet($key) {
if (isset($this->users[$key])) {
return $this->users[$key];
}
}
public function offsetExists($key) {
return ($key instanceof UserInterface)
? array_search($key, $this->users)
: isset($this->users[$key]);
}
public function getIterator() {
return new ArrayIterator($this->users);
}
}<?php namespace Mapper;
use ModelUserInterface;
interface UserCollectionInterface extends Countable, ArrayAccess, IteratorAggregate
{
public function add(UserInterface $user);
public function remove(UserInterface $user);
public function get($key);
public function exists($key);
public function clear();
public function toArray();
}<?php namespace Mapper;
use ModelRepositoryUserMapperInterface,
ModelUser;
class UserMapper implements UserMapperInterface
{
protected $entityTable = "users";
protected $collection;
public function __construct(DatabaseAdapterInterface $adapter, UserCollectionInterface $collection) {
$this->adapter = $adapter;
$this->collection = $collection;
}
public function fetchById($id) {
$this->adapter->select($this->entityTable,
array("id" => $id));
if (!$row = $this->adapter->fetch()) {
return null;
}
return $this->createUser($row);
}
public function fetchAll(array $conditions = array()) {
$this->adapter->select($this->entityTable, $conditions);
$rows = $this->adapter->fetchAll();
return $this->createUserCollection($rows);
}
protected function createUser(array $row) {
$user = new User($row["name"], $row["email"],
$row["role"]);
$user->setId($row["id"]);
return $user;
}
protected function createUserCollection(array $rows) {
$this->collection->clear();
if ($rows) {
foreach ($rows as $row) {
$this->collection[] = $this->createUser($row);
}
}
return $this->collection;
}
}Obwohl über einer ziemlich leichten Struktur die Implementierung von userRepository sehr intuitiv ist, da seine API es ihm ermöglicht, eine Sammlung von Benutzerobjekten aus einem Speicher zu extrahieren, der sich den feinen Prädikaten entspricht, die eng mit der Modellsprache verwandt sind. Darüber hinaus setzt das Repository in seinem aktuellen Zustand nur einige einfache Finder dem Client -Code aus, was wiederum die Funktionalität des Data Mapper zum Zugriff auf den Speicher verwendet. In einer realistischeren Umgebung sollte die Lagerung auch in der Lage sein, aggregierte Wurzeln zu bestehen. Wenn Sie die Methode Insert () oder eine andere ähnliche Methode zu UserRepository hinzufügen möchten, können Sie dies gerne tun. In beiden Fällen ist ein wirksamer Weg, um die tatsächlichen Vorteile der Verwendung von Lagern durch Beispiele zu erfassen,
<?php namespace Model;
interface UserInterface
{
public function setId($id);
public function getId();
public function setName($name);
public function getName();
public function setEmail($email);
public function getEmail();
public function setRole($role);
public function getRole();
}Wie bereits erwähnt, wechselt die Lagerung die Geschäftsbegriffe effektiv mit dem Kundencode (der sogenannten "universellen Sprache", die von Eric Evans in seinem Buch "Domain Driven Design") und nicht technische Begriffe auf niedrigeren Ebenen erstellt wurde. Im Gegensatz zur Unklarheit, die im Data Mapper -Finder vorhanden ist, beschreibt sich die Methode der Lagerung mit "Name", "E -Mail" und "Rolle", die zweifellos Teil der Eigenschaften der Modellierung von Benutzereinheiten sind. Diese feinere Datenabstraktion auf höherer Ebene und eine vollständige Anzahl von Funktionen, die bei der Einkapselung der Abfragelogik in komplexen Systemen erforderlich sind, sind zweifellos einer der überzeugendsten Gründe, warum Lagerheizungen bei mehrschichtigen Designs attraktiver sind. Natürlich besteht ein impliziter Kompromiss zwischen dem Aufwand, diese Vorteile im Voraus zu erhalten und zusätzliche Abstraktionsebenen bereitzustellen (die in einfacheren Anwendungen zu aufgebläht werden können).
Schlussfolgerung
Als Kernkonzepte im domänengesteuerten Design finden Sie Lagerung in Anwendungen, die in mehreren anderen Sprachen wie Java und C#geschrieben wurden, um nur einige zu nennen. In PHP sind sie jedoch noch relativ unbekannt und machen nur den ersten Schritt der Welt. Dennoch gibt es einige vertrauenswürdige Frameworks wie Flow3 und natürlich Doctrine 2.x, die Ihnen helfen können, das DDD -Paradigma zu übernehmen. Wie bei jedem vorhandenen Entwicklungsansatz müssen Sie keine Repositorys in Ihrer Anwendung verwenden oder sie sogar unnötig mit dem Konzepthaufen hinter DDD zerschlagen. Wenden Sie einfach den gesunden Menschenverstand an und wählen Sie sie nur aus, wenn Sie der Meinung sind, dass sie für Ihre Bedürfnisse geeignet sind. Es ist so einfach. Bilder von Chance Agrella / freerangestock.com
FAQs beim Umgang mit aggregierten Wurzelsammlungen (FAQ)
In Domain Driven Design (DDD) ist eine Aggregat -Wurzel eine Sammlung von zugehörigen Objekten, die als Einheit betrachtet werden. Diese Objekte werden durch Wurzeleinheiten zusammengebunden (auch als aggregierte Wurzeln bezeichnet). Die Aggregationswurzel behält die Konsistenz der Änderungen bei der Aggregation, indem externe Objekte verbieten, um Verweise auf ihre Mitglieder zu halten.
Der Hauptunterschied zwischen aggregierten Wurzeln und gewöhnlichen Einheiten ist ihre Verantwortung. Normale Entitäten verkapulieren Verhalten und Zustand, während die Aggregationswurzel auch die Integrität der gesamten Aggregation sorgt, indem sie den Zugriff auf ihre Mitglieder kontrolliert. Es ist das einzige Mitglied einer Aggregation, mit dem externe Objekte Verweise auf sie halten können.
Die Identifizierung der Aggregationswurzel erfordert ein tiefes Verständnis des Geschäftsbereichs. Es handelt sich normalerweise um eine hochrangige Entität mit einer globalen Identität und verkaps andere Entitäten und Wertobjekte. In der E-Commerce-Welt kann beispielsweise eine Bestellung eine aggregierte Wurzel sein, die Stellungen und Lieferinformationen zusammenfasst.
Verarbeitung einer Sammlung aggregierter Wurzeln kann eine Herausforderung sein. Es ist wichtig zu beachten, dass jede Aggregatwurzel eine Konsistenzgrenze ist. Daher sollte die Änderungen an einer Aggregatwurzel andere Aggregatwurzeln nicht beeinflussen. Bei der Verarbeitung einer Sammlung ist es daher normalerweise besser, jede Aggregatwurzel separat für die Konsistenz zu laden und zu bestehen.
Ja, eine aggregierte Wurzel kann auf eine andere Aggregat -Wurzel verweisen, sollte jedoch nur durch Identifizierung verwiesen werden. Dies bedeutet, dass es keinen direkten Hinweis auf ein anderes Aggregat -Root -Objekt, sondern seine ID enthalten sollte. Dies hilft, die Konsistenzgrenzen für jede Aggregat -Wurzel aufrechtzuerhalten.
In DDD bietet Warehousing Methoden zum Abrufen und Speichern von Aggregatwurzeln. Es wird den zugrunde liegenden Speichermechanismus abstrahiert, sodass das Domänenmodell die Details der Datenpersistenz ignorieren kann. Jede Aggregat -Wurzel hat normalerweise einen eigenen Speicher.
Aggregationwurzeln spielen eine entscheidende Rolle bei der Ausführung von Geschäftsregeln. Es stellt sicher, dass alle Änderungen an der Aggregation in einen gültigen Zustand gebracht werden. Dies bedeutet, dass alle Geschäftsregeln, die mehrere Entitäten oder Wertobjekte erstrecken, von der Gesamtwurzel erzwungen werden sollten.
Aggregationswurzeln helfen, die Komplexität in Domänenmodellen zu verringern, indem sie als Konsistenzgrenzen fungieren und den Zugriff auf ihre Mitglieder kontrollieren. Es vereinfacht das Modell, indem für jede Aggregation ein einzelner Interaktionspunkt bereitgestellt wird, wodurch das Verständnis des Systems einfacher wird.
Nein, die Aggregat -Wurzel sollte nicht Teil mehrerer Aggregate sein. Dies verstößt gegen die Konsistenzgrenzen von Aggregaten und kann zu Inkonsistenzen im Domänenmodell führen.
Verschiedene Strategien können verwendet werden, um mit Parallelitätsproblemen bei aggregierten Wurzeln wie optimistischen Schlössern oder pessimistischen Schlössern umzugehen. Die Wahl einer Richtlinie hängt von den spezifischen Anforderungen der Anwendung und der Art der Parallelitätsprobleme ab, mit denen Sie konfrontiert sind.
Diese überarbeitete Ausgabe behält die Originalbildformatierung und den Standort bei, skilaphrasen den Text, um Plagiate zu vermeiden, und hält die Kernbedeutung intakt.
Das obige ist der detaillierte Inhalt vonHandhabungssammlungen von aggregierten Wurzeln - dem Repository -Muster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
504 Gateway-Timeout – Ursachen und Lösungen
Wie viel entspricht Dimensity 9000 Snapdragon?
Vue allgemeine Anweisungen
So sortieren Sie in Excel
So berechnen Sie die Bearbeitungsgebühr für die Rückerstattung der Eisenbahn 12306
So lösen Sie das Problem eines ungültigen Datenbankobjektnamens
Was sind die Vorteile der Mongodb-Datenbank?
Orakel-Kobold
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
