Java : modèle de méthode de conception d'usine | Conception orientée objet | Modèles de conception

Publié: 2013-06-28

Modèle de méthode de conception d'usine Conception orientée objet

Le modèle de conception d'usine est l'un des modèles de conception de création et il est largement utilisé dans JDK ainsi que dans des frameworks tels que Spring MVC et Struts. Le modèle de méthode d'usine est un modèle de conception créationnel orienté objet pour implémenter le concept de fabrique et traite le problème de la création d'objets (produits) sans spécifier la classe exacte d'objet qui sera créée. L'essence de ce modèle est de « Définir une interface pour créer un objet, mais laisser les classes qui implémentent l'interface décider quelle classe instancier. La méthode Factory permet à une classe de différer l'instanciation aux sous-classes ".

Modèles de conception Java

Apprenons d'abord à implémenter le modèle d'usine en Java. Nous allons créer 5 classes pour implémenter ce pattern.

  • Super Classe (CrunchfiyCompany.java)
    • La super classe dans le modèle d'usine peut être une interface, une classe abstraite ou une classe Java normale. Pour notre exemple, nous avons une super classe en tant que classe abstraite avec toString() remplacée à des fins de test.
  • Sous-classe1 (CrunchifyEbay.java)
    • Notez que la classe étend la classe CrunchfiyCompany.
  • Sous-classe2 (CrunchifyGoogle.java)
    • Notez que la classe étend la classe CrunchfiyCompany.
  • Classe d'usine (CrunchifyFactoryPattern.java)
    • Maintenant que nous avons des super classes et des sous-classes prêtes, nous pouvons écrire notre classe d'usine.
    • Nous pouvons conserver la classe Factory Singleton ou nous pouvons conserver la méthode qui renvoie la sous-classe en statique.
    • Notez qu'en fonction du paramètre d'entrée, une sous-classe différente est créée et renvoyée.
  • Classe de test (CrunchifyFactoryPatternTest.java)
    • Programme client de test simple qui utilise l'implémentation du modèle d'usine ci-dessus.

Autres lectures incontournables :

  • Thread-Safe et implémentation rapide d'un singleton en Java
  • Qu'est-ce qu'un thread démon en Java ? Exemple joint

CrunchfiyCompany.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
// Super class in factory pattern can be an interface, abstract class or a
// normal java class. For our example, we have super class as abstract class
// with overridden toString() method for testing purpose.
 
public abstract class CrunchfiyCompany {
 
public abstract String getPhoneNumber ( ) ;
 
public abstract String getZipCode ( ) ;
 
@Override
public String toString ( ) {
return "Phone #= " + this . getPhoneNumber ( ) + ", Zip Code= " + this . getZipCode ( ) ;
}
}

CrunchifyEbay.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
// Notice that the class is extending CrunchfiyCompany class.
 
public class CrunchifyEbay extends CrunchfiyCompany {
 
private String phoneNumber ;
private String zipCode ;
 
public CrunchifyEbay ( String phoneNumber , String zipCode ) {
this . phoneNumber = phoneNumber ;
this . zipCode = zipCode ;
}
 
@Override
public String getPhoneNumber ( ) {
return this . phoneNumber ;
}
 
@Override
public String getZipCode ( ) {
return this . zipCode ;
}
}

CrunchifyGoogle.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
// Notice that the class is extending CrunchfiyCompany class.
 
public class CrunchifyGoogle extends CrunchfiyCompany {
 
private String phoneNumber ;
private String zipCode ;
 
public CrunchifyGoogle ( String phoneNumber , String zipCode ) {
this . phoneNumber = phoneNumber ;
this . zipCode = zipCode ;
}
 
@Override
public String getPhoneNumber ( ) {
return this . phoneNumber ;
}
 
@Override
public String getZipCode ( ) {
return this . zipCode ;
}
}

CrunchifyFactoryPattern.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com . crunchify . tutorials ;
 
import com . crunchify . tutorials . CrunchfiyCompany ;
import com . crunchify . tutorials . CrunchifyEbay ;
import com . crunchify . tutorials . CrunchifyGoogle ;
 
/**
* @author Crunchify.com
*/
 
// Now that we have super classes and sub-classes ready, we can write our factory class.
// We can keep Factory class Singleton or we can keep the method that return the subclass a static.
// Notice that based on the input parameter, different subclass is created and returned.
 
public class CrunchifyFactoryPattern {
 
public static CrunchfiyCompany getDetails ( String type , String phoneNumber , String zipCode ) {
if ( "Ebay" . equalsIgnoreCase ( type ) )
return new CrunchifyEbay ( phoneNumber , zipCode ) ;
else if ( "Google" . equalsIgnoreCase ( type ) )
return new CrunchifyGoogle ( phoneNumber , zipCode ) ;
 
return null ;
}
 
}

CrunchifyFactoryPatternTest.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com . crunchify . tutorials ;
 
import com . crunchify . tutorials . CrunchfiyCompany ;
import com . crunchify . tutorials . CrunchifyFactoryPattern ;
 
/**
* @author Crunchify.com
*/
 
// Simple Test client program that uses above factory pattern implementation.
 
public class CrunchifyFactoryPatternTest {
 
public static void main ( String [ ] args ) {
CrunchfiyCompany eBay = CrunchifyFactoryPattern . getDetails ( "Ebay" , "408.123.4567" , "98765" ) ;
CrunchfiyCompany google = CrunchifyFactoryPattern . getDetails ( "Google" , "519.123.4567" , "56789" ) ;
System . out . println ( "Factory eBay Config::" + eBay ) ;
System . out . println ( "Factory Google Config::" + google ) ;
}
}

Results
1
2
Factory eBay Config : : Phone #= 408.123.4567, Zip Code= 98765
Factory Google Config : : Phone #= 519.123.4567, Zip Code= 56789

D'autres exemples utilisant le modèle d'usine ?

  • Les méthodes java.util.Calendar, ResourceBundle et NumberFormat getInstance() utilisent le modèle Factory.
  • méthode valueOf() dans les classes wrapper comme Boolean, Integer etc.

Avantages du modèle d'usine :

  • Il est utilisé lorsque nous avons une super classe avec plusieurs sous-classes et en fonction de l'entrée, nous devons renvoyer l'une des sous-classes. Ce modèle supprime la responsabilité de l'instanciation d'une classe du programme client à la classe d'usine.
  • Le modèle d'usine fournit une approche du code pour l'interface plutôt que pour l'implémentation.
  • Le modèle d'usine supprime l'instanciation des classes d'implémentation réelles du code client, ce qui le rend plus robuste, moins couplé et facile à étendre. Par exemple, nous pouvons facilement modifier l'implémentation de la classe PC car le programme client n'en est pas conscient.
  • Le modèle d'usine fournit une abstraction entre l'implémentation et les classes client via l'héritage.

Désavantages:

  • L'usine doit être utilisée pour une famille d'objets. Si les classes n'étendent pas la classe ou l'interface de base commune, elles ne peuvent pas être utilisées dans un modèle de conception d'usine.

Liste de tous les tutoriels Java Web Development, Spring MVC.