logo

TechCodeview

Fabriksmetode designmønster i Java

Det er en kreativt designmønster der taler om skabelsen af ​​et objekt. Fabriksdesignmønsteret siger, at man skal definere en grænseflade (En java-grænseflade eller en abstrakt klasse) til at skabe objektet og lade underklasserne bestemme, hvilken klasse der skal instansieres.

fabriksmetode



Vigtige emner for Factory-metodens designmønster i Java

Hvad er Factory Method Design Pattern i Java?

Factory Method Design Pattern definerer en grænseflade til at skabe et objekt, men lad underklassen bestemme, hvilken klasse der skal instansieres. Factory Method lader en klasse udskyde instansiering til underklasse.

Hvad-er-fabriksmetode-design-mønster



streng og understreng

Nedenfor er forklaringen af ​​ovenstående billede:

  • Fabriksmetoden i grænsefladen lader en klasse udskyde instansieringen til en eller flere konkrete underklasser.
  • Da disse designmønstre taler om instansieringen af ​​et objekt, falder de ind under kategorien kreativt designmønster.
  • Hvis vi bemærker navnet Fabriksmetode , det betyder, at der er en metode, som er en fabrik, og generelt er fabrikker involveret med kreative ting, og her med dette bliver et objekt skabt.
  • Det er en af ​​de bedste måder at skabe et objekt, hvor logikken til oprettelse af objekter er skjult for klienten. Lad os nu se på implementeringen.

Hvornår skal man bruge Factory Method Design Pattern i Java?

Fabriksmetodedesignmønster kan bruges i java i følgende tilfælde:

  • En klasse kan ikke forudsige den type objekter, den skal oprette.
  • En klasse ønsker, at dens underklasser skal specificere de objekter, den opretter.
  • Klasser uddelegerer ansvaret til en af ​​flere hjælperunderklasser, og du sigter efter at holde informationen om, hvilken hjælperunderklasse, der er delegeret, inden for et specifikt område eller sted.

Nøglekomponenter i Factory Method Design Pattern

Nøgle-komponent-af-fabrik-metode-design-mønster-i-Java



Produkt

  • Det er en abstrakt klasse eller grænseflade, der definerer de fælles operationer for de objekter, som fabrikken vil skabe.
  • Konkrete produkter er de faktiske klasser, der implementerer produktgrænsefladen, som hver repræsenterer en bestemt type objekt, der skal oprettes.

Skaber

  • Det er en abstrakt klasse eller grænseflade, der erklærer fabriksmetoden.
  • Denne metode er ansvarlig for at skabe produktobjekter, men den delegerer selve oprettelsen til underklasser.

Betonskabere

  • Disse er underklasser af Skaberen, der implementerer fabriksmetoden.
  • De beslutter, hvilket specifikt betonprodukt, der skal oprettes, ofte baseret på inputparametre eller konfiguration.

Fabriksmetode

  • Det er en metode defineret i Creator-klassen, der er ansvarlig for at skabe produktobjekter.
  • Det er typisk erklæret som abstrakt i skaberen og implementeret i de konkrete skabere.

Eksempel på fabriksmetode designmønster i Java

Problemformulering

Du er ved at udvikle et softwaresystem til en e-handelsplatform, der omhandler forskellige typer produkter. Hver produktkategori (f.eks. elektronik, tøj, bøger) kræver specifik håndtering under oprettelsen. Du vil dog afkoble klientkoden fra den konkrete produktskabelseslogik for at øge fleksibiliteten og vedligeholdelsen. Derudover vil du give mulighed for nem udvidelse ved at tilføje nye produkttyper i fremtiden uden at ændre eksisterende kode.

Løsning ved hjælp af abstrakt klasse

Ovenstående problem kan løses ved hjælp af 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();> >}> }> 

>

ls kommandoer linux 
>

Produktion 

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

Løsning ved hjælp af grænseflade

Ovenstående problem kan løses ved hjælp af Factory Method Design Pattern:

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.>

Brug eksempler på Factory Method Design Pattern i Java

