logo

TechCodeview

Entwurfsmuster für Factory-Methoden in Java

es ist ein kreatives Designmuster das spricht von der Schaffung eines Objekts. Das Factory-Design-Muster sieht vor, eine Schnittstelle (eine Java-Schnittstelle oder eine abstrakte Klasse) zum Erstellen des Objekts zu definieren und die Unterklassen entscheiden zu lassen, welche Klasse instanziiert werden soll.

Fabrik-Methode



Wichtige Themen für das Factory-Methodenentwurfsmuster in Java

Was ist das Factory-Methodenentwurfsmuster in Java?

Factory Method Design Pattern definiert eine Schnittstelle zum Erstellen eines Objekts, lässt aber die Unterklasse entscheiden, welche Klasse instanziiert werden soll. Mit der Factory-Methode kann eine Klasse die Instanziierung auf eine Unterklasse verschieben.

Was-ist-Factory-Method-Design-Pattern



Nachfolgend finden Sie die Erklärung des obigen Bildes:

  • Mit der Factory-Methode in der Schnittstelle kann eine Klasse die Instanziierung auf eine oder mehrere konkrete Unterklassen verschieben.
  • Da es bei diesen Entwurfsmustern um die Instanziierung eines Objekts geht, fallen sie in die Kategorie der schöpferischen Entwurfsmuster.
  • Wenn uns der Name auffällt Fabrikmethode Das bedeutet, dass es eine Methode gibt, die eine Fabrik ist, und im Allgemeinen sind Fabriken an schöpferischen Dingen beteiligt, und hiermit wird ein Objekt erstellt.
  • Dies ist eine der besten Möglichkeiten, ein Objekt zu erstellen, bei dem die Objekterstellungslogik für den Client verborgen bleibt. Schauen wir uns nun die Implementierung an.

Wann sollte das Factory Method Design Pattern in Java verwendet werden?

Das Entwurfsmuster für Factory-Methoden kann in Java in folgenden Fällen verwendet werden:

  • Eine Klasse kann die Art der Objekte, die sie erstellen muss, nicht vorhersagen.
  • Eine Klasse möchte, dass ihre Unterklassen die von ihr erstellten Objekte angeben.
  • Klassen delegieren die Verantwortung an eine von mehreren Hilfsunterklassen, und Sie möchten, dass die Informationen darüber, welche Hilfsunterklasse der Delegierte ist, innerhalb eines bestimmten Bereichs oder Standorts bleiben.

Schlüsselkomponenten des Entwurfsmusters für Fabrikmethoden

Schlüsselkomponente des Factory-Method-Design-Patterns in Java



Produkt

  • Es handelt sich um eine abstrakte Klasse oder Schnittstelle, die die allgemeinen Operationen für die Objekte definiert, die die Factory erstellt.
  • Konkrete Produkte sind die eigentlichen Klassen, die die Produktschnittstelle implementieren und jeweils einen bestimmten Typ des zu erstellenden Objekts darstellen.

Schöpfer

  • Es handelt sich um eine abstrakte Klasse oder Schnittstelle, die die Factory-Methode deklariert.
  • Diese Methode ist für die Erstellung von Produktobjekten verantwortlich, delegiert die eigentliche Erstellung jedoch an Unterklassen.

Konkrete Schöpfer

  • Dies sind Unterklassen des Creators, die die Factory-Methode implementieren.
  • Sie entscheiden, welches konkrete Betonprodukt erstellt werden soll, häufig basierend auf Eingabeparametern oder der Konfiguration.

Fabrikmethode

  • Es handelt sich um eine in der Creator-Klasse definierte Methode, die für die Erstellung von Produktobjekten verantwortlich ist.
  • Normalerweise wird es im Creator als abstrakt deklariert und in den Concrete Creators implementiert.

Beispiel für ein Factory-Methodenentwurfsmuster in Java

Problemstellung

