logo

TechCodeview

Modèle de conception de méthode d'usine en Java

C'est un modèle de conception créative qui parle de la création d'un objet. Le modèle de conception d'usine dit de définir une interface (une interface Java ou une classe abstraite) pour créer l'objet et de laisser les sous-classes décider quelle classe instancier.

méthode d'usine



Sujets importants pour le modèle de conception de méthode Factory en Java

Qu’est-ce que le modèle de conception de méthode d’usine en Java ?

Le modèle de conception de méthode d'usine définit une interface pour créer un objet, mais laisse la sous-classe décider quelle classe instancier. La méthode Factory permet à une classe de différer l’instanciation vers la sous-classe.

Qu'est-ce que le modèle de conception de méthode d'usine



Ci-dessous l'explication de l'image ci-dessus :

  • La méthode factory dans l'interface permet à une classe de différer l'instanciation à une ou plusieurs sous-classes concrètes.
  • Puisque ces modèles de conception parlent de l’instanciation d’un objet, ils entrent dans la catégorie des modèles de conception créationnels.
  • Si nous remarquons le nom Méthode d'usine , cela signifie qu'il existe une méthode qui est une usine, et en général, les usines sont impliquées dans des tâches de création et ici, avec cela, un objet est créé.
  • C'est l'un des meilleurs moyens de créer un objet où la logique de création d'objet est cachée au client. Voyons maintenant la mise en œuvre.

Quand utiliser le modèle de conception de méthode d’usine en Java ?

Le modèle de conception de méthode d'usine peut être utilisé en Java dans les cas suivants :

  • Une classe ne peut pas prédire le type d’objets qu’elle doit créer.
  • Une classe souhaite que ses sous-classes spécifient les objets qu'elle crée.
  • Les classes délèguent la responsabilité à l’une des multiples sous-classes auxiliaires, et votre objectif est de conserver les informations sur la sous-classe auxiliaire qui est le délégué dans une portée ou un emplacement spécifique.

Composants clés du modèle de conception de méthode d'usine

Composant clé du modèle de conception de méthode d'usine en Java



Produit

  • C'est une classe ou une interface abstraite qui définit les opérations communes pour les objets que l'usine va créer.
  • Les produits concrets sont les classes réelles qui implémentent l'interface Product, chacune représentant un type spécifique d'objet à créer.

Créateur

  • C'est une classe ou une interface abstraite qui déclare la méthode factory.
  • Cette méthode est responsable de la création des objets Product, mais elle délègue la création réelle aux sous-classes.

Créateurs de béton

  • Ce sont des sous-classes du Creator qui implémentent la méthode factory.
  • Ils décident quel produit concret spécifique créer, souvent en fonction de paramètres d’entrée ou de configuration.

Méthode d'usine

  • Il s'agit d'une méthode définie dans la classe Creator qui est responsable de la création des objets Product.
  • Il est généralement déclaré comme abstrait dans le Creator et implémenté dans les Concrete Creators.

Exemple de modèle de conception de méthode d'usine en Java

Énoncé du problème

Vous développez un système logiciel pour une plateforme de commerce électronique traitant de différents types de produits. Chaque catégorie de produits (par exemple, électronique, vêtements, livres) nécessite une manipulation spécifique lors de la création. Cependant, vous souhaitez dissocier le code client de la logique concrète de création de produits pour améliorer la flexibilité et la maintenabilité. De plus, vous souhaitez permettre une extension facile en ajoutant de nouveaux types de produits à l'avenir sans modifier le code existant.

Solution utilisant la classe abstraite

Le problème ci-dessus peut être résolu à l’aide du modèle de conception de méthode d’usine :

Java




// Abstract Product Class> abstract> class> Product {> >public> abstract> void> display();> }> // Concrete Products> class> ConcreteProductA>extends> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product A.'>);> >}> }> class> ConcreteProductB>extends> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product B.'>);> >}> }> // Creator Abstract Class> abstract> class> Creator {> >public> abstract> Product factoryMethod();> }> // Concrete Creators> class> ConcreteCreatorA>extends> Creator {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductA();> >}> }> class> ConcreteCreatorB>extends> Creator {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductB();> >}> }> // Client Code> public> class> FactoryMethodExample {> >public> static> void> main(String[] args) {> >Creator creatorA =>new> ConcreteCreatorA();> >Product productA = creatorA.factoryMethod();> >productA.display();> >Creator creatorB =>new> ConcreteCreatorB();> >Product productB = creatorB.factoryMethod();> >productB.display();> >}> }>

combien de zéro pour un million 

>

>

Sortir 

This is Concrete Product A. This is Concrete Product B.>

Solution utilisant l'interface

Le problème ci-dessus peut être résolu à l’aide du modèle de conception de méthode d’usine :

Java




// Product Interface> interface> Product {> >void> display();> }> // Concrete Products> class> ConcreteProductA>implements> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product A.'>);> >}> }> class> ConcreteProductB>implements> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product B.'>);> >}> }> // Factory Interface> interface> Factory {> >Product factoryMethod();> }> // Concrete Factories> class> ConcreteFactoryA>implements> Factory {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductA();> >}> }> class> ConcreteFactoryB>implements> Factory {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductB();> >}> }> // Client Code> public> class> FactoryMethodExample {> >public> static> void> main(String[] args) {> >Factory factoryA =>new> ConcreteFactoryA();> >Product productA = factoryA.factoryMethod();> >productA.display();> >Factory factoryB =>new> ConcreteFactoryB();> >Product productB = factoryB.factoryMethod();> >productB.display();> >}> }> 

