Introduction aux modèles de conception créative

Introduction

En génie logiciel, un modèle de conception décrit une solution établie aux problèmes les plus fréquemment rencontrés dans le logiciel conception. Il représente les meilleures pratiques développées sur une longue période par essais et erreurs par des développeurs de logiciels expérimentés.

Design Patterns a gagné en popularité après que le livre Design Patterns: Elements of Reusable Object-Oriented Software a été publié en 1994 par Erich Gamma , John Vlissides, Ralph Johnson et Richard Helm (également connu sous le nom de Gang of Four ou GoF).

Dans cet article, nous allons explorer les modèles de conception créative et leurs types. Nous examinerons également certains des exemples de code et discutez des situations dans lesquelles ces modèles correspondent à notre conception.

Modèles de conception créative

Les modèles de conception créative sont concernés par la manière dont les objets sont créés . Ils réduisent les complexités et l’instabilité en créant des objets de manière contrôlée.

Le nouvel opérateur est souvent considéré comme dangereux car il disperse les objets dans toute l’application. Avec le temps, il peut devenir difficile de changer une implémentation car les classes deviennent étroitement couplées.

Les modèles de conception créative résolvent ce problème en dissociant entièrement le client du processus d’initialisation réel.

Dans cet article , nous allons discuter de quatre types de modèles de conception créative:

1. Singleton – S’assure qu’au plus une seule instance d’un objet existe dans l’application
2. Méthode d’usine – Crée des objets de plusieurs classes associées sans spécifier l’objet exact à créer
3. Abstract Factory – Crée des familles d’objets dépendants associés
4. Builder – Construit des objets complexes en utilisant une approche étape par étape

Parlons maintenant de chacun de ces modèles en détail.

Modèle de conception singleton

Le modèle de conception Singleton vise à conserver une vérification de l’initialisation des objets d’une classe particulière en s’assurant qu’une seule instance de l’objet existe dans toute la machine virtuelle Java.

Une classe Singleton fournit également un point d’accès global unique à l’objet de sorte que chaque appel ultérieur au point d’accès ne renvoie que cet objet particulier.

3.1. Exemple de modèle Singleton

Bien que le modèle Singleton ait été introduit par GoF, l’implémentation d’origine est connue pour être problématique dans les scénarios multithread.

Alors ici, nous  » Nous allons suivre une approche plus optimale qui utilise une classe interne statique:

Ici, nous avons créé une classe interne statique qui contient l’instance de la classe Singleton. Il crée l’instance uniquement lorsque quelqu’un appelle la méthode getInstance () et non lorsque la classe externe est chargée.

C’est une approche largement utilisée pour une classe Singleton car elle ne nécessite pas de synchronisation, est thread-safe , applique l’initialisation paresseuse et a comparativement moins de passe-partout.

Notez également que le constructeur a le modificateur d’accès privé. Ceci est une exigence pour créer un Singleton car un constructeur public signifierait que n’importe qui pourrait y accéder et commencer à créer de nouvelles instances.

N’oubliez pas qu’il ne s’agit pas de l’implémentation GoF d’origine. Pour la version originale, visitez ce lié à l’article de Baeldung sur les singletons en Java.

3.2. Quand utiliser Singleton Design Pattern

• Pour les ressources coûteuses à créer (comme la base de données objets de connexion)
• Il est recommandé de conserver tous les enregistreurs en tant que singletons, ce qui augmente les performances
• Classes qui donnent accès aux paramètres de configuration de l’application
• Classes qui contiennent des ressources accessibles en mode partagé

Modèle de conception de méthode d’usine

Le modèle de conception d’usine ou le modèle de conception de méthode d’usine est l’un des les modèles de conception les plus utilisés en Java.

Selon le GoF, ce modèle «définit une interface pour créer un objet, mais laisse les sous-classes décider quelle classe instan tiate. La méthode Factory permet à une classe de différer l’instanciation aux sous-classes ».

Ce modèle délègue la responsabilité d’initialiser une classe du client à une classe d’usine particulière en créant un type de constructeur virtuel.

Pour y parvenir, nous nous appuyons sur une usine qui nous fournit les objets, cachant les détails d’implémentation réels. Les objets créés sont accessibles via une interface commune.

4.1. Exemple de modèle de conception de méthode d’usine

