Housing project demand

1) Need to build a house: this process is piling, building walls and capping
2) There are all kinds of houses, such as ordinary houses, high-rise buildings and villas. Although the process of all kinds of houses is the same, the requirements are not the same.

Traditional way to solve the housing demand

1) Train of thought analysis (illustration)

package com.example.demo.builder;

public abstract class AbstractHouse {
	
	/**
	 * Laying foundation
	 */
	public abstract void buildBasic();

	/**
	 * Build a wall
	 */
	public abstract void buildWalls();
	
	/**
	 * Capping
	 */
	public abstract void roofed();
	
	public void build() {
		buildBasic();
		buildWalls();
		roofed();
	}
}
package com.example.demo.builder;

public class CommonHouse extends AbstractHouse{

	@Override
	public void buildBasic() {
		// TODO Auto-generated method stub
		System.out.println(" Laying foundation for ordinary house ");
	}

	@Override
	public void buildWalls() {
		// TODO Auto-generated method stub
		System.out.println(" Ordinary house walling ");
	}

	@Override
	public void roofed() {
		// TODO Auto-generated method stub
		System.out.println(" Ordinary house capping ");
	}

}
package com.example.demo.builder;

public class Client {
	public static void main(String[] args) {
		AbstractHouse abstractHouse = new CommonHouse();
		abstractHouse.build();
	}
}

Problem analysis of traditional methods

1) The advantages are easy to understand, simple and easy to operate.
2) The designed program structure is too simple, there is no cache layer object, and the program expansion and maintenance are not good. In other words, this design scheme encapsulates the product (i.e. house) and the process of creating the product (i.e. house building process), and the coupling is enhanced.
3) Solution: decouple product and product construction process = "builder mode".

Basic introduction to builder mode

Basic introduction
1) Builder Pattern, also known as Builder Pattern, is an object construction pattern. It can abstract the construction process of complex objects (abstract categories), so that different implementation methods of this abstract process can construct objects with different representations (attributes).
2) Builder mode is to create a complex object step by step. It allows users to build complex objects only by specifying their types and contents. Users do not need to know the specific internal construction details.

The four roles of the builder model

1) Product role: a specific product object.
2) Builder (Abstract builder): create an interface / abstract class specified by each part of a Product object.
3) ConcreteBuilder: implement interfaces, build and assemble various components.
4) Director: build an object that uses the Builder interface. It is mainly used to create a complex object. It has two main functions: one is to isolate the production process of customers and objects; Second: be responsible for controlling the production process of product objects.

Schematic diagram of class builder

package com.example.demo.builder.improve;

/**
 * Product - Product
 * @author zhaozhaohai
 *
 */
public class House {
	private String baise;
	private String wall;
	private String roofed;
	public String getBaise() {
		return baise;
	}
	public void setBaise(String baise) {
		this.baise = baise;
	}
	public String getWall() {
		return wall;
	}
	public void setWall(String wall) {
		this.wall = wall;
	}
	public String getRoofed() {
		return roofed;
	}
	public void setRoofed(String roofed) {
		this.roofed = roofed;
	}
	
}
package com.example.demo.builder.improve;

/**
 * Abstract builder
 * @author zhaozhaohai
 *
 */
public abstract class HouseBuilder {
	protected House house = new House();
	
	/**
	 * Write the construction process and abstract method
	 */
	public abstract void buildBasic();
	public abstract void buildWalls();
	public abstract void roofed();
	
	/**
	 * After building the house, return the house (product),
	 */
	public House buildHouse() {
		return house;
	}
}
package com.example.demo.builder.improve;

public class CommonHouse extends HouseBuilder{

	@Override
	public void buildBasic() {
		// TODO Auto-generated method stub
		System.out.println(" The foundation of an ordinary house is 5m ");
	}

	@Override
	public void buildWalls() {
		// TODO Auto-generated method stub
		System.out.println(" Ordinary house walling 10 cm ");
	}