>

chaîne dans le tableau c 
>

Sortir 

This is Concrete Product A. This is Concrete Product B.>

Cas d'utilisation du modèle de conception de méthode d'usine en Java

Voici quelques applications courantes du modèle Factory Method Design en Java :

  • Cadres de création :
    • JDBC (Java Database Connectivity) utilise largement les usines pour créer des connexions, des instructions et des jeux de résultats. Les frameworks d'injection de dépendances comme Spring et Guice s'appuient fortement sur les usines pour créer et gérer les beans.
  • Boîtes à outils GUI :
    • Swing et JavaFX utilisent des usines pour créer des composants d'interface utilisateur tels que des boutons, des champs de texte et des étiquettes, permettant une personnalisation et une flexibilité dans la conception de l'interface utilisateur.
  • Cadres de journalisation :
    • Les frameworks de journalisation tels que Log4j et Logback utilisent des usines pour créer des enregistreurs avec différentes configurations, permettant de contrôler les niveaux de journalisation et les destinations de sortie.
  • Sérialisation et désérialisation :
    • Les frameworks de sérialisation d'objets utilisent souvent des usines pour créer des objets à partir de données sérialisées, prenant en charge différents formats de sérialisation et de versionnage.
  • Systèmes de plugins :
    • Les systèmes basés sur des plugins utilisent souvent des usines pour charger et créer des instances de plugin de manière dynamique, permettant ainsi l'extensibilité et la personnalisation.
  • Développement de jeu:
    • Les moteurs de jeu utilisent souvent des usines pour créer différents types d'objets, de personnages et de niveaux de jeu, favorisant ainsi l'organisation et la flexibilité du code.
  • Développement web:
    • Les frameworks Web utilisent parfois des usines pour créer des composants de vue, des contrôleurs et des services, permettant ainsi la modularité et la testabilité des applications Web.

Avantages du modèle de conception de méthode d'usine en Java

Les avantages du modèle de conception de méthode d'usine en Java sont :

  • Découplage : Il sépare la logique de création d'objets du code client qui utilise ces objets. Cela rend le code plus flexible et maintenable car les modifications apportées au processus de création ne nécessitent pas de modifications du code client.
  • Extensibilité: Il est facile d’introduire de nouveaux types de produits sans modifier le code client. Il vous suffit de créer une nouvelle sous-classe Concrete Creator et d'implémenter la méthode d'usine pour produire le nouveau produit.
  • Testabilité : Il simplifie les tests unitaires en vous permettant de simuler ou de supprimer la création de produits pendant les tests. Vous pouvez tester différentes implémentations de produits de manière isolée sans vous fier à la création réelle d'objets.
  • Réutilisabilité du code : La méthode factory peut être réutilisée dans différentes parties de l'application où la création d'objets est nécessaire. Cela favorise la centralisation et la réutilisation des logiques de création d’objets.
  • Encapsulation : Il masque les classes de produits concrètes du code client, rendant le code moins dépendant d'implémentations spécifiques. Cela améliore la maintenabilité et réduit le couplage.

Inconvénients du modèle de conception de méthode d'usine en Java

Les inconvénients du modèle de conception de méthode d'usine en Java sont :

  • Complexité accrue : Il introduit des classes et des interfaces supplémentaires, ajoutant une couche d'abstraction qui peut rendre le code plus complexe à comprendre et à maintenir, en particulier pour ceux qui ne connaissent pas le modèle.
  • Aérien: L'utilisation du polymorphisme et de la liaison dynamique peut avoir un léger impact sur les performances, bien que cela soit souvent négligeable dans la plupart des applications.
  • Couplage étroit au sein des hiérarchies de produits : Les créateurs de béton sont toujours étroitement liés à leurs produits en béton correspondants. Les changements apportés à l’un nécessitent souvent des changements apportés à l’autre.
  • Dépendance aux sous-classes concrètes : Le code client dépend toujours de la classe abstraite Creator, nécessitant la connaissance de ses sous-classes concrètes pour effectuer des appels de méthode d'usine corrects.
  • Potentiel de surutilisation : Il est important d’utiliser le modèle Factory Method judicieusement pour éviter une ingénierie excessive de l’application. La création d'objets simples peut souvent être gérée directement sans avoir recours à une usine.
  • Défis des tests : Tester la logique de l’usine elle-même peut être plus complexe.

Conclusion

Jusqu'à présent, nous avons appris ce qu'est le modèle de conception de la méthode Factory et comment le mettre en œuvre. Je pense que nous comprenons désormais assez bien l’avantage de ce mécanisme de conception. Les méthodes d'usine sont omniprésentes dans les boîtes à outils et les frameworks. L'exemple de document précédent est une utilisation typique dans MacApp et ET++.

Lire la suite : Tutoriel sur les modèles de conception Java