Introducción
En el desarrollo de software, hay una gran cantidad de objetos complejos, que tienen una serie de atributos de miembro, algunos de los cuales son objetos de miembro de tipo de referencia. Y en estos objetos complejos, puede haber algunas restricciones. Por ejemplo, si algunos atributos no están asignados, el objeto complejo no se puede utilizar como un producto completo; la asignación de algunos atributos debe estar en un orden determinado. Antes de asignar un atributo, otro atributo Es posible que no pueda asignar valores, etc.
Debido a que el proceso de ensamblaje de piezas es muy complicado, el proceso de ensamblaje de estas piezas a menudo se "externaliza" en un objeto llamado constructor. El constructor devuelve al cliente un objeto de producto completo que ha sido construido, y el usuario no necesita Preocuparse por los atributos contenidos en el objeto y cómo se ensamblan es la motivación del patrón del patrón constructor.
El Builder utiliza varios objetos simples para construir un objeto complejo paso a paso. Este tipo de patrón de diseño es un patrón de creación, que proporciona la mejor manera de crear objetos.
Ejemplo
El modo de constructor incluye los siguientes roles:
Builder: Constructor abstractoConcreteBuilder: Constructor de hormigónDirector: ComandanteProduct:producto
Una computadora es una configuración estándar para cada programador.Los principales accesorios son: CPU, placa base, memoria, tarjeta gráfica y fuente de alimentación. Actualmente hay dos plataformas principales: AMDy Intel, pero algunas partes de las dos plataformas son diferentes. Por lo tanto, los accesorios seleccionados por Fei Zhai al ensamblar las dos plataformas también son diferentes.
Producto (computadora):
public class Computer {
/**
* cpu
*/
private String cpu;
/**
* 主板
*/
private String motherboar;
/**
* 内存
*/
private String ram;
/**
* 显卡
*/
private String graphicsCard;
/**
* 电源
*/
private String power;
//setter and getter
// toString
}
Fábrica abstracta:
abstract class AbstractComputerBuilder {
/**
* 选择CPU
*/
abstract void buildCPU();
/**
* 选择主板
*/
abstract void buildMotherboar();
/**
* 选择内存
*/
abstract void buildRam();
/**
* 选择显卡
*/
abstract void buildGraphicsCard();
/**
* 选择电源
*/
abstract void buildPower();
/**
* 获取电脑
*/
abstract Computer getComputer();
}
Constructor específico:
// AMD电脑 建造者
public class AmdComputerBuilder extends AbstractComputerBuilder {
private Computer computer = new Computer();
@Override
void buildCPU() {
computer.setCpu("2700x");
}
@Override
void buildMotherboar() {
computer.setMotherboar("华硕 ROG X470");
}
@Override
void buildRam() {
computer.setRam("芝奇 DDR4 8G");
}
@Override
void buildGraphicsCard() {
computer.setGraphicsCard("vega 56");
}
@Override
void buildPower() {
computer.setPower("EVGA 750W");
}
@Override
Computer getComputer() {
return computer;
}
}
// Intel 电脑建造者
public class IntelComputerBuilder extends AbstractComputerBuilder {
private Computer computer = new Computer();
@Override
void buildCPU() {
computer.setCpu("i7 8700");
}
@Override
void buildMotherboar() {
computer.setMotherboar("微星 Z370");
}
@Override
void buildRam() {
computer.setRam("金士顿 DDR4 8G");
}
@Override
void buildGraphicsCard() {
computer.setGraphicsCard("GTX 1080Ti");
}
@Override
void buildPower() {
computer.setPower("海韵 750W");
}
@Override
Computer getComputer() {
return computer;
}
}
Comandante:
public class ComputerDirector {
public void construct(AbstractComputerBuilder builder) {
builder.buildCPU();
builder.buildMotherboar();
builder.buildRam();
builder.buildGraphicsCard();
builder.buildPower();
}
}
prueba:
public class Fz {
@Test
public void build() {
ComputerDirector director = new ComputerDirector();
AmdComputerBuilder amdComputerBuilder = new AmdComputerBuilder();
director.construct(amdComputerBuilder);
Computer amdComputer = amdComputerBuilder.getComputer();
System.out.println("选择AMD平台配件：" + amdComputer);
IntelComputerBuilder intelComputerBuilder = new IntelComputerBuilder();
director.construct(intelComputerBuilder);
Computer intelComputer = intelComputerBuilder.getComputer();
System.out.println("选择Intel平台配件：" + intelComputer);
}
}
Diagrama de clase
ventaja
- La encapsulación del modo constructor es muy buena. El uso del modo de creación puede encapsular los cambios de forma eficaz. En el caso de utilizar el modo de creación, la categoría de producto general y la categoría de creación son relativamente estables. Por lo tanto, encapsular la lógica empresarial principal en la categoría de director se puede comparar como un todo Buena estabilidad.
- En el modo constructor, el cliente no necesita conocer los detalles de la composición interna del producto y desacopla el producto en sí del proceso de creación del producto, de modo que el mismo proceso de creación puede crear diferentes objetos de producto.
- El proceso de creación del producto se puede controlar con mayor precisión. La descomposición de los pasos de creación de productos complejos en diferentes métodos hace que el proceso de creación sea más claro y más conveniente para usar programas para controlar el proceso de creación.
- El modo de constructor es fácil de expandir. Si hay nuevos requisitos, se puede completar implementando una nueva clase de constructor. Básicamente, no es necesario modificar el código que se ha probado antes, por lo que no presentará riesgos a las funciones originales. Cumplir con el principio de apertura y cierre.
Desventaja
- Los productos creados por el modo constructor generalmente tienen más en común y sus componentes son similares.Si los productos son muy diferentes, no es adecuado utilizar el modo constructor, por lo que el alcance de su uso está sujeto a ciertas restricciones.
- Si los cambios internos del producto son complejos, puede llevar a la necesidad de definir muchas clases de constructores de concreto para lograr este cambio, lo que hace que el sistema se vuelva muy grande.
Escena aplicable
El modo de constructor se puede utilizar en las siguientes situaciones:
- Los objetos de producto que se deben generar tienen una estructura interna compleja y estos objetos de producto suelen contener varios atributos de miembro.
- Los atributos de los objetos de producto que se generarán dependen unos de otros, y es necesario especificar el orden de su generación.
- El proceso de creación de un objeto es independiente de la clase que creó el objeto. En el modo constructor, se introduce la clase líder y el proceso de creación se encapsula en la clase líder, no en la clase constructor.
- Aísle la creación y el uso de objetos complejos y habilite el mismo proceso de creación para crear diferentes productos.
para resumir
El modo de constructor es similar al modo de fábrica y los escenarios aplicables también son muy similares. El modo constructor solo tiene una función de "comandante" más que el modo de fábrica. En el diagrama de clases del patrón del constructor, si la clase del director se considera el cliente al que finalmente se llama, el resto de la imagen puede considerarse como un patrón de fábrica simple.
El modo constructor se usa generalmente para crear objetos más complejos, porque el proceso de creación de objetos es más complicado, por lo que el proceso de creación de objetos se separa en una nueva clase de director de clase. En otras palabras, el modelo de fábrica encapsula todo el proceso de creación del objeto en la clase de fábrica, y la clase de fábrica proporciona el producto final al cliente; en el modo de constructor, la clase de constructor generalmente solo proporciona la construcción de cada componente en la clase de producto. El proceso de construcción específico se entrega a la clase de director. La clase de director es responsable de organizar cada componente en un producto de acuerdo con reglas específicas y luego entregar el producto ensamblado al cliente. El modo de constructor presta más atención a la secuencia de ensamblaje de piezas.
En términos generales, si la construcción del producto es compleja, utilice el modelo de fábrica; si la construcción del producto es más compleja, utilice el modelo de construcción.