Desarrollar patrones reutilizables

Los patrones de diseño de software son soluciones reutilizables para problemas comunes en el desarrollo de software. Actúan como una guía o un paradigma para ayudar a los ingenieros de software a crear productos que sigan las prácticas recomendadas. Esta sección proporciona una descripción general de dos patrones reutilizables que puedes usar en tu AWS CDK base de código: el patrón Abstract Factory y el patrón Chain of Responsibility. Puede utilizar cada patrón como esquema y personalizarlo para el problema de diseño concreto de su código. Para obtener más información sobre los patrones de diseño, consulte Patrones de diseño en la documentación de Refactoring.Guru.

Fábrica abstracta

El patrón Fábrica abstracta brinda interfaces para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas. Este patrón se aplica a los siguientes casos de uso:

• Cuando el cliente es independiente de la forma en que se crean y componen los objetos del sistema

• Cuando el sistema consta de varias familias de objetos y estas familias se han diseñado para utilizarse juntas

• Cuando debe tener un valor de tiempo de ejecución para crear una dependencia determinada

Para obtener más información sobre el patrón Abstract Factory, consulta Abstract Factory TypeScript en la documentación de Refactoring.Guru.

El siguiente ejemplo de código muestra cómo se puede utilizar el patrón Abstract Factory para crear una fábrica de almacenamiento de 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();

Cadena de responsabilidades

La Cadena de responsabilidades es un patrón de diseño de comportamientos que permite transmitir una solicitud a lo largo de la cadena de posibles controladores hasta que uno de ellos gestione la solicitud. El patrón Cadena de responsabilidades se aplica a los siguientes casos de uso:

• Cuando varios objetos, determinados en el tiempo de ejecución, son candidatos para gestionar una solicitud

• Cuando no desee especificar los controladores de forma explícita en su código

• Cuando quiere enviar una solicitud a uno de varios objetos sin especificar el receptor de forma explícita

Para obtener más información sobre el patrón de cadena de responsabilidad, consulte Cadena de responsabilidad TypeScript en la documentación de Refactoring.Guru.

En el siguiente código, se muestra un ejemplo de cómo se utiliza el patrón Cadena de responsabilidades a fin de crear una serie de acciones necesarias para completar la tarea.

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