Développer des modèles réutilisables - AWS Conseils prescriptifs

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Développer des modèles réutilisables

Les modèles de conception logicielle sont des solutions réutilisables aux problèmes courants du développement logiciel. Ils servent de guide ou de paradigme pour aider les ingénieurs logiciels à créer des produits conformes aux bonnes pratiques. Cette section fournit un aperçu de deux modèles réutilisables que vous pouvez utiliser dans votre AWS CDK base de code : le modèle Abstract Factory et le modèle Chain of Responsibility. Vous pouvez utiliser chaque modèle comme plan et le personnaliser en fonction du problème de conception particulier de votre code. Pour obtenir plus d'informations sur les modèles de conception, veuillez consulter Design Patterns dans la documentation de Refactoring.Guru.

Abstract Factory

Le modèle Abstract Factory propose des interfaces permettant de créer des familles d'objets associés ou dépendants sans spécifier leurs classes concrètes. Ce modèle s'applique aux cas d'utilisation suivants :

  • Lorsque le client est indépendant de la façon dont vous créez et composez les objets dans le système.

  • Lorsque le système est composé de plusieurs familles d'objets et que ces familles sont conçues pour être utilisées ensemble.

  • Lorsque vous devez disposer d'une valeur d'exécution pour construire une dépendance particulière.

Pour plus d'informations sur le modèle Abstract Factory, consultez Abstract Factory TypeScript dans la documentation de Refactoring.Guru.

L'exemple de code suivant montre comment le modèle Abstract Factory peut être utilisé pour créer une usine de stockage 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

Chain of Responsibility est un modèle de conception comportementale qui vous permet de transmettre une demande à la chaîne des gestionnaires potentiels jusqu'à ce que l'un d'eux la traite. Le modèle Chain of Responsibility s'applique aux cas d'utilisation suivants :

  • Lorsque plusieurs objets, déterminés lors de l'exécution, sont candidats pour traiter une demande.

  • Lorsque vous ne souhaitez pas spécifier de gestionnaires explicitement dans votre code

  • Lorsque vous souhaitez envoyer une demande à l'un des nombreux objets sans spécifier explicitement le destinataire.

Pour plus d'informations sur le modèle de chaîne de responsabilité, consultez la section Chaîne de responsabilité TypeScript dans la documentation de Refactoring.Guru.

Le code suivant montre un exemple de la manière dont le modèle Chain of Responsibility est utilisé pour générer une série d'actions nécessaires à l'exécution de la tâche.

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