logo

TechCodeview

Patrón de diseño del método de fábrica en Java

Es un patrón de diseño creacional que habla de la creación de un objeto. El patrón de diseño de fábrica dice que se debe definir una interfaz (una interfaz Java o una clase abstracta) para crear el objeto y dejar que las subclases decidan qué clase crear una instancia.

método de fábrica



Temas importantes para el patrón de diseño del método Factory en Java

¿Qué es el patrón de diseño del método de fábrica en Java?

El patrón de diseño del método de fábrica define una interfaz para crear un objeto, pero deja que la subclase decida qué clase crear una instancia. El método Factory permite que una clase difiera la creación de instancias a una subclase.

¿Qué-es-el-patrón-de-diseño-del-método-de-fábrica?



A continuación se muestra la explicación de la imagen de arriba:

actriz de cine kajal
  • El método de fábrica en la interfaz permite que una clase difiera la creación de instancias a una o más subclases concretas.
  • Dado que estos patrones de diseño hablan de la creación de instancias de un objeto, se incluyen en la categoría de patrón de diseño creacional.
  • Si notamos el nombre Método de fábrica , eso significa que hay un método que es una fábrica y, en general, las fábricas están involucradas con cosas de creación y aquí con esto, se está creando un objeto.
  • Es una de las mejores formas de crear un objeto donde la lógica de creación del objeto está oculta al cliente. Ahora veamos la implementación.

¿Cuándo utilizar el patrón de diseño del método de fábrica en Java?

El patrón de diseño del método de fábrica se puede utilizar en Java en los siguientes casos:

  • Una clase no puede predecir el tipo de objetos que necesita crear.
  • Una clase quiere que sus subclases especifiquen los objetos que crea.
  • Las clases delegan la responsabilidad a una de las múltiples subclases auxiliares, y el objetivo es mantener la información sobre qué subclase auxiliar es la delegada dentro de un ámbito o ubicación específica.

Componentes clave del patrón de diseño del método de fábrica

Componente-clave-del-patrón-de-diseño-del-método-de-fábrica-en-Java



Producto

  • Es una clase o interfaz abstracta que define las operaciones comunes para los objetos que creará la fábrica.
  • Los Productos Concretos son las clases reales que implementan la interfaz del Producto, cada una de las cuales representa un tipo específico de objeto que se creará.

Creador

  • Es una clase o interfaz abstracta que declara el método de fábrica.
  • Este método es responsable de crear objetos Producto, pero delega la creación real a subclases.

Creadores concretos

  • Estas son subclases del Creador que implementan el método de fábrica.
  • Ellos deciden qué producto de hormigón específico crear, a menudo en función de los parámetros de entrada o la configuración.

Método de fábrica

  • Es un método definido en la clase Creator que se encarga de crear objetos Producto.
  • Por lo general, se declara abstracto en el Creador y se implementa en los Creadores concretos.

Ejemplo de patrón de diseño de método de fábrica en Java

Planteamiento del problema

Está desarrollando un sistema de software para una plataforma de comercio electrónico que trata varios tipos de productos. Cada categoría de producto (por ejemplo, electrónica, ropa, libros) requiere un manejo específico durante la creación. Sin embargo, desea desacoplar el código del cliente de la lógica concreta de creación del producto para mejorar la flexibilidad y la capacidad de mantenimiento. Además, desea permitir una extensión sencilla agregando nuevos tipos de productos en el futuro sin modificar el código existente.

Solución usando clase abstracta

El problema anterior se puede resolver utilizando el patrón de diseño del método de fábrica:

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

>

>

Producción 

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

Solución usando interfaz

El problema anterior se puede resolver utilizando el patrón de diseño del método de fábrica:

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

>

>

Producción 

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

Casos de uso del patrón de diseño del método Factory en Java

