Sviluppo di pattern riutilizzabili

I pattern di progettazione software sono soluzioni riutilizzabili a problemi comuni nello sviluppo di software. Fungono da guida o paradigma per aiutare gli ingegneri di software a creare prodotti che seguano le best practice. Questa sezione fornisce una panoramica di due modelli riutilizzabili che è possibile utilizzare nella propria AWS CDK codebase: il pattern Abstract Factory e il pattern Chain of Responsibility. Puoi utilizzare ciascun pattern come schema e personalizzarlo per il problema di progettazione specifico del tuo codice. Per ulteriori informazioni sui pattern di progettazione, consulta Pattern di progettazione nella documentazione di Refactoring.Guru.

Abstract Factory

Il pattern Abstract Factory fornisce interfacce per creare famiglie di oggetti correlati o dipendenti senza specificarne le classi concrete. Questo pattern è valido per i seguenti casi d'uso:

• Quando il client è indipendente dal modo in cui crei e componi gli oggetti nel sistema

• Quando il sistema è composto da più famiglie di oggetti progettate per essere utilizzate insieme

• Quando è necessario disporre di un valore di runtime per realizzare una particolare dipendenza

Per ulteriori informazioni sul pattern Abstract Factory, vedete Abstract Factory TypeScript nella documentazione di Refactoring.Guru.

Il seguente esempio di codice mostra come utilizzare il pattern Abstract Factory per creare uno storage factory Amazon Elastic Block Store (AmazonEBS).

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

Chain of Responsibility

Chain of Responsibility è un pattern di progettazione comportamentale che consente di inoltrare una richiesta lungo la catena di potenziali gestori finché uno di essi non la gestirà. Il pattern Chain of Responsibility è valido per i seguenti casi d'uso:

• Quando più oggetti, determinati durante il runtime, sono candidati alla gestione di una richiesta

• Quando non desideri specificare i gestori in modo esplicito nel codice

• Quando desideri inviare una richiesta a uno di più oggetti senza specificare in modo esplicito il destinatario

Per ulteriori informazioni sul modello Chain of Responsibility, consulta Chain of Responsibility TypeScript nella documentazione di Refactoring.Guru.

Il codice seguente mostra un esempio di come il pattern Chain of Responsibility viene utilizzato per creare una serie di azioni necessarie per completare l'attività.

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