Patron de conception Fabrique

Le patron Factory est l'un des patrons de conception les plus couramment utilisés en Java. Il fournit un moyen de créer des objets, en séparant le processus de création d'objets du processus d'utilisation des objets.

Le patron Factory fournit un moyen de créer des objets sans spécifier la classe concrète à créer.

En utilisant le patron Factory, la logique de création d'objets peut être encapsulée dans une classe de fabrique plutôt que d'instancier directement des objets dans le code client, ce qui améliore la maintenabilité et l'extensibilité du code.

Types de patron Factory

1. Patron Simple Factory：

  • Le patron Simple Factory n'est pas un patron de conception formel, mais il constitue la base du patron Factory. Il utilise une seule classe de fabrique pour créer différents objets, en déterminant quel type d'objet créer en fonction des paramètres transmis.

2. Patron Factory Method：

  • Le patron Factory Method définit une interface pour créer des objets, mais laisse les sous-classes décider quelle classe instancier. Il reporte la création d'objets aux sous-classes.

3. Patron Abstract Factory：

  • Le patron Abstract Factory fournit une interface pour créer une famille d'objets liés ou interdépendants sans spécifier leurs classes concrètes.

summary

intention

Définir une interface pour créer des objets, et laisser les sous-classes décider quelle classe concrète instancier. Le patron de fabrique reporte le processus de création d'objets aux sous-classes.

Résout principalement

Le problème de la sélection d’interface.

Quand l'utiliser

Lorsque nous devons créer différentes instances dans différentes conditions.

Comment résoudre

En faisant implémenter l'interface de fabrique par les sous-classes, un produit abstrait est renvoyé.

Code clé

Le processus de création d'objets est implémenté dans les sous-classes.

Exemple d'application

  1. Fabrication automobile: Vous avez besoin d'une voiture ; vous la récupérez simplement à l'usine, sans avoir à vous soucier du processus de fabrication et de l'implémentation interne de la voiture.
  2. HibernateLors du changement de base de données, il vous suffit de modifier le Dialect et le Driver de base de données pour basculer entre différentes bases de données.

Avantages

  1. L'appelant n'a besoin que de connaître le nom de l'objet pour le créer.
  2. Haute extensibilité : si un nouveau produit doit être ajouté, il suffit d'étendre une classe de fabrique.
  3. L'implémentation spécifique du produit est masquée ; l'appelant ne se soucie que de l'interface du produit.

Inconvénients

Chaque fois qu'un produit est ajouté, il faut ajouter une classe concrète et une fabrique correspondante, ce qui multiplie le nombre de classes dans le système et augmente sa complexité ainsi que sa dépendance aux classes concrètes.

Cas d'utilisation

  1. Journalisation: Les journaux peuvent être enregistrés sur un disque dur local, dans des événements système, sur des serveurs distants, etc. Les utilisateurs peuvent choisir où enregistrer les journaux.
  2. Accès à la base de données: Lorsque l'utilisateur ne sait pas quelle base de données le système final utilisera, ou lorsque la base de données peut changer.
  3. Conception de framework pour la connexion à un serveur.: il est nécessaire de prendre en charge trois protocoles : "POP3", "IMAP", "HTTP". Ces trois protocoles peuvent être utilisés comme classes de produits qui implémentent ensemble une interface.

Notes

Le patron Factory est adapté aux scénarios où des objets complexes sont générés. Si l'objet est relativement simple et peut être créé avec `new`, il n'est pas nécessaire d'utiliser le patron Factory. L'utilisation du patron Factory introduit une classe de fabrique et augmente la complexité du système.

Structure

Le patron Factory comprend les rôles principaux suivants :

  • Produit abstrait : définit l'interface commune ou la classe abstraite du produit. Il peut être la classe parente ou l'interface des classes de produits concrètes, en spécifiant les méthodes communes des objets produits.
  • Produit concret : implémente l'interface de produit abstrait, définissant le comportement et les propriétés spécifiques d'un produit concret.
  • Fabrique abstraite : déclare des méthodes abstraites pour créer des produits ; elle peut être une interface ou une classe abstraite. Elle peut avoir plusieurs méthodes pour créer différents types de produits.
  • Fabrique concrète : implémente l'interface de fabrique abstraite et est responsable de la création effective des objets produits concrets.

Implémentation

Nous allons créer uneShapeInterface et l'implémentationShapeLa classe d'entité de l'interface. L'étape suivante consiste à définir la classe de fabrique.ShapeFactory。

FactoryPatternDemoUtilisation de la classeShapeFactoryPour obtenirShapeobjet. Il vaShapeFactoryTransmet des informations (CIRCLE / RECTANGLE / SQUARE), afin d'obtenir le type d'objet dont il a besoin.

工厂模式的 UML 图

Étape 1

créer une interface :

Shape.java

public interface Shape { void draw(); }

Étape 2

Créez des classes concrètes qui implémentent l'interface.

Rectangle.java

public class Rectangle implements Shape { @Override public void draw() { System.out.println("À l'intérieur de la méthode Rectangle::draw()."); } }

Square.java

public class Square implements Shape { @Override public void draw() { System.out.println("À l'intérieur de la méthode Square::draw()."); } }

Circle.java

public class Circle implements Shape { @Override public void draw() { System.out.println("À l'intérieur de la méthode Circle::draw()."); } }

Étape 3

Créer une fabrique qui génère des objets de classes d'entités en fonction des informations données.

ShapeFactory.java

public class ShapeFactory { //Utilisez la méthode getShape pour obtenir l'objet de type forme. public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; } }

Étape 4

Utilisez cette fabrique pour obtenir des objets des classes d'entité en passant des informations de type.

FactoryPatternDemo.java

public class FactoryPatternDemo { public static void main(String[] args) { ShapeFactory shapeFactory = new ShapeFactory(); //Obtenez l'objet Circle et appelez sa méthode draw Shape shape1 = shapeFactory.getShape("CIRCLE"); //Appeler la méthode draw de Circle shape1.draw(); //Obtenir l’objet Rectangle, et appeler sa méthode draw. Shape shape2 = shapeFactory.getShape("RECTANGLE"); //Appeler la méthode draw de Rectangle shape2.draw(); //Obtenir l’objet Square et appeler sa méthode draw Shape shape3 = shapeFactory.getShape("SQUARE"); //Appeler la méthode draw de Square shape3.draw(); } }

Étape 5

Exécutez le programme, résultat de sortie :

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

Autres articles connexes

autres extensions