Compartir tecnología

Patrón de diseño Patrón de fábrica

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Factory Pattern es un patrón de diseño comúnmente utilizado en la programación orientada a objetos.patrón creacional un poco.El patrón de fábrica se usa principalmente para crear objetos, pero es diferente de usarlo directamente en el código.new La creación de palabras clave se diferencia en que crea objetos a través de una interfaz común, separando así el proceso de creación de objetos del uso de código de cliente. La siguiente es una introducción detallada al patrón de fábrica:

1. Características principales del modelo de fábrica.

  1. El proceso de creación de objetos encapsulados.: Encapsule el proceso de creación de objetos en una clase de fábrica. El cliente solo necesita especificar el tipo de objeto que debe crearse y luego puede obtener el objeto requerido a través de la clase de fábrica sin preocuparse por los detalles de creación específicos del objeto.
  2. Reducir el acoplamiento: Al aislar la fábrica abstracta y la fábrica concreta, se reduce el acoplamiento entre el cliente y el objeto, lo que hace que el programa cliente sea más fácil de expandir y mantener.
  3. Mejorar la escalabilidad del programa: Cuando necesite agregar un nuevo producto, solo necesita agregar la clase de producto específica correspondiente y la clase de fábrica correspondiente. No es necesario modificar el código original. Cumple con el principio de apertura y cierre (abierto para expansión y cerrado). para modificación), lo que mejora la escalabilidad del código.
  4. Fácil de mantener y actualizar: Debido a que el método de fábrica concentra el proceso de creación de objetos en una clase, si necesita modificar el método de creación de objetos, solo necesita modificar la clase de fábrica correspondiente, lo que no tendrá ningún impacto en el cliente.
  5. reutilización de código: El patrón de fábrica puede abstraer el proceso de creación de objetos, realizar la reutilización del código y aumentar la flexibilidad y reutilización del código.

2. Clasificación del modelo de fábrica.

Los patrones de fábrica se dividen principalmente en tres tipos: patrones de fábrica simples (patrones de fábrica estáticos), patrones de método de fábrica y patrones de fábrica abstractos.

1. Método de fábrica estática
  1. Defina una clase de fábrica para devolver instancias de diferentes clases según los diferentes parámetros pasados.
  2. Las clases de fábrica generalmente contienen múltiples métodos estáticos, cada método corresponde a la creación de un producto específico.
  3. Ventajas: Simple de implementar y fácil de entender.
  4. Desventajas: las responsabilidades de la clase de fábrica son demasiado pesadas. Al agregar nuevos productos, es necesario modificar el código fuente de la clase de fábrica, lo que viola el principio de apertura y cierre.

Diagrama de clases de patrón de fábrica simple

2. Patrón de método de fábrica (método de fábrica)
  1. Definir una interfaz (fábrica abstracta) para crear objetos,Pero dejemos que la subclase decida qué clase crear una instancia.。
  2. Los métodos de fábrica permiten aplazar la creación de instancias de clases a subclases.
  3. Ventajas: Buena escalabilidad Cuando es necesario agregar nuevos productos, solo es necesario agregar las categorías de productos específicas correspondientes y las categorías de fábrica específicas.
  4. Desventajas: cada vez que se agrega un producto, es necesario agregar una fábrica de implementación de objetos y clases específicas, lo que duplica el número de clases en el sistema y aumenta la complejidad del sistema.

Patrón de método de fábrica

3. Patrón Abstract Factory (Fábrica abstracta)
  1. Proporciona una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases concretas.
  2. El patrón de fábrica abstracto puede verse como el uso conjunto de múltiples patrones de métodos de fábrica.
  3. Ventajas: la familia de productos se puede restringir dentro de la clase. Una fábrica específica debe poder crear todos los productos de la familia de productos.
  4. Desventajas: aumenta la abstracción y la dificultad de comprender el sistema, y ​​​​la cantidad de clases en el sistema aumentará significativamente.

patrón abstracto de fábrica

3. Escenarios de aplicación del modelo de fábrica.

El patrón de fábrica tiene una amplia gama de aplicaciones en desarrollo real, como conexiones de bases de datos, controles de interfaz de usuario, procesamiento de archivos, registro, comunicaciones de red, colas de mensajes, estructuras de datos, cifrado y descifrado, envío de mensajes y programación de tareas. En estos escenarios, el uso del patrón de fábrica puede separar el proceso de creación de objetos del proceso de uso, mejorando la flexibilidad y escalabilidad del sistema.