Her er nogle almindelige anvendelser af Factory Method Design-mønsteret i Java:

  • Kreative rammer:
    • JDBC (Java Database Connectivity) bruger fabrikker i vid udstrækning til at skabe forbindelser, udsagn og resultatsæt. Afhængighedsinjektionsrammer som Spring og Guice er stærkt afhængige af fabrikker til at skabe og administrere bønner.
  • GUI-værktøjssæt:
    • Swing og JavaFX bruger fabrikker til at skabe UI-komponenter som knapper, tekstfelter og etiketter, hvilket giver mulighed for tilpasning og fleksibilitet i UI-design.
  • Logningsrammer:
    • Logningsrammer som Log4j og Logback bruger fabrikker til at skabe loggere med forskellige konfigurationer, hvilket muliggør kontrol over logningsniveauer og outputdestinationer.
  • Serialisering og deserialisering:
    • Objektserialiseringsrammer bruger ofte fabrikker til at skabe objekter ud fra serialiserede data, der understøtter forskellige serialiseringsformater og versionering.
  • Plugin-systemer:
    • Plugin-baserede systemer bruger ofte fabrikker til at indlæse og skabe plugin-forekomster dynamisk, hvilket giver mulighed for udvidelse og tilpasning.
  • Spiludvikling:
    • Spilmotorer bruger ofte fabrikker til at skabe forskellige typer spilobjekter, karakterer og niveauer, hvilket fremmer kodeorganisering og fleksibilitet.
  • Web-udvikling:
    • Webframeworks bruger nogle gange fabrikker til at skabe visningskomponenter, controllere og tjenester, hvilket muliggør modularitet og testbarhed i webapplikationer.

Fordele ved Factory Method Design Pattern i Java

Fordelene ved Factory Method Design Pattern i Java er:

  • Afkobling: Det adskiller objektoprettelseslogik fra klientkoden, der bruger disse objekter. Dette gør koden mere fleksibel og vedligeholdelig, fordi ændringer i oprettelsesprocessen ikke kræver ændringer af klientkoden.
  • Udvidelsesmuligheder: Det er nemt at introducere nye produkttyper uden at ændre klientkoden. Du skal blot oprette en ny Concrete Creator-underklasse og implementere fabriksmetoden til at producere det nye produkt.
  • Testbarhed: Det forenkler enhedstestning ved at give dig mulighed for at håne eller udligne produktskabelse under test. Du kan teste forskellige produktimplementeringer isoleret uden at stole på faktisk oprettelse af objekter.
  • Genanvendelighed af kode: Fabriksmetoden kan genbruges i forskellige dele af applikationen, hvor det er nødvendigt at oprette objekter. Dette fremmer centralisering og genbrug af objektskabelseslogik.
  • Indkapsling: Det skjuler de konkrete produktklasser fra klientkoden, hvilket gør koden mindre afhængig af specifikke implementeringer. Dette forbedrer vedligeholdelsesevnen og reducerer koblingen.

Ulemper ved Factory Method Design Pattern i Java

Ulemperne ved Factory Method Design Pattern i Java er:

hvornår blev skolen opfundet
  • Øget kompleksitet: Det introducerer yderligere klasser og grænseflader og tilføjer et lag af abstraktion, der kan gøre koden mere kompleks at forstå og vedligeholde, især for dem, der ikke er bekendt med mønsteret.
  • Overhead: Brugen af ​​polymorfi og dynamisk binding kan påvirke ydeevnen lidt, selvom dette ofte er ubetydeligt i de fleste applikationer.
  • Tæt kobling inden for produkthierarkier: Betonskabere er stadig tæt knyttet til deres tilsvarende betonprodukter. Ændringer i den ene kræver ofte ændringer i den anden.
  • Afhængighed af konkrete underklasser: Klientkoden afhænger stadig af den abstrakte Creator-klasse, der kræver viden om dens konkrete underklasser for at foretage korrekte fabriksmetodekald.
  • Potentiale for overforbrug: Det er vigtigt at bruge Factory Method-mønsteret med omtanke for at undgå at overkonstruere applikationen. Enkel oprettelse af objekter kan ofte håndteres direkte uden behov for en fabrik.
  • Test udfordringer: Test af selve fabrikslogikken kan være mere kompleks.

Konklusion

Indtil videre har vi lært, hvad der er Factory-metodedesignmønster, og hvordan man implementerer det. Jeg tror nu, vi har en rimelig forståelse af fordelen ved denne designmekanisme. Fabriksmetoder gennemsyrer værktøjssæt og rammer. Det foregående dokumenteksempel er typisk brug i MacApp og ET++.

Læs mere : Tutorial til Java-designmønstre