Sie entwickeln ein Softwaresystem für eine E-Commerce-Plattform, die verschiedene Arten von Produkten abwickelt. Jede Produktkategorie (z. B. Elektronik, Kleidung, Bücher) erfordert eine spezifische Handhabung bei der Erstellung. Sie möchten jedoch den Client-Code von der konkreten Produkterstellungslogik entkoppeln, um die Flexibilität und Wartbarkeit zu verbessern. Darüber hinaus möchten Sie eine einfache Erweiterung ermöglichen, indem Sie in Zukunft neue Produkttypen hinzufügen, ohne den vorhandenen Code zu ändern.

Wählen Sie Multi-Table-SQL aus

Lösung mit abstrakter Klasse

Das obige Problem kann mit dem Factory Method Design Pattern gelöst werden:

Java


enthält in string



// Abstract Product Class> abstract> class> Product {> >public> abstract> void> display();> }> // Concrete Products> class> ConcreteProductA>extends> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product A.'>);> >}> }> class> ConcreteProductB>extends> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product B.'>);> >}> }> // Creator Abstract Class> abstract> class> Creator {> >public> abstract> Product factoryMethod();> }> // Concrete Creators> class> ConcreteCreatorA>extends> Creator {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductA();> >}> }> class> ConcreteCreatorB>extends> Creator {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductB();> >}> }> // Client Code> public> class> FactoryMethodExample {> >public> static> void> main(String[] args) {> >Creator creatorA =>new> ConcreteCreatorA();> >Product productA = creatorA.factoryMethod();> >productA.display();> >Creator creatorB =>new> ConcreteCreatorB();> >Product productB = creatorB.factoryMethod();> >productB.display();> >}> }> 

>

>

Ausgabe

10 hoch 6 
This is Concrete Product A. This is Concrete Product B.>

Lösung mit Schnittstelle

Das obige Problem kann mit dem Factory Method Design Pattern gelöst werden:

Java




// Product Interface> interface> Product {> >void> display();> }> // Concrete Products> class> ConcreteProductA>implements> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product A.'>);> >}> }> class> ConcreteProductB>implements> Product {> >@Override> >public> void> display() {> >System.out.println(>'This is Concrete Product B.'>);> >}> }> // Factory Interface> interface> Factory {> >Product factoryMethod();> }> // Concrete Factories> class> ConcreteFactoryA>implements> Factory {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductA();> >}> }> class> ConcreteFactoryB>implements> Factory {> >@Override> >public> Product factoryMethod() {> >return> new> ConcreteProductB();> >}> }> // Client Code> public> class> FactoryMethodExample {> >public> static> void> main(String[] args) {> >Factory factoryA =>new> ConcreteFactoryA();> >Product productA = factoryA.factoryMethod();> >productA.display();> >Factory factoryB =>new> ConcreteFactoryB();> >Product productB = factoryB.factoryMethod();> >productB.display();> >}> }> 

>

np.linspace 
>

Ausgabe 

This is Concrete Product A. This is Concrete Product B.>

Anwendungsfälle des Factory Method Design Patterns in Java

Hier sind einige häufige Anwendungen des Factory Method Design-Musters in Java:

  • Kreationsrahmen:
    • JDBC (Java Database Connectivity) nutzt Factorys in großem Umfang zum Erstellen von Verbindungen, Anweisungen und Ergebnismengen. Dependency-Injection-Frameworks wie Spring und Guice verlassen sich bei der Erstellung und Verwaltung von Beans stark auf Fabriken.
  • GUI-Toolkits:
    • Swing und JavaFX verwenden Fabriken, um UI-Komponenten wie Schaltflächen, Textfelder und Beschriftungen zu erstellen, was eine individuelle Anpassung und Flexibilität beim UI-Design ermöglicht.
  • Protokollierungs-Frameworks:
    • Protokollierungsframeworks wie Log4j und Logback verwenden Fabriken, um Logger mit unterschiedlichen Konfigurationen zu erstellen und so die Kontrolle über Protokollierungsstufen und Ausgabeziele zu ermöglichen.
  • Serialisierung und Deserialisierung:
    • Objektserialisierungs-Frameworks verwenden häufig Fabriken, um Objekte aus serialisierten Daten zu erstellen, und unterstützen dabei verschiedene Serialisierungsformate und Versionierung.
  • Plugin-Systeme:
    • Plugin-basierte Systeme verwenden häufig Fabriken, um Plugin-Instanzen dynamisch zu laden und zu erstellen und so Erweiterbarkeit und Anpassung zu ermöglichen.
  • Spieleentwicklung:
    • Spiel-Engines verwenden häufig Fabriken, um verschiedene Arten von Spielobjekten, Charakteren und Levels zu erstellen und so die Organisation und Flexibilität des Codes zu fördern.
  • Web Entwicklung:
    • Web-Frameworks verwenden manchmal Fabriken, um Ansichtskomponenten, Controller und Dienste zu erstellen und so Modularität und Testbarkeit in Webanwendungen zu ermöglichen.

