Java Design Patterns Einfaches Factory-Muster

1.1 Simple Factory-Muster

Das Simple Factory-Muster ist die Erstellung von Klassen, auch Static Factory Method-Muster genannt. Das einfache Factory-Muster verwendet ein Factory-Objekt, um zu entscheiden, welche Instanz der Produktklasse erstellt werden soll.

1.1.1 Verschiedene Formen von Factory-Mustern

Das Factory-Muster ist speziell für die Instanziierung einer großen Anzahl von Klassen mit gemeinsamen Schnittstellen verantwortlich. Das Factory-Muster kann dynamisch entscheiden, welche Klasse instanziiert werden soll. Das Factory-Muster hat die folgenden Formen:
 Simple Factory-Muster (Simple Factory-Muster): wird auch als Static Factory-Methode (Static Factory-Methode) bezeichnet.
 Factory-Methodenmuster: Auch bekannt als Polymorphic Factory-Muster oder Virtual Constructor-Muster.
 Abstraktes Factory-Muster: wird auch als Toolbox-Muster (Kit oder Toolkit) bezeichnet.
Die folgende Abbildung zeigt ein vereinfachtes Klassendiagramm des einfachen Factory-Musters.

Das einfache Factory-Muster oder statisches Factory-Methodenmuster ist eine spezielle Implementierung verschiedener Factory-Methodenmuster. In der Java-Sprache kann das übliche Factory-Methodenmuster nicht das statische Factory-Methodenmuster ergeben, indem die Designfunktionalität degeneriert wird.

1.1.2 Einführung des einfachen Fabrikmodus (allgemeiner Modus)
Zum Beispiel gibt es einen Bauernhof, der verschiedene Früchte produziert, darunter Äpfel, Erdbeeren, Trauben (Traube); Der Hofgärtner (FruitGardener) muss entsprechend den Kundenbedürfnissen entsprechende Früchte bereitstellen. Schauen wir uns an, wie dieser Prozess mithilfe des einfachen Factory-Musters implementiert wird, wie unten gezeigt:

Der Implementierungsquellcode dieses Modus lautet wie folgt:

1.1.2.1 Produktschnittstelle – Fruchtschnittstelle: Fruit.java
Paket com.lavasoft.patterns.simplefactory.ybgc;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: Fruit.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 0:26:51
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmustermuster – Einfaches Fabrikmuster – Allgemeines Muster
* ReadMe: Abstrakte Produktrolle: Fruchtproduktschnittstelle der Fabrik --Obst
*/
public interface Fruit {
/**
*Pflanzen
*/
void plant();

/**
* Wachstum
*/
void grow();

/**
* Ernte
*/
void Harvest();
}

1.1.2.2 Produkt – Pingguo-Kategorie: Apple.java
Paket com .lavasoft.patterns.simplefactory .ybgc;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: Apple.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 0:47:25
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Factory-Modus-Modus – Einfacher Factory-Modus – Allgemeiner Modus
* ReadMe: Fruit Factory-Produkte: Apple
*/
public class Apple implementiert Fruit {
private int treeAge;

/**
*Pflanzen
*/
public void plant() {
System.out.println("Apple has been planted.");
}

/**
* Wachstum
*/
public void grow() {
System.out.println("Apple is Grown...");
}

/**
* Ernte
*/
public void Harvest () {
System.out.println("Der Apfel wurde geerntet.");
}

/**
* @return return tree age
*/
public int getTreeAge() {
Return TreeAge; 🎜>}

1.1.2.3 产品－草莓类：Strawberry.java
Paket com.lavasoft.patterns.simplefactory.ybgc;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname:Strawberry.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 0:45:09
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmodus-Modus – Einfacher Fabrikmodus – Allgemeiner Modus
* ReadMe: Obstfabrikprodukte: Erdbeere
*/
öffentliche Klasse Strawberry implementiert Fruit {
    /**
* Wachstum
*/
    public void grow() {
        System.out.println("Strawberry is Grown...");
    }

/**
* Ernte
*/
    public void Harvest() {
        System.out.println("Erdbeere wurde geerntet.");
    }

    /**
*Pflanzen
*/
    public void plant() {
        System.out.println("Strawberry has been planted.");
    }

    /**
* Hilfsmethode
*/
    public static void log(String msg) {
        System.out.println(msg);
    }
}

 

1.1.2.4 Grape.java
package com.lavasoft.patterns.simplefactory.ybgc;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: Grape.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 0:36:56
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmodus-Modus – Einfacher Fabrikmodus – Allgemeiner Modus
* ReadMe: Obstfabrikprodukte: Trauben
*/
public class Grape implementiert Fruit {
    private boolean samenlos;   //是否有籽

