El patrón Abstract Factory se define de la siguiente manera:
1. Intención: Proporcionar una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases específicas.
(Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas).
2. Participantes: (5 roles)
• Abstract Factory (AbstractFactory): declara una interfaz de operación para crear objetos de producto abstractos .
• ConcreteFactory: implementa la operación de creación de objetos de producto específicos .
• Producto abstracto: declara una interfaz para un tipo de objeto de producto.
• Producto de Concreto (ConcreteProdcut): Define un objeto de producto que será creado por la fábrica de concreto correspondiente. Implemente la interfaz AbstractProduct .
• Cliente: Utilice sólo las interfaces declaradas por las clases AbstractFactory y AbstractProduct .
Cuando vi por primera vez el papel del cliente , estaba un poco confundido, me pregunto qué papel juega el cliente en el patrón abstracto de fábrica.
¿Es lo mismo que el cliente en los ejemplos (1~7) escritos cuando aprendí el "Patrón de fábrica simple" y el "Patrón de método de fábrica" antes ? ¿Significa lo mismo? Si es así, ¿por qué no hay ningún cliente participante en el patrón del método de fábrica ?
El patrón de diseño GOF incluye al participante " Cliente" , sin embargo, "Java and Patterns" de Yan Hong no incluye al participante " Cliente" .
Más tarde, pareció entenderse que el cliente debería usar la fábrica abstracta para ensamblar productos abstractos y proporcionar una interfaz de llamada para el cliente usando el patrón de fábrica abstracta . Entenderemos el papel del cliente en el Ejemplo 8 a continuación .
De hecho, en muchos ejemplos, el cliente se fusiona con la fábrica abstracta y algunos se fusionan con el cliente .
3. Estructura:
Figura 1: En el patrón de diseño de GoF (similar al formulario siguiente)
Figura 2: En "Java and Patterns" de Yan Hong (similar al formulario siguiente)
Cuando veo el patrón abstracto de fábrica , siempre lo comparo con el patrón del método de fábrica .
Ambos modos tienen los mismos cuatro personajes:
Fábrica abstracta (AbstractFactory) ---> Fábrica de hormigón (ConcreteFactory)
Producto abstracto (AbstractProduct) ---> Producto de hormigón (ConcreteProdcut)
Entonces, ¿cuál es la diferencia entre estos dos modos?
Vea cuál es la diferencia en la intención:
1. Patrón de método de fábrica: defina una interfaz para crear objetos y deje que las subclases decidan qué clase crear una instancia. El método Factory difiere la creación de instancias de una clase a sus subclases.
(Defina una interfaz para crear un objeto , pero deje que las subclases decidan qué clase crear una instancia. El método Factory permite que una clase difiera la creación de instancias a las subclases).
2. Patrón abstracto de fábrica : proporciona una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases específicas.
(Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas).
A través de las intenciones de estos dos modos, podemos ver:
1. El patrón del método de fábrica se usa para crear un objeto de producto, es decir, cada fábrica abstracta se usa para crear un objeto de producto abstracto, y cada fábrica concreta que hereda la fábrica abstracta se usa para crear un objeto de producto específico.
2. El patrón de fábrica abstracta se utiliza para crear múltiples objetos de producto (un conjunto o una serie) , es decir, cada fábrica abstracta se usa para crear múltiples objetos de producto abstracto (un conjunto o una serie) y hereda la fábrica abstracta. Cada una de las fábricas de hormigón se puede utilizar para crear múltiples (un conjunto o serie) de objetos de productos concretos.
Siguiendo tomando como ejemplo la "producción de automóviles",
1. En el modo de método de fábrica , cada automóvil es un objeto de producto (las piezas de automóvil, como motores, puertas, etc., se consideran atributos del automóvil ).
El proceso de producción de automóviles en una fábrica es en realidad solo el proceso de ensamblar piezas de automóviles.
2. En el modo de fábrica abstracto , cada automóvil se compone de un conjunto de objetos de productos de autopartes (motores, puertas, etc. son todos productos, ya no atributos ).
El proceso de producción de automóviles en una fábrica se ha convertido en un proceso en el que primero se producen piezas individuales y luego se ensamblan.
Yan Hong dijo esto en "JAVA y patrones":
La mayor diferencia entre el patrón de fábrica abstracto y el patrón de método de fábrica es que el patrón de método de fábrica apunta a una estructura a nivel de producto, mientras que el patrón de fábrica abstracto necesita enfrentar múltiples estructuras a nivel de producto.
El término "jerarquía de productos" parece abstracto.
1. ¿Qué es una jerarquía de productos?
Audi A6, Audi A8 e incluso BMW X6 pueden considerarse una clase de producto porque todos son automóviles.
El Audi A6 rojo, el Audi A8 negro e incluso BMW también pueden considerarse una clase de producto, porque todos son coches.
imagen 3:
Los motores de cada uno de los automóviles anteriores, el motor Audi A6 y el motor Audi A8 (suponiendo que los modelos de motor sean diferentes aquí), también pueden considerarse a nivel de producto, porque todos son motores.
Figura 4:
2. ¿Qué es una organización a nivel de múltiples productos?
El motor del Audi A6, las puertas del Audi A6 y los neumáticos del Audi A6 están estructurados en múltiples niveles de producto porque son diferentes tipos de productos.
En otras palabras, los motores, las puertas, los neumáticos y otras piezas de automóviles representan cada uno un tipo de producto, no existe una relación de herencia e implementación y no hay intersección.
Existe una relación paralela entre ellos, pero cuando se combinan pueden formar un automóvil (una familia de productos).
Un automóvil Audi A6 es una combinación de una serie de motores Audi A6, puertas Audi A6, neumáticos Audi A6 y otros productos de autopartes.
Figura 5:
Ejemplos e implementación Java del patrón Abstract Factory:
Si un cliente quiere comprar un coche FAW-Volkswagen, el motor y la carrocería del coche también deben ser del modelo correspondiente.
El cliente A quiere comprar un Audi A6 y el cliente A quiere comprar un Audi A8. Ejemplo 8:
Motor de coche (producto abstracto):
/*
* 汽车发动机(抽象产品)
*/
public interface Engine {
}
Motor Audi A6 (productos específicos):
/*
* 奥迪A6的发动机（具体产品）
*/
public class AudiA6Engine implements Engine{
public String toString(){
return "奥迪A6发动机";
}
}
Motor Audi A8 (productos específicos):
/*
* 奥迪A8的发动机（具体产品）
*/
public class AudiA8Engine implements Engine{
public String toString(){
return "奥迪A8发动机";
}
}
Carrocería (producto abstracto):
/*
* 汽车车身（抽象产品）
*/
public interface CarBody {
}
Carrocería Audi A6 (productos específicos):
/*
* 奥迪A6的车身（具体产品）
*/
public class AudiA6CarBody implements CarBody {
public String toString(){
return "奥迪A6车身";
}
}
Carrocería Audi A8 (productos específicos):
/*
* 奥迪A8的车身（具体产品）
*/
public class AudiA8CarBody implements CarBody {
public String toString(){
return "奥迪A8车身";
}
}
Fábrica FAW-Volkswagen (Fábrica abstracta):
/*
* 一汽大众工厂（抽象工厂）
*/
public interface CarFactory {
/*
* 生产汽车发动机的工厂方法（创建一种产品对象）
*/
public Engine createEngine();
/*
* 生产汽车车身的工厂方法（创建另一种产品对象）
*/
public CarBody createCarBody();
}
Fábrica de Audi A6 (fábrica específica):
/*
* 奥迪A6工厂（具体工厂）
*/
public class AudiA6CarFactory implements CarFactory {
/*
* 生产奥迪A6发动机的工厂方法（创建一种具体产品对象）
*/
public CarBody createCarBody() {
return new AudiA6CarBody();
}
/*
* 生产奥迪A6车身的工厂方法（创建另一种具体产品对象）
*/
public Engine createEngine() {
return new AudiA6Engine();
}
}
Fábrica de Audi A8 (fábrica específica):
/*
* 奥迪A8工厂（具体工厂）
*/
public class AudiA8CarFactory implements CarFactory {
/*
* 生产奥迪A6发动机的工厂方法（创建一种具体产品对象）
*/
public CarBody createCarBody() {
return new AudiA8CarBody();
}
/*
* 生产奥迪A6车身的工厂方法（创建另一种具体产品对象）
*/
public Engine createEngine() {
return new AudiA8Engine();
}
}
Auto (cliente):
Un automóvil es en realidad una familia de productos, es decir, un conjunto (una serie) de productos de autopartes (familia de productos).
Aquí se define una clase Car, que solo utiliza fábrica abstracta (CarFactory) y productos abstractos ( Engine, CarBody ) , y no involucra fábricas específicas ( AudiA6CarFactory, AudiA8CarFactory ) ni productos específicos ( AudiA6Engine, AudiA8Engine, AudiA6CarBody, AudiA8CarBody ) .
/*
* 汽车（客户端）
* 通过生产发动机的工厂和生产车身的工厂，生产汽车发动机和汽车车身，
* 最终，汽车由一套产品族（一套汽车零部件）组成。
*/
public class Car {
private CarBody body;
private Engine engine;
public Car(CarFactory carFactory){
this.body = carFactory.createCarBody();
this.engine = carFactory.createEngine();
}
public String toString(){
return "[" + this.body+"/" + this.engine + "]";
}
}
Llamada del cliente (para prueba):
Al llamar al patrón de fábrica abstracto, se utiliza el rol de cliente Car , porque el tipo de parámetro entrante de la correspondencia del constructor de la clase Car es una fábrica abstracta.
De esta manera, siempre que pasemos un objeto de fábrica específico deseado ( AudiA6CarFactory) según sea necesario , podemos obtener el objeto de la familia de productos deseada (adioA6Car) .
Cuando desee obtener otro objeto de familia de productos (adioA8Car) , simplemente pase otro objeto de fábrica específico (AudiA8CarFactory) .
/*
* 使用抽象工厂的客户端（用于测试）
*/
public class Customers {
public static void main(String[] args){
// 创建一个奥迪A6生产工厂（具体工厂对象）
CarFactory adioA6CarFactory = new AudiA6CarFactory();
// 顾客A购买了奥迪A6（具体工厂对象作为参数，将会被用来创建汽车对象（包含了一系列相关的汽车部件产品对象））
Car adioA6Car = new Car(adioA6CarFactory);
System.out.println("顾客A买了一辆汽车" + adioA6Car);
// 创建一个奥迪A8生产工厂（具体工厂对象）
CarFactory adioA8CarFactory = new AudiA8CarFactory();
// 顾客B购买了奥迪A8（具体工厂对象作为参数，将会被用来创建汽车对象（包含了一系列相关的汽车部件产品对象））
Car adioA8Car = new Car(adioA8CarFactory);
System.out.println("顾客B买了一辆汽车" + adioA8Car);
}
}
resultado de la operación:
顾客A买了一辆汽车[奥迪A6车身/奥迪A6发动机]
顾客B买了一辆汽车[奥迪A8车身/奥迪A8发动机]
Diagrama de estructura de este ejemplo:
Para resumir brevemente, comparando el patrón del método de fábrica , podemos comprender las ventajas del patrón de fábrica abstracto :
1. A través de una comparación intencional,
El propósito de utilizar el patrón de fábrica abstracto : crear una serie de objetos relacionados o interdependientes (varias o varias categorías);
El propósito de utilizar el patrón del método de fábrica es crear (uno o una clase de) objetos.
2. A través de la comparación estructural,
Debido a que el patrón abstracto de fábrica es crear múltiples objetos de productos relacionados, se agrega una función de cliente (Cliente) para integrar las familias de productos creadas.
Al mismo tiempo, la fábrica en el patrón de fábrica abstracto no es una fábrica para ningún producto, es una fábrica para múltiples productos. Creo que esta puede ser la razón por la que la fábrica de patrones de fábrica abstracta se llama fábrica "abstracta" . En otras palabras, su "abstracción" es la "abstracción" de múltiples productos.
En muchos materiales y aplicaciones prácticas, la mayoría de las ventajas del patrón de fábrica abstracto se reflejan completamente al combinar archivos de configuración y reflexión.
El siguiente enlace es un patrón de fábrica abstracto explicado por un blogger que usa .NET. Creo que es fácil de entender y tiene un gran valor de referencia en aplicaciones prácticas.
Patrón de diseño .NET (3): patrón Abstract Factory (Abstract Factory)