Dans cet exemple, nous allons créer une interface Polygon qui sera implémentée par plusieurs classes concrètes. Une PolygonFactory sera utilisée pour récupérer les objets de cette famille :

Créons d’abord l’interface Polygon:

Ensuite, nous allons créer quelques implémentations comme Square, Triangle, etc. qui implémentent cette interface et retournent un objet de type Polygon.

Nous pouvons maintenant créer une fabrique qui prend le nombre de côtés comme argument et renvoie l’implémentation appropriée de cette interface:

Remarquez comment le client peut compter sur cette fabrique pour nous donner un Polygone approprié, sans avoir à initialiser l’objet directement.

4.2. Quand utiliser le modèle de conception de méthode d’usine

• Quand l’implémentation d’une interface ou d’une classe abstraite est censée changer fréquemment
• Quand l’implémentation actuelle ne peut pas accueillir confortablement un nouveau changement
• Lorsque le processus d’initialisation est relativement simple et que le constructeur ne nécessite qu’une poignée de paramètres

Abstract Factory Design Pattern

Dans la section précédente, nous avons vu comment le modèle de conception de la méthode d’usine pouvait être utilisé pour créer des objets liés à une seule famille.

En revanche, le modèle de conception d’usine abstraite est utilisé pour créer des familles d’objets liés ou dépendants. On l’appelle aussi parfois une usine d’usines.

Pour une explication détaillée, consultez notre didacticiel sur l’usine abstraite.

Modèle de conception de constructeur

Le modèle de conception Builder est un autre modèle de création conçu pour gérer la construction d’objets relativement complexes.

Lorsque la complexité de la création d’un objet augmente, le modèle Builder peut séparer le processus d’instanciation en utilisant un autre objet (un générateur) pour construire l’objet.

Ce générateur peut ensuite être utilisé pour créer de nombreuses autres représentations similaires en utilisant une approche simple étape par étape.

6.1. Modèle de générateur Exemple

Le modèle de conception Builder original introduit par GoF se concentre sur l’abstraction et est très bon lorsqu’il s’agit d’objets complexes, cependant, la conception est un peu compliquée.

Joshua Bloch, dans son livre Effective Java, a présenté une version améliorée du modèle de générateur qui est propre, hautement lisible (car il utilise conception fluide) et facile à utiliser du point de vue du client. Dans cet exemple, nous allons discuter de cette version.

Cet exemple n’a qu’une seule classe, BankAccount qui contient un générateur en tant que classe interne statique:

Notez que tous les modificateurs d’accès sur les champs sont déclarés privés car nous ne voulons pas que les objets externes y accèdent directement.

Le constructeur est également privé de sorte que seul le constructeur affecté à ceci la classe peut y accéder. Toutes les propriétés définies dans le constructeur sont extraites de l’objet builder que nous fournissons comme argument.

Nous « avons défini BankAccountBuilder dans une classe interne statique:

Notez que nous « avons déclaré le même ensemble de champs que la classe externe contient. Tous les champs obligatoires sont requis comme arguments pour le constructeur de la classe interne tandis que les champs facultatifs restants peuvent être spécifiés à l’aide des méthodes setter.

Cette implémentation prend également en charge l’approche de conception fluide en demandant aux méthodes setter de renvoyer le générateur objet.

Enfin, la méthode de construction appelle le constructeur privé de la classe externe et se passe comme argument. Le BankAccount retourné sera instancié avec les paramètres définis par BankAccountBuilder.

Voyons un exemple rapide du modèle de générateur en action:

6.2. Quand utiliser un modèle de générateur

1. Lorsque le processus de création d’un objet est extrêmement complexe, avec de nombreux paramètres obligatoires et facultatifs
2. Quand un l’augmentation du nombre de paramètres du constructeur conduit à une longue liste de constructeurs
3. Lorsque le client attend des représentations différentes pour l’objet qui « est construit

Conclusion

Dans cet article, nous avons découvert les modèles de conception créative en Java. Nous avons également discuté de leurs quatre types différents, à savoir, Singleton, Factory Method, Abstract Factory et Builder Pattern, leurs avantages, exemples et quand faut-il nous les utilisons.

Comme toujours, les extraits de code complets sont disponibles over sur GitHub.