    /**
*Pflanzen
*/
    public void plant() {
        System.out.println("Traube wurde gepflanzt.");
    }

    /**
* Wachstum
*/
    public void wachsen() {
        System.out.println("Traube wächst...");
    }

    /**
* Ernte
*/
    public void Harvest() {
        System.out.println("Weintraube wurde geerntet.");
    }

    /**
* @return, ob Samen vorhanden sind
*/
    public boolean getSeedless() {
        return samenlos;
    }

    /**
* Zuordnungsmethode mit oder ohne Samen
*/
    public void setSeedless(boolean samenlos) {
        this.seedless = samenlos;
    }

    /**
* Hilfsmethode
*/
    public static void log(String msg) {
        System.out.println(msg);
{

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: FruitGardener.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 1:03:27
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmodus-Modus – Einfacher Fabrikmodus – Allgemeiner Modus
* ReadMe: Fabrikrolle: Obstgärtner, Herstellung von Obstprodukten
*/
public class FruitGardener {
    /**
* Statische Factory-Methode
* @param which: spezifischer Produktname
* @return ein Fruchtobjekt
* @throws BadFruitException
*/
    public static Fruitfactory(String which) throws BadFruitException {
        if (which. equalIgnoreCase("apple")) {
            return new Apple();
        } else if (which.equalsIgnoreCase("strawberry")) {
            return new Strawberry();
        } else if ( which.equalsIgnoreCase("grape")) {
            return new Grape();
        } else {
            throw new BadFruitException("Bad Fruit Request");
        }
    }
}

 

1.1.2.6 工厂异常定义类：BadFruitException.java
package com.lavasoft.patterns.simplefactory.ybgc;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: BadFruitException.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 1:04:56
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Factory-Mustermuster – einfaches Factory-Muster – allgemeines Muster
* ReadMe: Factory-Ausnahmebehandlungsklasse
*/
public class BadFruitException erweitert Exception {
    public BadFruitException(String msg) {
        super(msg);     //调用父类的构造方法
    }

 

1.1.2.7 一般工厂模式的测试类

Paket. com.lavasoft.patterns .simplefactory.ybgc ;

/**

* Erstellt von IntelliJ IDEA.
* Dateiname: TestApp.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 1:12:08
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmustermuster – einfaches Fabrikmuster – allgemeines Muster
* ReadMe: Testklassen für allgemeine Fabrikmuster
*/
public class TestApp {
    /**
* Testmethode
*/
    private void test(String FruitName) {
        try {
            Fruit f = FruitGardener.factory (fruitName); 🎜>            System. out.println("对不起!工厂目前不能生产你所要的产品:" + FruitName);
            System.out.println(e.getMessage());     //输出异常信息
            e.printStackTrace();                    //输出异常堆栈信息
        }
    }

    /**
* Bewerbungseingabemethode
*/

    public static void main(String args[]) {

        TestApp t = neue TestApp ();
        t.test("apple");
        t.test("grape");
        t.test("strawberry");

        t.test(" Auto");  //此处会抛异常,水果工厂能生产car(轿车)吗!哈哈哈哈...
    }
}

 

1.1.2.8 Ergebnisse des Testlaufs
Herzlichen Glückwunsch! Derzeit kann das von Ihnen angeforderte Produkt nicht hergestellt werden: car
Bad Fruit Request
com.lavasoft.patterns.simplefactory.ybgc.BadFruitException: Bad Fruit Request
bei com.lavasoft.patterns.simplefactory.ybgc.FruitGardener. Factory(FruitGardener.java:28)
bei com.lavasoft.patterns.simplefactory.ybgc.TestApp.test(TestApp.java:19)
bei com.lavasoft.patterns.simplefactory.ybgc.TestApp.main( TestApp.java:37)
bei sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
bei sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
bei sun.reflect.DelegatingMethodAccessorImpl.invoke (DelegatingMethodAccessorImpl.java:25)
bei java.lang.reflect.Method.invoke(Method.java:585)
bei com.intellij.rt.execution.application.AppMain.main(AppMain.java:90 )

Prozess mit Exit-Code 0 abgeschlossen

Aus den Ergebnissen geht hervor, dass der Typ Auto (Auto) eingegeben wurde, den die Fabrik nicht produzieren kann, Hahahaha, der Obstgarten kann Autos produzieren? Lassen Sie sich von den Kindergartenkindern erzählen!

1.1.3 Die allgemeine Struktur des einfachen Fabrikmusters

Zusammenfassend lässt sich sagen, dass dies aus der Implementierung ersichtlich ist einfaches Fabrikmuster oben Ja, das einfache Fabrikmuster muss implementiert werden
 Fabrikrolle: Gärtner

 Abstraktes Produkt: Fruchtschnittstelle

 Spezifische Produkte: Äpfel, Trauben, Erdbeeren
Darüber hinaus ist es ist im Allgemeinen erforderlich, um
 Factory Exception-Klasse
 Client-Klasse
zu implementieren. Das allgemeine Strukturdiagramm des einfachen Factory-Musters lautet wie folgt:

1.1 .4 Implementierung des einfachen Factory-Musters

1.1.4.1 Verwenden Sie Schnittstellen oder abstrakte Klassen, um mehrstufige Produktstrukturen zu implementieren

Factory-Klassen können mehrere statische Factory-Methoden haben, die zur Herstellung verschiedener Produktobjekte verwendet werden.

1.1.4.2 Mehrere Factory-Methoden

sind für die Erstellung verschiedener Produktobjekte verantwortlich. Beispielsweise ist die Klasse java.text.DateFormat die Factory-Klasse ihrer Unterklassen und das DateFormat Die Klasse bietet mehrere statische Factory-Methoden.

1.1.4.3 Weglassen der abstrakten Produktrolle

Wenn das System nur eine bestimmte Produktrolle hat, kann die abstrakte Produktrolle weggelassen werden. Das vereinfachte Klassendiagramm nach Weglassen der abstrakten Produktrolle lautet wie folgt:

Das Folgende ist ein Beispiel: Die Factory-Rolle erstellt ein bestimmtes Produkt. Der Quellcode lautet wie folgt:

1.1.4.3.1 Produktrolle: ConcreteProduct.java

Paket com.lavasoft.patterns.simplefactory.gchb;

/**
* Erstellt von IntelliJ IDEA.

* Dateiname:ConcreteProduct.java

* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 2:07:48
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – einfaches Fabrikmuster – Zusammenführung von Arbeit und Zeichnung (Zusammenführung von Fabrikrolle und abstrakter Produktrolle)
* ReadMe : Spezifische Produktkategorien, stellt einen einzelnen Produkttyp dar.
* /
public class ConcreteProduct {
public ConcreteProduct() {
}
}

1.1.4.3.2 Factory-Rolle:

package com. lavasoft.patterns.simplefactory.gchb;

/**
* Erstellt von IntelliJ IDEA.

* Dateiname: Creator.java

* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 1:56:43
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – einfaches Fabrikmuster – Zusammenführung von Arbeit und Zeichnung (Zusammenführung von Fabrikrolle und abstrakter Produktrolle)
* ReadMe : Spezifische Produktkategorien, die mit der abstrakten Produktrolle zusammengeführt werden, um nur einen einzigen Produkttyp zu erzeugen.
*/
public class Creator {
/**
* Statische Factory-Methode
* @Return a Product
*/
public static Creatorfactory(){
return new Creator() ;
}
}

1.1.4.3.3 Testklasse

package com.lavasoft.patterns.simplefactory.gchb;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: TestApp.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 2:11:30
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – einfaches Fabrikmuster – Zusammenführung von Arbeit und Zeichnung (Zusammenführung von Fabrikrollen und abstrakten Produktrollen)
* ReadMe: Testklasse zum Zusammenführen von Werk und Zeichnung
*/
public class TestApp {
private void test() {
Creator t = Creator.factory();
System.out.println("Product Erfolgreich produziert!");
}

public static void main(String args[]) {
new TestApp().test();
}
}

1.1.4.3.4 Testergebnisse
Das Produkt wurde erfolgreich produziert!

Prozess mit Exit-Code 0 abgeschlossen

1.1 .4.4 Fabrikrolle mit abstrakter Rolle verschmolzen
In einigen Fällen kann die Fabrikrolle durch die abstrakte Produktrolle gespielt werden. Eine typische Anwendung ist die Klasse java.text.DateFormat, eine abstrakte Produktklasse, die auch eine Fabrik für Unterklassen ist, wie in der folgenden Abbildung dargestellt:

Das Folgende ist eine Implementierung habe ich selbst geschrieben. Der Quellcode lautet wie folgt:

1.1.4.4.1 Abstrakte Produktklasse (auch eine Factory-Klasse)
Paket com.lavasoft.patterns.simplefactory .cxsl;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: AbsProduct.java
* Benutzer: LavaSoft
* Datum: 3.12.2006
* Zeit: 3:23:47
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – Einfaches Fabrikmuster – Verschmelzung von Fabrikrolle und abstrakter Produktrolle
* ReadMe: Abstrakte Produktklasse und Fabrik unter gleichzeitig Klasse.
*/
öffentliche abstrakte Klasse AbsProduct {
static Productfactory(){
return new Product();
}
}

1.1.4.4.2 Spezifische Produktklasse
Paket com.lavasoft.patterns.simplefactory.cxsl;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname:Product.java
* Benutzer: LavaSoft
* Datum: 3.12.2006
* Zeit: 3:23:54
* „Java and Patterns“ (geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – einfaches Fabrikmuster – Fabrikrollen und abstrakte Produktrollen zusammenführen
* ReadMe: Spezifische Produktkategorien
*/
öffentliche Klasse Produkt {
Produkt(){
}
}

1.1.4.4.3 Testklasse
Paket com.lavasoft.patterns. simplefactory.cxsl;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: TestApp.java
* Benutzer: LavaSoft
* Datum: 3.12.2006
* Zeit: 3:30:30
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – Einfaches Fabrikmuster – Fabrikrolle und abstrakte Produktrolle zusammenführen
* ReadMe: Testklasse
*/
public class TestApp {
private void test() {
Product a = AbsProduct.factory();
System .out.println("Erfolgreiches Erstellen eines Produktobjekts! ");
}

public static void main(String args[]) {
TestApp test = new TestApp();
test.test();
}
}

1.1.4.4.4 Testergebnisse

Ein Produkt Objekt wurde erfolgreich erstellt!

Prozess mit Exit-Code 0 abgeschlossen

Diese Implementierung ist sehr einfach, daher wird der Code nicht im Detail erklärt!

1.1.4.5 Alle drei Rollen werden zusammengeführt

Wenn Sie auf dem obigen Beispiel basieren, wird sogar die abstrakte Produktrolle weggelassen, und die Fabrikrolle kann weggelassen werden Zusammengeführt mit bestimmten Produktrollen. Mit anderen Worten: Eine Produktklasse ist eine eigene Fabrik. Wie in der Abbildung unten gezeigt:

Ein einfaches Implementierungsbeispiel ist unten angegeben:

1.1.4.5.1 Spezifische Produktkategorie
Paket com.lavasoft.patterns.simplefactory.sshb;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname:ConcreteProduct.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 2:20:38
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Fabrikmuster – einfaches Fabrikmuster – Drei-Farben-in-einem-Muster
* ReadMe: Abstraktes Produkt, Produkt, Fabrikklasse drei und eins Spezifische Produktkategorien
*/
public class ConcreteProduct
{
public ConcreteProduct(){}

/**
* Statische Factory-Methode
* @return spezifisches Produkt ConcreteProduct-Instanz
*/
public static ConcreteProduct Factory()
{
return new ConcreteProduct();
}
}

1.1.4.5.2 Testklasse
Paket com.lavasoft .patterns.simplefactory.sshb;

/**
* Erstellt von IntelliJ IDEA.
* Dateiname: TestApp.java
* Benutzer: LavaSoft
* Datum: 2006-12-1
* Zeit: 2:24:22
* „Java und Muster“ (--geschrieben von Dr. Yan Hong) Lesenotizen
* Werksmodus – Einfacher Werksmodus – Drei Farben in einem Modus
* ReadMe: Testmethode
*/

public class TestApp {
//Test method
private void test(){
ConcreteProduct t=ConcreteProduct.factory();
System.out.println("Produkt erfolgreich hergestellt!");
}
//
public static void main(String args[]){
new TestApp().test();
}
}

1.1.4.5.3 Testlaufergebnisse
Das Produkt wurde erfolgreich produziert!

Prozess mit Exit-Code 0 abgeschlossen

Der Code ist sehr einfach und ich werde ihn nicht mehr erklären.

1.1.4.6 Recycling von Produktobjekten und registrierten Fabrikmethoden
Dies wird im Singleton-Modus und im Mehrfachinstanzmodus besprochen.
Vor- und Nachteile des einfachen Fabrikmusters

1.1.4.6.1 Vorteile des einfachen Fabrikmusters
Kernfabrikklasse, die Fabrikklasse entscheidet, unter welcher sie erstellt wird welche Umstände Ein Beispiel für eine Produktklasse. Der Kunde hingegen ist von der Verantwortung für die direkte Erstellung des Produktobjekts befreit und „konsumiert“ nur das Produkt. Das einfache Fabrikmuster erreicht durch diesen Ansatz die Trennung der Verantwortlichkeiten.

1.1.4.6.2 Nachteile des einfachen Factory-Musters
Wenn die Produktklasse eine komplexe mehrstufige hierarchische Struktur aufweist, hat die Factory-Klasse nur sich selbst. Der Mangel besteht darin, sich an alle Veränderungen anzupassen, indem man unverändert bleibt.
Diese Fabrikklasse konzentriert die gesamte Produkterstellungslogik und bildet eine allmächtige Klasse (auch Gottklasse genannt), die alles weiß. Wenn mit dieser Klasse etwas schief geht, wird die gesamte Anwendung stark beeinträchtigt.
Wenn ein Produkt über mehrere Schnittstellen verfügt, kann es schwierig sein zu bestimmen, welche Produktklasseninstanz unter welchen Bedingungen erstellt werden soll.
Für Fabriken ist das Hinzufügen neuer Produkte ein schmerzhafter Prozess. Die Fabrikrolle muss jedes Produkt kennen, wissen, wie es hergestellt wird und wann es den Kunden zur Verfügung gestellt werden muss. Mit anderen Worten: Die Annahme neuer Produkte bedeutet, den Quellcode dieser Fabrikrolle zu ändern. Einfache Fabriken unterstützen das Offen-Geschlossen-Prinzip nur bedingt.
Da das einfache Factory-Muster statische Methoden als Factory-Methoden verwendet und statische Methoden nicht von Unterklassen geerbt werden können, kann die Factory-Rolle keine hierarchische Struktur basierend auf Vererbung bilden. Dieser Mangel wird im Factory-Methodenmuster behoben.

1.1.4.7 Anwendung eines einfachen Fabrikmusters in Java
DateFormat und einfaches Fabrikmuster
XMLReaderFactory und einfaches Fabrikmuster in der SAX2-Bibliothek

1.1.4.8 Nuwa macht Menschen aus Erde
Nuwa muss Menschen aus Erde machen. Dies ist die Anwendung des einfachen Fabrikmusters:

Nuwa ist eine Fabrikfigur, Menschen sind abstrakte Produktfiguren und Zhang San und Li Si sind Produkte. Auf die konkrete Umsetzung wird hier nicht näher eingegangen, sondern auf das Beispiel eines Obstanbaugärtners verwiesen.

Weitere Artikel zu einfachen Fabrikmustern für Java-Designmuster finden Sie auf der chinesischen PHP-Website!