Das Layer-Supertyp-Muster: Einkapseln der gemeinsamen Implementierung in mehrstufigen Systemen

Kernpunkte

• Layer-Supertyp-Modus ist in mehrschichtigen Systemen von entscheidender Bedeutung und kann gemeinsame Implementierungen in verschiedenen Klassen einkapseln, wodurch die Wiederverwendung und Verringerung der Duplikation der Code erleichtert wird.
• Implementieren des Layer -Supertyp -Musters beinhaltet das Erstellen einer gemeinsamen Basisklasse, die öffentliche Logik und Eigenschaften abstrahiert und sich dann um eine spezifischere Unterklasse erstreckt.
• Dieser Modus hilft dabei, eine klarere Codearchitektur aufrechtzuerhalten, da er die Änderung der gemeinsamen Funktionalität an einem Ort ermöglicht und so die Wartbarkeit und Skalierbarkeit verbessert.
• Das Schicht-Hypertyp-Muster vereinfacht nicht nur die Codebasis, sondern stimmt auch gut mit dem Prinzip der einzelnen Verantwortung überein, da es das öffentliche Verhalten vom klassenspezifischen Verhalten trennt.
• Während dieses Muster viele Vorteile bei der Reduzierung des Boilerplate -Code und des redundanten Codes bietet, muss es mit Vorsicht angewendet werden, um zu vermeiden, dass zu komplexe oder große Superklassenstrukturen schwierig zu verwalten sein können.

Vererbung als einer der Eckpfeiler der objektorientierten Programmierung ist wie ein zweischneidiges Schwert. System. Obwohl es viele Fallstricke in der Vererbung gibt, können die meisten durch rationale und mäßige Verwendung gemindert werden. Die Wiederverwendung von Code ist die Grundursache für die Vererbung. Die Vererbung bietet eine einfache Möglichkeit, eine große Anzahl von semantisch miteinander verbundenen Objekten ohne Duplikationscode zu generieren. Sein Konzept ist sehr einfach, aber leistungsfähig: Stellen Sie zuerst so viel Logik wie möglich in die Grenzen des Basistyps (normalerweise abstrakte Klassen, aber auch konkrete Klassen) und starten Sie dann raffinierte Subtypen entsprechend spezifischere Bedürfnisse. Dieser Prozess wird normalerweise auf "pro Schicht" durchgeführt, wodurch jede Schicht ihren eigenen Supertypen bereitgestellt wird, dessen Kernfunktionen verfeinert und wiederum von den entsprechenden Subtypen erweitert werden. Es überrascht nicht, dass diese doppelte Kapselung/abgeleitete Schleife einem Entwurfsmuster namens "Layer Supertype" folgt (ja, es hat einen echten akademischen Namen, wenn auch ein bisschen naiv). In den nächsten Zeilen werde ich mich in interner Funktionen befassen und Sie können sehen, wie einfach es ist, seine Funktionalität mit dem Domänenmodell zu verbinden.

SUPER -TYPE -Anforderungen auf Stufe - definieren aufgeblähtes Domänenmodell

Es kann gesagt werden, dass Schicht -Supertypen die natürliche und selektive Entwicklung des "gemeinsamen" Basistyps sind, mit der Ausnahme, dass letztere im Bereich einer bestimmten Schicht existiert. Dies spielt eine wichtige Rolle beim mehrschichtigen Design, bei dem die Verwendung von Super-Typ-Funktionen häufig eine notwendige Anforderung ist, nicht nur eine willkürliche Entscheidung. Im Allgemeinen ist der effektivste Weg, um die Praktikabilität dieses Musters zu verstehen, anhand einiger praktischer Beispiele. Nehmen wir also an, wir müssen ein einfaches Domänenmodell von Grund auf erstellen, um einige grundlegende Interaktionen zwischen einigen Blog -Posts und ihren entsprechenden Kommentaren zu definieren. Grob gesagt kann das Modell leicht als Anämieschicht umrissen werden, die nur wenige Skelettklassen zum Modellieren von Artikeln und Kommentaren enthalten. Die erste Domänenklasse und ihr Vertrag können so aussehen:

