Java: Model de metodă de proiectare în fabrică | Proiectare orientată pe obiecte | Modele de design

Publicat: 2013-06-28

Fabrică de proiectare-metodă model Proiectare orientată pe obiecte

Factory Design Pattern este unul dintre modelele Creational Design și este utilizat pe scară largă în JDK, precum și în cadre precum Spring MVC și Struts. Modelul metodei fabrică este un model de design creațional orientat pe obiecte pentru a implementa conceptul de fabrici și tratează problema creării de obiecte (produse) fără a specifica clasa exactă de obiect care va fi creat. Esența acestui model este să „ Definiți o interfață pentru crearea unui obiect, dar lăsați clasele care implementează interfața să decidă ce clasă să instanțieze. Metoda Factory permite unei clase să amâne instanțierea la subclase „.

Modele de design Java

Să învățăm mai întâi cum să implementăm modelul din fabrică în java. Vom crea 5 clase pentru a implementa acest model.

  • Super clasă (CrunchfiyCompany.java)
    • Super clasă în modelul din fabrică poate fi o interfață, o clasă abstractă sau o clasă java normală. Pentru exemplul nostru, avem super clasă ca clasă abstractă cu metoda toString() suprascrisă în scopul testării.
  • Subclasa 1 (CrunchifyEbay.java)
    • Observați că clasa extinde clasa CrunchfiyCompany.
  • Subclasa 2 (CrunchifyGoogle.java)
    • Observați că clasa extinde clasa CrunchfiyCompany.
  • Clasa Factory (CrunchifyFactoryPattern.java)
    • Acum că avem super-clase și subclase pregătite, putem scrie clasa noastră din fabrică.
    • Putem păstra clasa Factory Singleton sau putem păstra metoda care returnează subclasa static.
    • Observați că pe baza parametrului de intrare, este creată și returnată o subclasă diferită.
  • Clasa de testare (CrunchifyFactoryPatternTest.java)
    • Program simplu de testare client care utilizează implementarea modelului din fabrică de mai sus.

Alte trebuie citite:

  • Thread-Safe și o implementare rapidă Singleton în Java
  • Ce este Daemon Thread în Java? Exemplu atasat

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

Alte exemple folosind modelul de fabrică?

  • Metodele java.util.Calendar, ResourceBundle și NumberFormat getInstance() utilizează modelul Factory.
  • metoda valueOf() în clasele wrapper precum Boolean, Integer etc.

Avantajele modelului de fabrică:

  • Este folosit atunci când avem o super clasă cu mai multe subclase și, pe baza intrării, trebuie să returnăm una din subclase. Acest model preia responsabilitatea instanțierii unei clase de la programul client la clasa din fabrică.
  • Modelul din fabrică oferă o abordare a codului pentru interfață, mai degrabă decât implementare.
  • Modelul de fabrică elimină instanțiarea claselor de implementare reale din codul clientului, făcându-l mai robust, mai puțin cuplat și ușor de extins. De exemplu, putem schimba cu ușurință implementarea clasei PC, deoarece programul client nu este conștient de acest lucru.
  • Modelul de fabrică oferă abstracție între implementare și clasele client prin moștenire.

Dezavantaje:

  • Fabrica trebuie folosită pentru o familie de obiecte. Dacă clasele nu extind clasa de bază comună sau interfața, acestea nu pot fi utilizate într-un șablon de proiectare din fabrică.

Lista tuturor tutorialelor Java Web Development, Spring MVC.