• Homepage
  • Articoli
  • Generale
  • Java: modello di metodo di progettazione di fabbrica | Design orientato agli oggetti | Modelli di progettazione

Java: modello di metodo di progettazione di fabbrica | Design orientato agli oggetti | Modelli di progettazione

Pubblicato: 2013-06-28

Progettazione orientata agli oggetti con metodo di progettazione di fabbrica

Factory Design Pattern è uno dei modelli Creational Design ed è ampiamente utilizzato in JDK e in framework come Spring MVC e Struts. Il modello del metodo factory è un modello di progettazione della creazione orientato agli oggetti per implementare il concetto di factory e affronta il problema della creazione di oggetti (prodotti) senza specificare l'esatta classe di oggetto che verrà creato. L'essenza di questo modello è “ Definire un'interfaccia per creare un oggetto, ma lasciare che le classi che implementano l'interfaccia decidano quale classe istanziare. Il metodo Factory consente a una classe di rinviare l'istanza alle sottoclassi ".

Modelli di progettazione Java

Per prima cosa impariamo come implementare il modello di fabbrica in java. Creeremo 5 classi per implementare questo modello.

  • Superclasse (CrunchfiyCompany.java)
    • La super classe nel modello di fabbrica può essere un'interfaccia, una classe astratta o una normale classe java. Per il nostro esempio, abbiamo la super classe come classe astratta con il metodo toString() sovrascritto a scopo di test.
  • Sottoclasse1 (CrunchifyEbay.java)
    • Si noti che la classe sta estendendo la classe CrunchfiyCompany.
  • Sottoclasse2 (CrunchifyGoogle.java)
    • Si noti che la classe sta estendendo la classe CrunchfiyCompany.
  • Classe di fabbrica (CrunchifyFactoryPattern.java)
    • Ora che abbiamo le super classi e le sottoclassi pronte, possiamo scrivere la nostra classe factory.
    • Possiamo mantenere la classe Factory Singleton o possiamo mantenere statico il metodo che restituisce la sottoclasse.
    • Si noti che in base al parametro di input, viene creata e restituita una sottoclasse diversa.
  • Classe di test (CrunchifyFactoryPatternTest.java)
    • Semplice programma client di test che utilizza l'implementazione del modello di fabbrica sopra.

Altro deve leggere:

  • Thread-Safe e un'implementazione singleton veloce in Java
  • Che cos'è Daemon Thread in Java? Esempio allegato

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

Altri esempi che utilizzano il modello di fabbrica?

  • I metodi java.util.Calendar, ResourceBundle e NumberFormat getInstance() utilizzano il modello Factory.
  • valueOf() nelle classi wrapper come Boolean, Integer ecc.

Vantaggi del modello di fabbrica:

  • Viene utilizzato quando abbiamo una superclasse con più sottoclassi e in base all'input, dobbiamo restituire una delle sottoclassi. Questo modello si assume la responsabilità dell'istanziazione di una classe dal programma client alla classe factory.
  • Il modello di fabbrica fornisce un approccio al codice per l'interfaccia piuttosto che per l'implementazione.
  • Il modello di fabbrica rimuove l'istanziazione delle classi di implementazione effettive dal codice client, rendendolo più robusto, meno accoppiato e facile da estendere. Ad esempio, possiamo facilmente modificare l'implementazione della classe PC perché il programma client non ne è a conoscenza.
  • Il modello di fabbrica fornisce l'astrazione tra l'implementazione e le classi client tramite l'ereditarietà.

Svantaggi:

  • La fabbrica deve essere utilizzata per una famiglia di oggetti. Se le classi non estendono la classe base o l'interfaccia comuni, non possono essere utilizzate in un modello di progettazione di fabbrica.

Elenco di tutti i tutorial di Java Web Development, Spring MVC.