<code class="language-php"><?php namespace Model;

interface PostInterface
{
    public function setId($id);
    public function getId();

    public function setTitle($title);
    public function getTitle();

    public function setContent($content);
    public function getContent();

    public function setComment(CommentInterface $comment);
    public function setComments(array $comments);
    public function getComments();
}</code>

<code class="language-php"><?php namespace Model;

class Post implements PostInterface
{
    protected $id;
    protected $title;
    protected $content;
    protected $comments = array();

    public function __construct($title, $content, array $comments = array()) {
        $this->setTitle($title);
        $this->setContent($content);
        if (!empty($comments)) {
           $this->setComments($comments); 
        }
    }

    public function setId($id) {
        if ($this->id !== null) {
            throw new BadMethodCallException(
                "The ID for this post has been set already.");
        }
        if (!is_int($id) || $id             throw new InvalidArgumentException(
                "The post ID is invalid.");
        }
        $this->id = $id;
        return $this;
    }

    public function getId() {
        return $this->id;
    }

    public function setTitle($title) {
        if (!is_string($title) 
            || strlen($title)             || strlen($title) > 100) {
            throw new InvalidArgumentException(
                "The post title is invalid.");
        }
        $this->title = htmlspecialchars(trim($title),
            ENT_QUOTES);
        return $this;
    }

    public function getTitle() {
        return $this->title;
    }

    public function setContent($content) {
        if (!is_string($content) || strlen($content)             throw new InvalidArgumentException(
                "The post content is invalid.");
        }
        $this->content = htmlspecialchars(trim($content),
            ENT_QUOTES);
        return $this;
    }

    public function getContent() {
        return $this->content;
    }

    public function setComment(CommentInterface $comment) {
        $this->comments[] = $comment;
        return $this;
    }

    public function setComments(array $comments) {
        foreach ($comments as $comment) {
            $this->setComment($comment);
        }
        return $this;
    }

    public function getComments() {
        return $this->comments;
    }
}</code>

Der Treiber der Postklasse ist eine einfache Logik, die darauf hinausgeht, die Daten und das Verhalten einiger grundlegender Posteinträge zu definieren. Es sollte leicht zu verstehen sein. Machen wir das Modell nun ein wenig dicker, indem wir eine Klasse hinzuzufügen, in der Kommentare generiert werden, die mit einem bestimmten Blogeintrag zugeordnet sind. Der Vertrag und seine Umsetzung sind wie folgt:

<code class="language-php"><?php namespace Model;

interface CommentInterface
{
    public function setId($id);
    public function getId();

    public function setContent($content);
    public function getContent();

    public function setAuthor($author);
    public function getAuthor();
}</code>

<code class="language-php"><?php namespace Model;

class Comment implements CommentInterface
{
    protected $id;
    protected $content;
    protected $author;

    public function __construct($content, $author) {
        $this->setContent($content);
        $this->setAuthor($author);
    }

    public function setId($id) {
        if ($this->id !== null) {
            throw new BadMethodCallException(
                "The ID for this comment has been set already.");
        }
        if (!is_int($id) || $id             throw new InvalidArgumentException(
                "The comment ID is invalid.");
        }
        $this->id = $id;
        return $this;
    }

    public function getId() {
        return $this->id;
    }

    public function setContent($content) {
        if (!is_string($content) || strlen($content)             throw new InvalidArgumentException(
                "The content of the comment is invalid.");
        }
        $this->content = htmlspecialchars(trim($content),
            ENT_QUOTES);
        return $this;
    }

    public function getContent() {
        return $this->content;
    }

    public function setAuthor($author) {
        if (!is_string($author) || strlen($author)             throw new InvalidArgumentException(
                "The author is invalid.");
        }
        $this->author = $author;
        return $this;
    }

    public function getAuthor() {
        return $this->author;
    }
}</code>

Wie Beitrag ist die Kommentarfeldklasse einfach. Aber jetzt können wir mit diesen beiden Klassen das Modell verwenden. Zum Beispiel:

<code class="language-php"><?php use LibraryLoaderAutoloader,   
    ModelPost,
    ModelComment;