4. Ejemplo de modelo de fábrica

1. Ejemplo de patrón de fábrica simple

En el patrón de fábrica simple, definimos una clase de fábrica que puede devolver instancias de diferentes tipos según los parámetros pasados.

A continuación se muestra un ejemplo de un patrón de fábrica simple escrito en Java. Crearemos una fábrica de formas que pueda producir instancias de círculos, rectángulos y cuadrados. Primero, definimos una interfaz de forma (Shape) y varias clases concretas (Círculo, Rectángulo, Cuadrado) que implementan esta interfaz.

  1. // 形状接口  
  2. interface Shape {  
  3.     void draw();  
  4. }  
  5.   
  6. // 圆形类  
  7. class Circle implements Shape {  
  8.     @Override  
  9.     public void draw() {  
  10.         System.out.println("Inside Circle::draw() method.");  
  11.     }  
  12. }  
  13.   
  14. // 矩形类  
  15. class Rectangle implements Shape {  
  16.     @Override  
  17.     public void draw() {  
  18.         System.out.println("Inside Rectangle::draw() method.");  
  19.     }  
  20. }  
  21.   
  22. // 正方形类  
  23. class Square implements Shape {  
  24.     @Override  
  25.     public void draw() {  
  26.         System.out.println("Inside Square::draw() method.");  
  27.     }  
  28. }

A continuación, definimos una clase de fábrica (ShapeFactory) que utiliza métodos estáticos para generar objetos de forma.

  1. // 形状工厂类  
  2. class ShapeFactory {  
  3.   
  4.     // 使用 getShape 方法获取形状类型的对象  
  5.     public static Shape getShape(String shapeType){  
  6.         if(shapeType == null){  
  7.             return null;  
  8.         }          
  9.         if(shapeType.equalsIgnoreCase("CIRCLE")){  
  10.             return new Circle();  
  11.         } else if(shapeType.equalsIgnoreCase("RECTANGLE")){  
  12.             return new Rectangle();  
  13.         } else if(shapeType.equalsIgnoreCase("SQUARE")){  
  14.             return new Square();  
  15.         }  
  16.           
  17.         return null;  
  18.     }  
  19. }

Finalmente, podemos usar una clase de fábrica para obtener objetos de forma y llamar a susdrawmétodo.

  1. public class FactoryPatternDemo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 获取 Circle 的对象，并调用它的 draw 方法  
  5.         Shape shape1 = ShapeFactory.getShape("CIRCLE");  
  6.         shape1.draw();  
  7.   
  8.         // 获取 Rectangle 的对象，并调用它的 draw 方法  
  9.         Shape shape2 = ShapeFactory.getShape("RECTANGLE");  
  10.         shape2.draw();  
  11.   
  12.         // 获取 Square 的对象，并调用它的 draw 方法  
  13.         Shape shape3 = ShapeFactory.getShape("SQUARE");  
  14.         shape3.draw();  
  15.     }  
  16. }

En este ejemplo,ShapeFactoryLa clase es responsable de crear.Shape Una instancia de la interfaz.El código del cliente hace esto pasando información de tipo (por ejemplo, cadena) aShapeFactorymétodo estático de clasegetShape para obtener una instancia de la forma deseada. De esta manera, el cliente se desacopla de la implementación de la clase específica y cumple con el principio de apertura y cierre, es decir, se pueden ampliar nuevas clases de formas sin modificar el código del cliente. Sin embargo, una desventaja importante del patrón de fábrica simple es que si el sistema necesita ampliarse con nuevas familias de productos (como colores además de formas, etc.), es necesario modificar la clase de fábrica, lo que viola parte del patrón abierto. -principio cerrado. En este caso, considere utilizar el patrón Factory Method o el patrón Abstract Factory.

2. Ejemplo de patrón de método de fábrica

Aún tomando forma como ejemplo, utilizamos métodos de ingeniería para crearlo.