	@Override
	public void roofed() {
		// TODO Auto-generated method stub
		System.out.println(" Ordinary houses are roofed ");
	}

}
package com.example.demo.builder.improve;

public class HighHouse extends HouseBuilder{

	@Override
	public void buildBasic() {
		// TODO Auto-generated method stub
		System.out.println(" The foundation of the tall building is 100m ");
	}

	@Override
	public void buildWalls() {
		// TODO Auto-generated method stub
		System.out.println(" The wall of the tall building is 50 meters ");
	}

	@Override
	public void roofed() {
		// TODO Auto-generated method stub
		System.out.println(" The transparent roof of a tall building ");
	}

}
package com.example.demo.builder.improve;

/**
 * Commander, go here to specify the process and return the product
 * @author zhaozhaohai
 *
 */
public class HouseDirector {
	private HouseBuilder houseBuilder = null;
	
	/**
	 * Constructor passed into houseBuilder
	 * @param houseDirector
	 */
	public HouseDirector(HouseBuilder houseBuilder) {
		this.houseBuilder = houseBuilder;
	}

	/**
	 * Pass in houseBuilder through setter
	 * @param houseDirector
	 */
	public void setHouseDirector(HouseBuilder houseBuilder) {
		this.houseBuilder = houseBuilder;
	}
	
	/**
	 * How to deal with the process of building a house and leave it to the commander
	 * @return
	 */
	public House construHouse() {
		houseBuilder.buildBasic();
		houseBuilder.buildWalls();
		houseBuilder.roofed();
		return houseBuilder.buildHouse();
	}
	
}
package com.example.demo.builder.improve;

public class Client {
	public static void main(String[] args) {
		// Build an ordinary house
		CommonHouse commonHouse = new CommonHouse();
		// The commander ready to create the house
		HouseDirector houseDirector = new HouseDirector(commonHouse);
		
		// Finish building the house and return the product (house)
		House house = houseDirector.construHouse();
	}
}

Application and source code analysis of builder pattern in JDK

1)java. Builder pattern in lang.stringbuilder




2) Role analysis of builder pattern in source code
(1) The Appendable interface defines multiple append methods (abstract methods), that is, Appendable is the abstract builder and defines abstract methods
(2) AbstractStringBuilder implements the Appendable interface method. AbstractStringBuilder here is already the builder, but it cannot be instantiated
(3) StringBuilder plays the role of commander and acts as a specific builder. The implementation of the construction method is completed by AbstractStringBuilder, which inherits AbstractStringBuilder

Notes and details of builder mode

1) The client (user program) does not need to know the details of the internal composition of the product, decouples the product itself from the product creation process, so that the same creation process can create different product objects
2) Each specific builder is relatively independent and has nothing to do with other specific builders. Therefore, it is convenient to replace or add new specific builders. Users can get different product objects by using different specific builders
3) You can more finely control the product creation process. The creation steps of complex products are decomposed into different methods, which makes the creation process clearer and easier to use programs to control the creation process
4) Adding a new specific builder does not need to modify the code of the original class library. The commander class is programmed for the abstract builder class, which is convenient for system expansion and conforms to the "opening and closing principle"
5) The products created by the builder mode generally have more in common and their components are similar. If there are great differences between products, it does not comply with the builder mode, so its scope of use is limited.
6) If the internal changes of the product are complex, it may lead to the need to define many specific builder classes to implement such changes, resulting in a huge system. Therefore, in this case, it is necessary to consider whether to select the builder mode.
7) Abstract factory pattern VS builder pattern
Abstract factory pattern realizes the creation of product family. A product family is such a series of products; For product combinations with different classification dimensions, the abstract factory model does not need to care about the construction process, but only about what products are produced by what factory. The builder model requires the product to be built according to the specified blueprint. Its main purpose is to produce a new product by assembling spare parts.