logo

TechCodeview

Patró de disseny del mètode de fàbrica en Java

És un patró de disseny creatiu que parla de la creació d'un objecte. El patró de disseny de fàbrica diu que cal definir una interfície (una interfície java o una classe abstracta) per crear l'objecte i deixar que les subclasses decideixin quina classe instància.

mètode de fàbrica



Temes importants per al patró de disseny del mètode Factory a Java

Què és el patró de disseny del mètode de fàbrica a Java?

Factory Method Design Pattern defineix una interfície per crear un objecte, però deixa que la subclasse decideixi quina classe instància. El mètode Factory permet a una classe diferir la instanciació a la subclasse.

Què és el patró de disseny del mètode de fàbrica



A continuació es mostra l'explicació de la imatge anterior:

  • El mètode de fàbrica a la interfície permet a una classe diferir la instanciació a una o més subclasses concretes.
  • Com que aquests patrons de disseny parlen de la instanciació d'un objecte, entren dins de la categoria de patró de disseny creatiu.
  • Si observem el nom Mètode de fàbrica , això vol dir que hi ha un mètode que és una fàbrica i, en general, les fàbriques estan involucrades amb coses de creació i aquí amb això, s'està creant un objecte.
  • És una de les millors maneres de crear un objecte on la lògica de creació d'objectes està oculta al client. Ara mirem la implementació.

Quan utilitzar el patró de disseny del mètode de fàbrica a Java?

El patró de disseny del mètode de fàbrica es pot utilitzar a Java en els casos següents:

  • Una classe no pot predir el tipus d'objectes que necessita per crear.
  • Una classe vol que les seves subclasses especifiquen els objectes que crea.
  • Les classes deleguen la responsabilitat a una de les múltiples subclasses d'ajuda i l'objectiu és mantenir la informació sobre quina subclasse d'ajuda és el delegat dins d'un àmbit o ubicació específics.

Components clau del patró de disseny del mètode de fàbrica

Patró de disseny del mètode de component clau de fàbrica a Java



Producte

  • És una classe o interfície abstracta que defineix les operacions comunes per als objectes que crearà la fàbrica.
  • Els productes concrets són les classes reals que implementen la interfície Producte, cadascuna representant un tipus específic d'objecte a crear.

Creador

  • És una classe o interfície abstracta que declara el mètode de fàbrica.
  • Aquest mètode és responsable de crear objectes Product, però delega la creació real a subclasses.

Creadors concrets

  • Aquestes són subclasses del Creator que implementen el mètode de fàbrica.
  • Ells decideixen quin producte concret de formigó crear, sovint en funció dels paràmetres d'entrada o de la configuració.

Mètode de fàbrica

  • És un mètode definit a la classe Creator que s'encarrega de crear objectes Product.
  • Normalment es declara com a abstracte a Creator i s'implementa a Concrete Creators.

Exemple de patró de disseny del mètode de fàbrica a Java

Plantejament del problema

Esteu desenvolupant un sistema de programari per a una plataforma de comerç electrònic que tracta diversos tipus de productes. Cada categoria de producte (p. ex., electrònica, roba, llibres) requereix un tractament específic durant la creació. Tanmateix, voleu desacoblar el codi del client de la lògica de creació de productes concrets per millorar la flexibilitat i el manteniment. A més, voleu permetre una extensió fàcil afegint nous tipus de producte en el futur sense modificar el codi existent.

10 per cent de 60

Solució utilitzant la classe abstracta

El problema anterior es pot resoldre mitjançant 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();> >}> }> 

>

>

Sortida 

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

Solució mitjançant la interfície

El problema anterior es pot resoldre mitjançant 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();> >}> }> 

>

>

Sortida 

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

Casos d'ús del patró de disseny del mètode de fàbrica a Java