A continuación se muestran algunas aplicaciones comunes del patrón Factory Method Design en Java:

  • Marcos creacionales:
    • JDBC (Java Database Connectivity) utiliza ampliamente fábricas para crear conexiones, declaraciones y conjuntos de resultados. Los marcos de inyección de dependencia como Spring y Guice dependen en gran medida de las fábricas para crear y administrar beans.
  • Kits de herramientas GUI:
    • Swing y JavaFX utilizan fábricas para crear componentes de interfaz de usuario como botones, campos de texto y etiquetas, lo que permite la personalización y flexibilidad en el diseño de la interfaz de usuario.
  • Marcos de registro:
    • Los marcos de registro como Log4j y Logback utilizan fábricas para crear registradores con diferentes configuraciones, lo que permite controlar los niveles de registro y los destinos de salida.
  • Serialización y deserialización:
    • Los marcos de serialización de objetos a menudo utilizan fábricas para crear objetos a partir de datos serializados, admitiendo diferentes formatos de serialización y control de versiones.
  • Sistemas de complementos:
    • Los sistemas basados ​​en complementos suelen utilizar fábricas para cargar y crear instancias de complementos de forma dinámica, lo que permite la extensibilidad y personalización.
  • Desarrollo de juegos:
    • Los motores de juegos suelen utilizar fábricas para crear diferentes tipos de objetos, personajes y niveles de juego, promoviendo la organización y la flexibilidad del código.
  • Desarrollo web:
    • Los marcos web a veces utilizan fábricas para crear componentes de vista, controladores y servicios, lo que permite la modularidad y la capacidad de prueba en las aplicaciones web.

Ventajas del patrón de diseño del método de fábrica en Java

Las ventajas del patrón de diseño del método de fábrica en Java son:

  • Desacoplamiento: Separa la lógica de creación de objetos del código del cliente que utiliza esos objetos. Esto hace que el código sea más flexible y fácil de mantener porque los cambios en el proceso de creación no requieren modificaciones en el código del cliente.
  • Extensibilidad: Es fácil introducir nuevos tipos de productos sin cambiar el código del cliente. Simplemente necesita crear una nueva subclase de Concrete Creator e implementar el método de fábrica para producir el nuevo producto.
  • Comprobabilidad: Simplifica las pruebas unitarias al permitirle simular o eliminar la creación de productos durante las pruebas. Puede probar diferentes implementaciones de productos de forma aislada sin depender de la creación real de objetos.
  • Reutilización del código: El método de fábrica se puede reutilizar en diferentes partes de la aplicación donde se necesita la creación de objetos. Esto promueve la centralización y reutilización de la lógica de creación de objetos.
  • Encapsulación: Oculta las clases de productos concretas del código del cliente, haciendo que el código sea menos dependiente de implementaciones específicas. Esto mejora la mantenibilidad y reduce el acoplamiento.

Desventajas del patrón de diseño del método de fábrica en Java

Las desventajas del patrón de diseño del método de fábrica en Java son:

  • Mayor complejidad: Introduce clases e interfaces adicionales, agregando una capa de abstracción que puede hacer que el código sea más complejo de entender y mantener, especialmente para aquellos que no están familiarizados con el patrón.
  • Gastos generales: El uso de polimorfismo y enlace dinámico puede afectar levemente el rendimiento, aunque esto suele ser insignificante en la mayoría de las aplicaciones.
  • Acoplamiento estrecho dentro de las jerarquías de productos: Los creadores de hormigón todavía están estrechamente vinculados a sus correspondientes productos de hormigón. Los cambios en uno a menudo requieren cambios en el otro.
  • Dependencia de subclases concretas: El código del cliente todavía depende de la clase abstracta Creator, lo que requiere conocimiento de sus subclases concretas para realizar llamadas correctas al método de fábrica.
  • Potencial de uso excesivo: Es importante utilizar el patrón Factory Method con prudencia para evitar realizar demasiada ingeniería en la aplicación. La creación de objetos simples a menudo se puede realizar directamente sin necesidad de una fábrica.
  • Desafíos de prueba: Probar la lógica de la fábrica en sí puede ser más complejo.

Conclusión

Hasta ahora hemos aprendido qué es el patrón de diseño del método Factory y cómo implementarlo. Creo que ahora comprendemos bastante las ventajas de este mecanismo de diseño. Los métodos de fábrica están presentes en los marcos y kits de herramientas. El ejemplo del documento anterior es un uso típico en MacApp y ET++.

Leer más : Tutorial de patrones de diseño de Java