logo

TechCodeview

Fabriksmetod designmönster i Java

Det är en kreativt designmönster som talar om skapandet av ett objekt. Fabriksdesignmönstret säger att man ska definiera ett gränssnitt (Ett java-gränssnitt eller en abstrakt klass) för att skapa objektet och låta underklasserna bestämma vilken klass som ska instansieras.

fabriksmetod



Viktiga ämnen för Factory-metodens designmönster i Java

Vad är fabriksmetodens designmönster i Java?

Factory Method Design Pattern definierar ett gränssnitt för att skapa ett objekt, men låt underklass bestämma vilken klass som ska instansieras. Factory Method låter en klass skjuta upp instansieringen till underklass.

Vad-är-fabriksmetod-designmönster



Nedan är förklaringen av bilden ovan:

  • Fabriksmetoden i gränssnittet låter en klass skjuta upp instansieringen till en eller flera konkreta underklasser.
  • Eftersom dessa designmönster talar om instansieringen av ett objekt hamnar de under kategorin kreativt designmönster.
  • Om vi ​​märker namnet Fabriksmetod , det betyder att det finns en metod som är en fabrik, och i allmänhet är fabriker involverade med skapande saker och här med detta skapas ett objekt.
  • Det är ett av de bästa sätten att skapa ett objekt där logik för objektskapande är dold för klienten. Låt oss nu titta på implementeringen.

När ska man använda Factory Method Design Pattern i Java?

Fabriksmetodens designmönster kan användas i java i följande fall:

listnode java
  • En klass kan inte förutsäga vilken typ av objekt den behöver skapa.
  • En klass vill att dess underklasser ska specificera de objekt den skapar.
  • Klasser delegerar ansvaret till en av flera hjälpunderklasser, och du strävar efter att hålla informationen om vilken hjälpunderklass som är delegaten inom en specifik omfattning eller plats.

Nyckelkomponenter i fabriksmetodens designmönster

Key-Component-of-Factory-Method-Design-Pattern-i-Java



Produkt

  • Det är en abstrakt klass eller gränssnitt som definierar de vanliga operationerna för de objekt som fabriken kommer att skapa.
  • Konkreta produkter är de faktiska klasserna som implementerar produktgränssnittet, var och en representerar en specifik typ av objekt som ska skapas.

Skapare

  • Det är en abstrakt klass eller gränssnitt som deklarerar fabriksmetoden.
  • Denna metod är ansvarig för att skapa produktobjekt, men den delegerar själva skapandet till underklasser.

Konkreta skapare

  • Dessa är underklasser av Skaparen som implementerar fabriksmetoden.
  • De bestämmer vilken specifik betongprodukt som ska skapas, ofta baserat på ingångsparametrar eller konfiguration.

Fabriksmetod

  • Det är en metod definierad i Creator-klassen som är ansvarig för att skapa produktobjekt.
  • Det deklareras vanligtvis som abstrakt i Skaparen och implementeras i de konkreta Skaparna.

Factory Method Design Pattern Exempel i Java

Problembeskrivning

Du utvecklar ett mjukvarusystem för en e-handelsplattform som hanterar olika typer av produkter. Varje produktkategori (t.ex. elektronik, kläder, böcker) kräver specifik hantering under skapandet. Däremot vill du frikoppla klientkoden från logiken för att skapa konkreta produkter för att öka flexibiliteten och underhållbarheten. Dessutom vill du tillåta enkel förlängning genom att lägga till nya produkttyper i framtiden utan att ändra befintlig kod.

python sortering tuplar

Lösning med abstrakt klass

Ovanstående problem kan lösas med Factory Method Design Pattern:

Java




// 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();> >}> }> 

>

>

urval sortera
Produktion 

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

Lösning med gränssnitt

Ovanstående problem kan lösas med Factory Method Design Pattern:

sql flera tabeller välj

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();> >}> }> 

>

>

Produktion 

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

Användningsfall av Factory Method Design Pattern i Java

