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:

<?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();
}

<?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;
    }
}

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:

<?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();
}

<?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;
    }
}

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

<?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></br>";

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

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

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.

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!