A continuació es mostren algunes aplicacions habituals del patró Factory Method Design a Java:

  • Marcs de creació:
    • JDBC (Java Database Connectivity) utilitza àmpliament les fàbriques per crear connexions, declaracions i conjunts de resultats. Els marcs d'injecció de dependència com Spring i Guice depenen molt de les fàbriques per crear i gestionar beans.
  • Kits d'eines GUI:
    • Swing i JavaFX utilitzen fàbriques per crear components d'interfície d'usuari com botons, camps de text i etiquetes, cosa que permet la personalització i la flexibilitat en el disseny de la interfície d'usuari.
  • Marcs de registre:
    • Els marcs de registre com Log4j i Logback utilitzen fàbriques per crear registradors amb diferents configuracions, cosa que permet controlar els nivells de registre i les destinacions de sortida.
  • Serialització i deserialització:
    • Els marcs de serialització d'objectes sovint utilitzen fàbriques per crear objectes a partir de dades serialitzades, donant suport a diferents formats de serialització i versions.
  • Sistemes de connectors:
    • Els sistemes basats en connectors sovint utilitzen fàbriques per carregar i crear instàncies de connectors de forma dinàmica, cosa que permet l'extensibilitat i la personalització.
  • Desenvolupament del joc:
    • Els motors de joc sovint utilitzen fàbriques per crear diferents tipus d'objectes, personatges i nivells de joc, promovent l'organització i la flexibilitat del codi.
  • Desenvolupament web:
    • Els marcs web de vegades utilitzen fàbriques per crear components de visualització, controladors i serveis, la qual cosa permet la modularitat i la provabilitat a les aplicacions web.

Avantatges del patró de disseny del mètode de fàbrica a Java

Els avantatges de Factory Method Design Pattern a Java són:

  • Desacoblament: Separa la lògica de creació d'objectes del codi de client que utilitza aquests objectes. Això fa que el codi sigui més flexible i fàcil de mantenir perquè els canvis al procés de creació no requereixen modificacions al codi del client.
  • Extensibilitat: És fàcil introduir nous tipus de producte sense canviar el codi del client. Només cal que creeu una nova subclasse de Concrete Creator i implementeu el mètode de fàbrica per produir el nou producte.
  • Testabilitat: Simplifica les proves d'unitat, ja que us permet burlar-vos o eliminar la creació de productes durant les proves. Podeu provar diferents implementacions de productes de manera aïllada sense dependre de la creació real d'objectes.
  • Reutilitzabilitat del codi: El mètode de fàbrica es pot reutilitzar en diferents parts de l'aplicació on es necessita la creació d'objectes. Això promou la centralització i la reutilització de la lògica de creació d'objectes.
  • Encapsulació: Oculta les classes de producte concretes del codi del client, fent que el codi sigui menys dependent d'implementacions específiques. Això millora el manteniment i redueix l'acoblament.

Desavantatges del patró de disseny del mètode de fàbrica a Java

Els inconvenients de Factory Method Design Pattern a Java són:

  • Augment de la complexitat: Introdueix classes i interfícies addicionals, afegint una capa d'abstracció que pot fer que el codi sigui més complex d'entendre i mantenir, especialment per a aquells que no estan familiaritzats amb el patró.
  • Càrrec: L'ús de polimorfisme i unió dinàmica pot afectar lleugerament el rendiment, tot i que sovint és insignificant en la majoria d'aplicacions.
  • Acoblament estret dins de les jerarquies de productes: Els creadors de formigó encara estan estretament vinculats als seus productes de formigó corresponents. Els canvis a un sovint requereixen canvis a l'altre.
  • Dependència de subclasses concretes: El codi del client encara depèn de la classe Creator abstracta, que requereix el coneixement de les seves subclasses concretes per fer trucades de mètodes de fàbrica correctes.
  • Potencial d'ús excessiu: És important utilitzar el patró del mètode de fàbrica amb criteri per evitar una enginyeria excessiva de l'aplicació. La creació simple d'objectes sovint es pot gestionar directament sense necessitat d'una fàbrica.
  • Reptes de prova: Provar la lògica de fàbrica en si pot ser més complex.

Conclusió

Fins ara hem après què és el patró de disseny del mètode Factory i com implementar-lo. Crec que ara tenim una bona comprensió de l'avantatge d'aquest mecanisme de disseny. Els mètodes de fàbrica impregnen conjunts d'eines i marcs. L'exemple del document anterior és un ús típic a MacApp i ET++.

Llegeix més : Tutorial de patrons de disseny de Java