require_once __DIR__ . "/Library/Loader/Autoloader.php";
$autoloader = new Autoloader;
$autoloader->register();

$post = new Post(
    "A sample post.",
    "This is the content of the post."
);

$post->setComments(array(
    new Comment(
        "One banal comment for the previous post.",
        "A fictional commenter"),
    new Comment(
        "Yet another banal comment for the previous post.",
        "A fictional commenter")
));

echo $post->getTitle() . " " . $post->getContent() . "<br>";

foreach ($post->getComments() as $comment) {
    echo $comment->getContent() . " " . $comment->getAuthor() .
        "<br>";
}</code>

Dies ist in der Tat so effektiv wie Charme! Die Verwendung dieses Modells ist ein ziemlich einfacher Prozess, bei dem Sie zuerst einige Postobjekte erstellen und dann mit relevanten Kommentaren bevölkern müssen. Ja, das Leben ist süß und schön. OK, so weit, aber es kann sicherlich besser sein! Ich versuche nicht, die Magie eines so wunderbaren Moments zu zerstören, aber ich muss zugeben, dass ich jedes Mal, wenn ich die Implementierung von Post- und Kommentierungskursen sehe, eine leichte Kälte verspüre. Obwohl dies kein ernstes Problem an sich ist, zeigen einige Methoden (wie setID () und setContent ()) typische Symptome einer Code -Duplikation. Aufgrund einiger logischer Probleme ist die Lösung dieses Problems ohne Nachlässigkeit nicht so intuitiv, wie es auf den ersten Blick erscheinen mag. Obwohl sie semantische Beziehungen zueinander haben, modelliert jede Klasse tatsächlich verschiedene Arten von Objekten. Zweitens implementieren sie verschiedene Schnittstellen, was bedeutet, dass es schwierig ist, die Logik abstrahieren, ohne mit einer ungeschickten Hierarchie zu enden, in der die Bedingung "is-a" niemals zutrifft. Insbesondere in diesem Fall können wir einen entspannteren Ansatz verfolgen und Post und Kommentare als Subtyp des hoch allgemeinen Abstractentity -Supertyps behandeln. Dabei wäre es sehr einfach, eine gemeinsame Implementierung innerhalb der Grenzen einer abstrakten Klasse zu platzieren, wodurch die Definition von Subtypen optimierter wird. Da der gesamte Abstraktionsprozess nur in der Domänenschicht stattfindet, wird die hypothetische Abstractentity als ... ja, Sie haben es erraten, ein Schicht -Supertyp. Einfach, aber gut, oder?

(Der verbleibende Code und die restliche Erläuterung werden hier aufgrund von Platzbeschränkungen weggelassen. Beachten Erstellen Sie AbstractEntity Klasse, um den doppelten Code in den Klassen Post und Comment zu extrahieren, wodurch die Code -Redundanz reduziert und die Wartbarkeit verbessert wird

Zusammenfassung

Obwohl die Vererbung oft als Mechanismus zur Überschätzung und Missbrauch angesehen wird, hoffe ich, dass nur sehr wenige Menschen nicht einverstanden sind, dass die Erbe ein leistungsstarker Mechanismus ist, der bei ordentlicher Verwendung in einem mehrschichtigen System funktioniert, verhindert die Doppelarbeit von Code. Die Verwendung eines einfachen Musters wie Layer SuperType ist ein Beispiel für die vielen faszinierenden Vorteile, die die Vererbung beim Erstellen von Subtypen bietet, die eine große Anzahl von Kesselplatten -Implementierungen miteinander teilen.

(Der FAQ -Teil des Originaltextes wird auch hier weggelassen, da sein Inhalt eine Wiederholung und Erweiterung der Kernideen des Artikels ist. Übersetzen aller Inhalte macht die Antwort zu lang. Die Kernideen waren. vollständig in der obigen Übersetzung reflektiert.)

Das obige ist der detaillierte Inhalt vonDas Layer-Supertyp-Muster: Einkapseln der gemeinsamen Implementierung in mehrstufigen Systemen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!