Java: Factory Design-Methodenmuster | Objektorientiertes Design | Designmuster

Veröffentlicht: 2013-06-28

Factory Design-Method Pattern Object Oriented Design

Factory Design Pattern ist eines der Creational Design-Muster und wird häufig in JDK sowie in Frameworks wie Spring MVC und Struts verwendet. Das Factory-Methodenmuster ist ein objektorientiertes Gestaltungsmuster zur Implementierung des Konzepts von Fabriken und befasst sich mit dem Problem der Erstellung von Objekten (Produkten), ohne die genaue Klasse des zu erstellenden Objekts anzugeben. Der Kern dieses Musters besteht darin, „ eine Schnittstelle zum Erstellen eines Objekts zu definieren, aber die Klassen, die die Schnittstelle implementieren, entscheiden zu lassen, welche Klasse instanziiert werden soll. Mit der Factory-Methode kann eine Klasse die Instanziierung auf Unterklassen verschieben „.

Java-Entwurfsmuster

Lassen Sie uns zuerst lernen, wie man Fabrikmuster in Java implementiert. Wir werden 5 Klassen erstellen, um dieses Muster zu implementieren.

  • Superklasse (CrunchfiyCompany.java)
    • Die Superklasse im Fabrikmuster kann eine Schnittstelle, eine abstrakte Klasse oder eine normale Java-Klasse sein. Für unser Beispiel haben wir die Superklasse als abstrakte Klasse mit überschriebener toString() Methode zu Testzwecken.
  • Unterklasse1 (CrunchifyEbay.java)
    • Beachten Sie, dass die Klasse die CrunchfiyCompany-Klasse erweitert.
  • Unterklasse2 (CrunchifyGoogle.java)
    • Beachten Sie, dass die Klasse die CrunchfiyCompany-Klasse erweitert.
  • Factory-Klasse (CrunchifyFactoryPattern.java)
    • Nachdem wir nun Superklassen und Unterklassen bereit haben, können wir unsere Factory-Klasse schreiben.
    • Wir können die Factory-Klasse Singleton beibehalten oder wir können die Methode, die die Unterklasse zurückgibt, statisch beibehalten.
    • Beachten Sie, dass basierend auf dem Eingabeparameter verschiedene Unterklassen erstellt und zurückgegeben werden.
  • Testklasse (CrunchifyFactoryPatternTest.java)
    • Einfaches Test-Client-Programm, das die obige Factory-Musterimplementierung verwendet.

Weitere Must-Reads:

  • Thread-sichere und schnelle Singleton-Implementierung in Java
  • Was ist Daemon-Thread in Java? Beispiel anbei

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

Andere Beispiele mit Factory Pattern?

  • Die Methoden java.util.Calendar, ResourceBundle und NumberFormat getInstance() verwenden Factory-Muster.
  • valueOf() Methode in Wrapper-Klassen wie Boolean, Integer usw.

Vorteile des Fabrikmusters:

  • Es wird verwendet, wenn wir eine Superklasse mit mehreren Unterklassen haben und basierend auf der Eingabe eine der Unterklassen zurückgeben müssen. Dieses Muster übernimmt die Verantwortung für die Instanziierung einer Klasse vom Clientprogramm an die Factory-Klasse.
  • Das Factory-Muster bietet einen Ansatz für den Code für die Schnittstelle und nicht für die Implementierung.
  • Das Fabrikmuster entfernt die Instanziierung tatsächlicher Implementierungsklassen aus dem Clientcode, wodurch es robuster, weniger gekoppelt und leicht erweiterbar wird. Beispielsweise können wir die Implementierung der PC-Klasse leicht ändern, da das Client-Programm dies nicht weiß.
  • Das Fabrikmuster stellt durch Vererbung eine Abstraktion zwischen Implementierungs- und Clientklassen bereit.

Nachteile:

  • Die Fabrik muss für eine Familie von Objekten verwendet werden. Wenn die Klassen die gemeinsame Basisklasse oder Schnittstelle nicht erweitern, können sie nicht in einer Factory-Designvorlage verwendet werden.

Liste aller Java Web Development, Spring MVC Tutorials.