As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Desenvolva padrões reutilizáveis
<a name="reusable-patterns-best-practices"></a>

Os padrões de design de software são soluções reutilizáveis para problemas comuns no desenvolvimento de software. Eles atuam como um guia ou paradigma para ajudar os engenheiros de software a criar produtos que sigam as práticas recomendadas. Esta seção fornece uma visão geral de dois padrões reutilizáveis que você pode usar em sua AWS CDK base de código: o padrão Abstract Factory e o padrão Chain of Responsibility. É possível usar cada padrão como um modelo e personalizá-lo para o problema de design específico no código. Para obter mais informações sobre padrões de design, consulte [Padrões de design](https://refactoring.guru/design-patterns) na documentação do Refactoring.Guru.

## Abstract Factory
<a name="abstract-factory"></a>

O padrão Abstract Factory fornece interfaces para a criação de famílias de objetos relacionados ou dependentes sem especificar suas classes concretas. Esse padrão se aplica aos seguintes casos de uso:
+ Quando o cliente é independente de como você cria e compõe os objetos no sistema
+ Quando o sistema consiste em várias famílias de objetos e essas famílias são projetadas para serem usadas juntas
+ Quando é necessário ter um valor em tempo de execução para construir uma dependência específica

Para obter mais informações sobre o padrão Abstract Factory, consulte [Abstract Factory TypeScript na documentação](https://refactoring.guru/design-patterns/abstract-factory/typescript/example) do Refactoring.Guru.

O exemplo de código a seguir mostra como o padrão Abstract Factory pode ser usado para criar uma fábrica de armazenamento do 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();
```

## Chain of Responsibility
<a name="chain-responsibility"></a>

O Chain of Responsibility é um padrão de design comportamental que permite passar uma solicitação ao longo da cadeia de manipuladores em potencial até que um deles processe a solicitação. O padrão Chain of Responsibility se aplica aos seguintes casos de uso:
+ Quando vários objetos determinados em tempo de execução são candidatos para lidar com uma solicitação
+ Quando você não quiser especificar manipuladores explicitamente em seu código
+ Quando você deseja emitir uma solicitação para um dos vários objetos sem especificar explicitamente o receptor

Para obter mais informações sobre o padrão da Cadeia de Responsabilidade, consulte [Cadeia de Responsabilidade TypeScript na documentação](https://refactoring.guru/design-patterns/chain-of-responsibility/typescript/example) do Refactoring.Guru.

O código a seguir mostra um exemplo de como o padrão Chain of Responsibility é usado para criar uma série de ações necessárias para concluir a tarefa.

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