Här är några vanliga tillämpningar av Factory Method Design-mönstret i Java:

  • Skapande ramar:
    • JDBC (Java Database Connectivity) använder fabriker i stor utsträckning för att skapa anslutningar, uttalanden och resultatuppsättningar. Ramverk för beroendeinjektion som Spring och Guice är starkt beroende av fabriker för att skapa och hantera bönor.
  • GUI Toolkit:
    • Swing och JavaFX använder fabriker för att skapa UI-komponenter som knappar, textfält och etiketter, vilket möjliggör anpassning och flexibilitet i UI-design.
  • Loggningsramar:
    • Loggningsramverk som Log4j och Logback använder fabriker för att skapa loggrar med olika konfigurationer, vilket möjliggör kontroll över loggningsnivåer och utdatadestinationer.
  • Serialisering och deserialisering:
    • Objektserialiseringsramverk använder ofta fabriker för att skapa objekt från serialiserade data, som stöder olika serialiseringsformat och versionshantering.
  • Pluginsystem:
    • Plugin-baserade system använder ofta fabriker för att ladda och skapa plugin-instanser dynamiskt, vilket möjliggör utökning och anpassning.
  • Spelutveckling:
    • Spelmotorer använder ofta fabriker för att skapa olika typer av spelobjekt, karaktärer och nivåer, vilket främjar kodorganisation och flexibilitet.
  • Webbutveckling:
    • Webbramverk använder ibland fabriker för att skapa vykomponenter, kontroller och tjänster, vilket möjliggör modularitet och testbarhet i webbapplikationer.

Fördelar med Factory Method Design Pattern i Java

Fördelarna med Factory Method Design Pattern i Java är:

returtyp i java
  • Frikoppling: Den separerar objektskapande logik från klientkoden som använder dessa objekt. Detta gör koden mer flexibel och underhållbar eftersom ändringar i skapandeprocessen inte kräver modifieringar av klientkoden.
  • Sträckbarhet: Det är enkelt att introducera nya produkttyper utan att ändra kundkoden. Du behöver helt enkelt skapa en ny Concrete Creator-underklass och implementera fabriksmetoden för att producera den nya produkten.
  • Testbarhet: Det förenklar enhetstestning genom att låta dig håna eller stumma produktskapandet under tester. Du kan testa olika produktimplementeringar isolerat utan att förlita dig på faktisk objektskapande.
  • Kodåteranvändbarhet: Fabriksmetoden kan återanvändas i olika delar av applikationen där objektskapande behövs. Detta främjar centralisering och återanvändning av objektskapande logik.
  • Inkapsling: Den döljer de konkreta produktklasserna från klientkoden, vilket gör koden mindre beroende av specifika implementeringar. Detta förbättrar underhållsbarheten och minskar kopplingen.

Nackdelar med Factory Method Design Pattern i Java

Nackdelarna med Factory Method Design Pattern i Java är:

  • Ökad komplexitet: Den introducerar ytterligare klasser och gränssnitt och lägger till ett lager av abstraktion som kan göra koden mer komplex att förstå och underhålla, särskilt för de som inte känner till mönstret.
  • Över huvudet: Användningen av polymorfism och dynamisk bindning kan påverka prestandan något, även om detta ofta är försumbart i de flesta applikationer.
  • Tät koppling inom produkthierarkier: Concrete Creators är fortfarande tätt kopplade till sina motsvarande betongprodukter. Förändringar av den ena kräver ofta förändringar av den andra.
  • Beroende av betongunderklasser: Klientkoden beror fortfarande på den abstrakta Creator-klassen, som kräver kunskap om dess konkreta underklasser för att göra korrekta fabriksmetodanrop.
  • Potential för överanvändning: Det är viktigt att använda Factory Method-mönstret med omtanke för att undvika att överkonstruera applikationen. Enkelt objektskapande kan ofta hanteras direkt utan behov av en fabrik.
  • Testutmaningar: Att testa själva fabrikslogiken kan vara mer komplicerat.

Slutsats

Hittills har vi lärt oss vad som är Factory method design pattern och hur man implementerar det. Jag tror att vi nu har en rättvis förståelse för fördelen med denna designmekanism. Fabriksmetoder genomsyrar verktygssatser och ramverk. Det föregående dokumentexemplet är en typisk användning i MacApp och ET++.

Läs vidare : Handledning för Java-designmönster