El modo de constructor del modo de diseño común

concepto

Builder Pattern 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.
El modo constructor incluye principalmente cuatro roles:

• Producto (producto): el objeto de clase de producto que se creará
• Abstracción del constructor (constructor): la clase abstracta del constructor, que regula la construcción de los diversos componentes del objeto de producto y, en general, implementa el proceso de construcción específico por subclases.
• Builder (concreteBuilder): clase de constructor concreto, de acuerdo con diferentes lógicas comerciales, concreta la creación de cada componente del objeto
• El llamador (director): llama al creador específico para crear cada parte del objeto. El director no involucra la información del producto específico, sino que solo es responsable de asegurarse de que todas las partes del objeto se creen completamente o en un orden determinado.

lograr

1. Crea un producto

@Data
    public class Product {
    
    
        private String name;
        private String coke;
        private String burger;
        private String chicken;

        @Override
        public String toString() {
    
    
            return "Product{" +
                    "name='" + name + '\'' +
                    ", coke='" + coke + '\'' +
                    ", burger='" + burger + '\'' +
                    ", chicken='" + chicken + '\'' +
                    '}';
        }
    }

2. Crea un constructor

public class ConcreteBuilder {
    
    
    private Product product=new Product();

    public Product builder() {
    
    
        return product;
    }

    public ConcreteBuilder addName(String name){
    
    
        product.setName(name);
        return this;
    }
    public ConcreteBuilder addCoke(String coke){
    
    
        product.setCoke(coke);
        return this;
    }
    public ConcreteBuilder addBurger(String burger){
    
    
        product.setBurger(burger);
        return this;
    }
    public ConcreteBuilder addChicken(String chicken){
    
    
        product.setChicken(chicken);
        return this;
    }

    @Data
    public class Product {
    
    
        private String name;
        private String coke;
        private String burger;
        private String chicken;

        @Override
        public String toString() {
    
    
            return "Product{" +
                    "name='" + name + '\'' +
                    ", coke='" + coke + '\'' +
                    ", burger='" + burger + '\'' +
                    ", chicken='" + chicken + '\'' +
                    '}';
        }
    }


}

3. Crea la persona que llama

public class Director {
    
    
    public static void main(String[] args) {
    
    
        ConcreteBuilder builder=new ConcreteBuilder().
                addName("肯德基全家桶").
                addChicken("炸鸡腿").
                addBurger("汉堡").
                addCoke("可乐");

        System.out.println(builder.builder());
    }
}

resultado de la operación:

Usar en código fuente

En el proceso IOC de primavera, los objetos en xml, la aplicación y otros archivos se llaman a través de la clase BeanDefinitionBuildergetBeanDefinition () Método para obtener un objeto AbstractBeanDefinition y ponerlo en el contenedor IOC

BeanDefinitionBuilder.java

public class BeanDefinitionBuilder {
    
    
	public AbstractBeanDefinition getBeanDefinition() {
    
    
			this.beanDefinition.validate();
			return this.beanDefinition;
		}
	public BeanDefinitionBuilder setParentName(String parentName) {
    
    
		this.beanDefinition.setParentName(parentName);
		return this;
	}
	public BeanDefinitionBuilder setFactoryMethod(String factoryMethod) {
    
    
		this.beanDefinition.setFactoryMethodName(factoryMethod);
		return this;
	}
	public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean) {
    
    
		this.beanDefinition.setFactoryMethodName(factoryMethod);
		this.beanDefinition.setFactoryBeanName(factoryBean);
		return this;
	}
	public BeanDefinitionBuilder addConstructorArgValue(@Nullable Object value) {
    
    
		this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
				this.constructorArgIndex++, value);
		return this;
	}
	public BeanDefinitionBuilder addConstructorArgReference(String beanName) {
    
    
		this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
				this.constructorArgIndex++, new RuntimeBeanReference(beanName));
		return this;
	}
	public BeanDefinitionBuilder addPropertyValue(String name, @Nullable Object value) {
    
    
		this.beanDefinition.getPropertyValues().add(name, value);
		return this;
	}
	public BeanDefinitionBuilder addPropertyReference(String name, String beanName) {
    
    
		this.beanDefinition.getPropertyValues().add(name, new RuntimeBeanReference(beanName));
		return this;
	}
	public BeanDefinitionBuilder setInitMethodName(@Nullable String methodName) {
    
    
		this.beanDefinition.setInitMethodName(methodName);
		return this;
	}
	public BeanDefinitionBuilder setDestroyMethodName(@Nullable String methodName) {
    
    
		this.beanDefinition.setDestroyMethodName(methodName);
		return this;
	}
	public BeanDefinitionBuilder setScope(@Nullable String scope) {
    
    
		this.beanDefinition.setScope(scope);
		return this;
	
	public BeanDefinitionBuilder setAbstract(boolean flag) {
    
    
		this.beanDefinition.setAbstract(flag);
		return this;
	}
	public BeanDefinitionBuilder setLazyInit(boolean lazy) {
    
    
		this.beanDefinition.setLazyInit(lazy);
		return this;
	}
	public BeanDefinitionBuilder setAutowireMode(int autowireMode) {
    
    
		beanDefinition.setAutowireMode(autowireMode);
		return this;
	}
	...
}	

La diferencia entre el modo constructor y el modo de fábrica

1. El modo constructor presta más atención a la secuencia de llamadas de los métodos, y el modo de fábrica se centra en la creación de objetos.
2. La fuerza de crear objetos es diferente. El modo de constructor crea objetos complejos, compuestos de varias partes complejas, y el modo de fábrica crea los mismos
3. El enfoque es diferente. El modo de fábrica solo necesita crear el objeto, y el modo de constructor necesita saber de qué partes está compuesto el objeto

para resumir

ventaja

1. Constructor independiente, fácil de expandir
2. Riesgos detallados fáciles de controlar

Desventaja

1. Los productos deben tener algo en común
2. Si el interior es complejo, será necesario un objeto Builder.