Entwickeln Sie wiederverwendbare Muster

Softwaredesignmuster sind wiederverwendbare Lösungen für häufig auftretende Probleme in der Softwareentwicklung. Sie dienen als Leitfaden oder Paradigma, um Softwareingenieuren dabei zu helfen, Produkte zu entwickeln, die bewährten Methoden folgen. Dieser Abschnitt bietet einen Überblick über zwei wiederverwendbare Muster, die Sie in Ihrer AWS CDK Codebasis verwenden können: das Abstract Factory-Muster und das Chain-of-Responsibility-Muster. Sie können jedes Muster als Vorlage verwenden und es an das jeweilige Designproblem in Ihrem Code anpassen. Weitere Informationen zu Entwurfsmustern finden Sie unter Entwurfsmuster in der Refactoring.Guru-Dokumentation.

Abstract Factory

Das Abstract-Factory-Muster bietet Schnittstellen zum Erstellen von Familien verwandter oder abhängiger Objekte, ohne deren konkrete Klassen anzugeben. Dieses Muster gilt für die folgenden Anwendungsfälle:

• Wenn der Client unabhängig davon ist, wie Sie die Objekte im System erstellen und zusammenstellen

• Wenn das System aus mehreren Objektfamilien besteht und diese Familien so konzipiert sind, dass sie zusammen verwendet werden können

• Wenn Sie einen Laufzeitwert benötigen, um eine bestimmte Abhängigkeit zu erstellen

Weitere Informationen zum Abstract Factory-Muster finden Sie unter Abstract Factory TypeScript in der Refactoring.Guru-Dokumentation.

Das folgende Codebeispiel zeigt, wie das Abstract Factory-Muster verwendet werden kann, um eine Amazon Elastic Block Store (AmazonEBS) -Speicherfabrik zu erstellen.

abstract class EBSStorage {
    abstract initialize(): void; 
}

class ProductEbs extends EBSStorage{
    constructor(value: String) {
        super();
        console.log(value);
    }
    initialize(): void {}
}

abstract class AbstractFactory {
    abstract createEbs(): EBSStorage
}

class EbsFactory extends AbstractFactory {
    createEbs(): ProductEbs{
        return new ProductEbs('EBS Created.')
    }
}

const ebs = new EbsFactory();
ebs.createEbs();

Kette der Verantwortung

Die Kette der Verantwortung ist ein Verhaltensmuster, das es Ihnen ermöglicht, eine Anfrage entlang der Kette potenzieller Bearbeiter weiterzuleiten, bis einer von ihnen die Anfrage bearbeitet. Das Kette-der-Verantwortung-Muster gilt für die folgenden Anwendungsfälle:

• Wenn mehrere Objekte, die zur Laufzeit bestimmt wurden, für die Bearbeitung einer Anfrage in Frage kommen

• Wenn Sie Handler nicht explizit in Ihrem Code angeben möchten

• Wenn Sie eine Anfrage an eines von mehreren Objekten stellen möchten, ohne den Empfänger explizit anzugeben

Weitere Informationen zum Muster der Verantwortungskette finden Sie unter Verantwortungskette TypeScript in der Refactoring.Guru-Dokumentation.

Der folgende Code zeigt ein Beispiel dafür, wie das Kette-der-Verantwortung-Muster verwendet wird, um eine Reihe von Aktionen zu erstellen, die für die Ausführung der Aufgabe erforderlich sind.

interface Handler {
    setNext(handler: Handler): Handler;
    handle(request: string): string;
}
abstract class AbstractHandler implements Handler
{
    private nextHandler: Handler;
    public setNext(handler: Handler): Handler {
        this.nextHandler = handler;
        return handler;
    }

    public handle(request: string): string {
        if (this.nextHandler) {
            return this.nextHandler.handle(request);
        }
        return '';
    }
}

class KMSHandler extends AbstractHandler {
    public handle(request: string): string {
        return super.handle(request);
    }
}