Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Desarrollar patrones reutilizables
<a name="reusable-patterns-best-practices"></a>

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](https://refactoring.guru/design-patterns) en la documentación de Refactoring.Guru.

## Fábrica abstracta
<a name="abstract-factory"></a>

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](https://refactoring.guru/design-patterns/abstract-factory/typescript/example) la documentación de Refactoring.Guru.

En el siguiente ejemplo de código, se muestra cómo utilizar el patrón Fábrica abstracta para crear una fábrica de almacenamiento de Amazon Elastic Block Store (Amazon EBS).

```
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
<a name="chain-responsibility"></a>

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 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](https://refactoring.guru/design-patterns/chain-of-responsibility/typescript/example) 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);
    }
}
```