Vorteile des Factory Method Design Patterns in Java

Die Vorteile des Factory Method Design Pattern in Java sind:

  • Entkopplung: Es trennt die Objekterstellungslogik vom Clientcode, der diese Objekte verwendet. Dadurch wird der Code flexibler und wartbarer, da Änderungen am Erstellungsprozess keine Änderungen am Client-Code erfordern.
  • Erweiterbarkeit: Es ist einfach, neue Produkttypen einzuführen, ohne den Client-Code zu ändern. Sie müssen lediglich eine neue Concrete Creator-Unterklasse erstellen und die Factory-Methode implementieren, um das neue Produkt herzustellen.
  • Testbarkeit: Es vereinfacht Unit-Tests, indem es Ihnen ermöglicht, die Produkterstellung während der Tests zu simulieren oder auszublenden. Sie können verschiedene Produktimplementierungen isoliert testen, ohne sich auf die tatsächliche Objekterstellung verlassen zu müssen.
  • Wiederverwendbarkeit des Codes: Die Factory-Methode kann in verschiedenen Teilen der Anwendung wiederverwendet werden, in denen eine Objekterstellung erforderlich ist. Dies fördert die Zentralisierung und Wiederverwendung der Objekterstellungslogik.
  • Verkapselung: Es verbirgt die konkreten Produktklassen vor dem Client-Code, wodurch der Code weniger von bestimmten Implementierungen abhängig wird. Dies verbessert die Wartbarkeit und reduziert die Kopplung.

Nachteile des Factory-Methodenentwurfsmusters in Java

Die Nachteile des Factory Method Design Pattern in Java sind:

  • Erhöhte Komplexität: Es führt zusätzliche Klassen und Schnittstellen ein und fügt eine Abstraktionsebene hinzu, die das Verständnis und die Wartung des Codes komplexer machen kann, insbesondere für diejenigen, die mit dem Muster nicht vertraut sind.
  • Gemeinkosten: Die Verwendung von Polymorphismus und dynamischer Bindung kann sich leicht auf die Leistung auswirken, obwohl dies in den meisten Anwendungen oft vernachlässigbar ist.
  • Enge Kopplung innerhalb der Produkthierarchien: Betonschöpfer sind immer noch eng mit ihren entsprechenden Betonprodukten verbunden. Änderungen an dem einen erfordern oft Änderungen am anderen.
  • Abhängigkeit von konkreten Unterklassen: Der Client-Code hängt immer noch von der abstrakten Creator-Klasse ab und erfordert Kenntnisse über ihre konkreten Unterklassen, um korrekte Factory-Methodenaufrufe durchzuführen.
  • Potenzial für Überbeanspruchung: Es ist wichtig, das Factory-Methodenmuster mit Bedacht einzusetzen, um eine Überentwicklung der Anwendung zu vermeiden. Die einfache Objekterstellung kann oft direkt durchgeführt werden, ohne dass eine Factory erforderlich ist.
  • Herausforderungen beim Testen: Das Testen der Fabriklogik selbst kann komplexer sein.

Abschluss

Bisher haben wir gelernt, was ein Factory-Methodenentwurfsmuster ist und wie man es implementiert. Ich glaube, wir haben jetzt ein gutes Verständnis für die Vorteile dieses Designmechanismus. Factory-Methoden durchdringen Toolkits und Frameworks. Das vorangehende Dokumentbeispiel ist eine typische Verwendung in MacApp und ET++.

Weiterlesen : Tutorial zu Java-Designmustern