Java: Wzorzec metody projektowania fabrycznego | Projektowanie zorientowane obiektowo | Wzorce projektowe

Opublikowany: 2013-06-28

Factory Design-Metod Pattern Projektowanie zorientowane na obiekt

Factory Design Pattern jest jednym z wzorców Creational Design i jest szeroko stosowany w JDK, a także w platformach, takich jak Spring MVC i Struts. Wzorzec metody fabryki jest wzorcem projektowym zorientowanym obiektowo, służącym do realizacji koncepcji fabryk i rozwiązuje problem tworzenia obiektów (produktów) bez określania dokładnej klasy obiektu, który zostanie utworzony. Istotą tego wzorca jest „ Zdefiniuj interfejs do tworzenia obiektu, ale pozwól klasom implementującym interfejs zdecydować, którą klasę utworzyć. Metoda Factory pozwala klasie odroczyć tworzenie instancji do podklas „.

Wzorce projektowe Java

Nauczmy się najpierw, jak zaimplementować wzorzec fabryki w javie. Stworzymy 5 klas, aby zaimplementować ten wzorzec.

  • Superklasa (CrunchfiyCompany.java)
    • Super klasa we wzorcu fabrycznym może być interfejsem, klasą abstrakcyjną lub zwykłą klasą java. W naszym przykładzie mamy superklasę jako klasę abstrakcyjną z nadpisaną metodą toString() do celów testowych.
  • Podklasa 1 (CrunchifyEbay.java)
    • Zauważ, że klasa jest rozszerzeniem klasy CrunchfiyCompany.
  • Podklasa2 (CrunchifyGoogle.java)
    • Zauważ, że klasa jest rozszerzeniem klasy CrunchfiyCompany.
  • Klasa fabryki (CrunchifyFactoryPattern.java)
    • Teraz, gdy mamy gotowe superklasy i podklasy, możemy napisać naszą klasę fabryczną.
    • Możemy zachować klasę Factory Singleton lub metodę zwracającą podklasę jako statyczną.
    • Zauważ, że na podstawie parametru wejściowego tworzona i zwracana jest inna podklasa.
  • Klasa testowa (CrunchifyFactoryPatternTest.java)
    • Prosty program klienta testowego, który wykorzystuje implementację powyższego wzorca fabrycznego.

Inne musi brzmieć:

  • Bezpieczna wątkowo i szybka implementacja singletona w Javie
  • Co to jest wątek demona w Javie? Przykład w załączeniu

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

Inne przykłady z wykorzystaniem wzorca fabrycznego?

  • Metody java.util.Calendar, ResourceBundle i NumberFormat getInstance() używają wzorca Factory.
  • metoda valueOf() w opakowujących klasach, takich jak Boolean, Integer itp.

Korzyści z wzorca fabrycznego:

  • Jest używany, gdy mamy superklasę z wieloma podklasami i na podstawie danych wejściowych musimy zwrócić jedną z podklas. Ten wzorzec przejmuje odpowiedzialność za tworzenie instancji klasy z programu klienta do klasy fabrycznej.
  • Wzorzec Factory zapewnia podejście do kodu dla interfejsu, a nie implementacji.
  • Wzorzec fabryki usuwa tworzenie instancji rzeczywistych klas implementacji z kodu klienta, czyniąc go bardziej niezawodnym, mniej powiązanym i łatwym do rozszerzenia. Na przykład możemy łatwo zmienić implementację klasy PC, ponieważ program klienta nie jest tego świadomy.
  • Wzorzec fabryki zapewnia abstrakcję między implementacją a klasami klienta poprzez dziedziczenie.

Wady:

  • Fabryka ma być wykorzystywana dla rodziny obiektów. Jeśli klasy nie rozszerzają wspólnej klasy bazowej lub interfejsu, nie można ich używać w szablonie projektu fabryki.

Lista wszystkich tutoriali Java Web Development, Spring MVC.