Primero defina la interfaz de forma (Producto) y cree tres clases de implementación.

  1. // 形状接口  
  2. interface Shape {  
  3.     void draw();  
  4. }
  5.  
  6. // 圆形类  
  7. class Circle implements Shape {  
  8.     @Override  
  9.     public void draw() {  
  10.         System.out.println("Inside Circle::draw() method.");  
  11.     }  
  12. }  
  13.   
  14. // 矩形类  
  15. class Rectangle implements Shape {  
  16.     @Override  
  17.     public void draw() {  
  18.         System.out.println("Inside Rectangle::draw() method.");  
  19.     }  
  20. }  
  21.   
  22. // 正方形类  
  23. class Square implements Shape {  
  24.     @Override  
  25.     public void draw() {  
  26.         System.out.println("Inside Square::draw() method.");  
  27.     }  
  28. }

A continuación, defina la interfaz del creador (Creator) y el creador concreto (Concrete Creator):

  1. // 创建者接口  
  2. interface ShapeFactory {  
  3.     Shape getShape(String shapeType);  
  4. }  
  5.   
  6. // 具体创建者类  
  7. class RectangleFactory implements ShapeFactory {  
  8.     @Override  
  9.     public Shape getShape(String shapeType) {  
  10.         if (shapeType == null) {  
  11.             return null;  
  12.         }  
  13.         if (shapeType.equalsIgnoreCase("RECTANGLE")) {  
  14.             return new Rectangle();  
  15.         }  
  16.         return null;  
  17.     }  
  18. }  
  19.   
  20. class CircleFactory implements ShapeFactory {  
  21.     @Override  
  22.     public Shape getShape(String shapeType) {  
  23.         if (shapeType == null) {  
  24.             return null;  
  25.         }  
  26.         if (shapeType.equalsIgnoreCase("CIRCLE")) {  
  27.             return new Circle();  
  28.         }  
  29.         return null;  
  30.     }  
  31. }  
  32.   
  33. class SquareFactory implements ShapeFactory {  
  34.     @Override  
  35.     public Shape getShape(String shapeType) {  
  36.         if (shapeType == null) {  
  37.             return null;  
  38.         }  
  39.         if (shapeType.equalsIgnoreCase("SQUARE")) {  
  40.             return new Square();  
  41.         }  
  42.         return null;  
  43.     }  
  44. }

Finalmente, use la clase creadora concreta para obtener los objetos de forma y llamar a susdrawmétodo:

  1. public class FactoryMethodPatternDemo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         ShapeFactory shapeFactory = new CircleFactory();  
  5.   
  6.         // 获取 Circle 的对象，并调用它的 draw 方法  
  7.         Shape shape1 = shapeFactory.getShape("CIRCLE");  
  8.         shape1.draw();  
  9.   
  10.         // 使用 RectangleFactory 来获取 Rectangle 的对象  
  11.         shapeFactory = new RectangleFactory();  
  12.         Shape shape2 = shapeFactory.getShape("RECTANGLE");  
  13.         shape2.draw();  
  14.   
  15.         // 使用 SquareFactory 来获取 Square 的对象  
  16.         shapeFactory = new SquareFactory();  
  17.         Shape shape3 = shapeFactory.getShape("SQUARE");  
  18.         shape3.draw();  
  19.     }  
  20. }

En este ejemplo,Creamos una clase de fábrica correspondiente para cada clase de forma. (Aunque en aplicaciones reales, generalmente habrá una estructura de clases de fábrica más general, tal vez a través de archivos de configuración o reflexión para evitar escribir clases de fábrica separadas para cada clase de producto). Esto ayuda a demostrar los fundamentos del patrón Factory Method,Es decir, deje que la subclase de fábrica decida qué clase crear una instancia. . Sin embargo, para el caso simple de este ejemplo, es posible que se sienta más inclinado a utilizar el patrón Simple Factory o considerar otros patrones de diseño para reducir la duplicación de código.

3. Ejemplo de fábrica abstracta

Este ejemplo toma como ejemplo los teléfonos móviles, productos abstractos relacionados con los teléfonos móviles (como pantallas, baterías, sistemas operativos, etc.) y crea clases de productos específicas para implementar estas interfaces. Luego podemos definir interfaces de fábrica abstractas y clases de fábrica concretas para producir estos productos. A continuación se muestra un ejemplo simplificado que muestra cómo utilizar el patrón Abstract Factory para producir componentes (pantallas y baterías) para diferentes marcas y modelos de teléfonos móviles:

Primero, defina la interfaz del producto y los productos específicos:

  1. // 屏幕接口  
  2. interface Screen {  
  3.     void display();  
  4. }  
  5.   
  6.  
  7. // 高端屏幕的实现  
  8. class HighEndScreen implements Screen {  
  9.     @Override  
  10.     public void display() {  
  11.         System.out.println("显示高清屏幕");  
  12.     }  
  13. }  
  14.   
  15. // 低端屏幕的实现  
  16. class LowEndScreen implements Screen {  
  17.     @Override  
  18.     public void display() {  
  19.         System.out.println("显示普通屏幕");  
  20.     }  
  21. }  
  22.  
  23.  
  24. // 电池接口  
  25. interface Battery {  
  26.     void charge();  
  27. }
  28.  
  29.   
  30. // 高效电池的实现  
  31. class HighEfficiencyBattery implements Battery {  
  32.     @Override  
  33.     public void charge() {  
  34.         System.out.println("快速充电");  
  35.     }  
  36. }  
  37.   
  38. // 标准电池的实现  
  39. class StandardBattery implements Battery {  
  40.     @Override  
  41.     public void charge() {  
  42.         System.out.println("标准充电");  
  43.     }  
  44. }

A continuación, defina la interfaz de fábrica abstracta y la clase de fábrica concreta:

  1. // 手机组件工厂接口  
  2. interface PhoneFactory {  
  3.     Screen createScreen();  
  4.     Battery createBattery();  
  5. }  
  6.   
  7. // 高端手机工厂  
  8. class HighEndPhoneFactory implements PhoneFactory {  
  9.     @Override  
  10.     public Screen createScreen() {  
  11.         return new HighEndScreen();  
  12.     }  
  13.   
  14.     @Override  
  15.     public Battery createBattery() {  
  16.         return new HighEfficiencyBattery();  
  17.     }  
  18. }  
  19.   
  20. // 低端手机工厂  
  21. class LowEndPhoneFactory implements PhoneFactory {  
  22.     @Override  
  23.     public Screen createScreen() {  
  24.         return new LowEndScreen();  
  25.     }  
  26.   
  27.     @Override  
  28.     public Battery createBattery() {  
  29.         return new StandardBattery();  
  30.     }  
  31. }

Finalmente, el código del cliente, que utiliza una fábrica abstracta para crear objetos de producto concretos:

  1. public class PhoneFactoryPatternDemo {  
  2.     public static void main(String[] args) {  
  3.         // 使用高端手机工厂  
  4.         PhoneFactory highEndFactory = new HighEndPhoneFactory();  
  5.         Screen highEndScreen = highEndFactory.createScreen();  
  6.         Battery highEndBattery = highEndFactory.createBattery();  
  7.   
  8.         highEndScreen.display();  
  9.         highEndBattery.charge();  
  10.   
  11.         // 使用低端手机工厂  
  12.         PhoneFactory lowEndFactory = new LowEndPhoneFactory();  
  13.         Screen lowEndScreen = lowEndFactory.createScreen();  
  14.         Battery lowEndBattery = lowEndFactory.createBattery();  
  15.   
  16.         lowEndScreen.display();  
  17.         lowEndBattery.charge();  
  18.     }  
  19. }

En este ejemplo, definimos dos fábricas de teléfonos móviles (gama alta y gama baja), cada una capaz de producir un tipo específico de pantalla y batería.El código del cliente interactúa con la clase de fábrica específica a través de una interfaz de fábrica abstracta, logrando así el desacoplamiento de la clase de producto específica. . De esta manera, si necesitamos agregar nuevos tipos de teléfonos en el futuro (por ejemplo, teléfonos de gama media), solo necesitamos agregar nuevas clases de productos y las clases de fábrica correspondientes sin modificar el código de cliente existente.

5. Resumen

El patrón de fábrica es un patrón de diseño muy útil,Encapsula el proceso de creación de objetos, reduce el acoplamiento, mejora la escalabilidad del programa y la facilidad de mantenimiento, etc. , ha sido ampliamente utilizado en el desarrollo de software.Sin embargo, también tiene algunosDesventajas, como responsabilidades excesivas de fábrica, dificultad en la expansión del sistema, etc. . Por lo tanto, en aplicaciones prácticas, es necesario hacer concesiones y elecciones basadas en escenarios y necesidades específicas.

Si el patrón de fábrica (fábrica simple, método de fábrica, fábrica abstracta) le resulta útil, recuerde darle me gusta y recopilarlo.

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo