builder mode
Introduce a case of building a house
- A house needs to be built: the process is piling, building walls, capping
- There are various kinds of houses, such as ordinary houses, high-rise buildings, villas, although the process of various houses is the same, but the requirements are not the same.
The traditional way to solve the housing needs
Code
base class for house
public abstract class AbstractHouse { //lay the foundation public abstract void buildBasic(); //build walls public abstract void buildWalls(); //capped public abstract void roofed(); public void build() { buildBasic(); buildWalls(); roofed(); } }
specific housing subclasses
public class CommonHouse extends AbstractHouse { @Override public void buildBasic() { // TODO Auto-generated method stub System.out.println(" ordinary house foundation "); } @Override public void buildWalls() { // TODO Auto-generated method stub System.out.println(" ordinary house wall "); } @Override public void roofed() { // TODO Auto-generated method stub System.out.println(" ordinary house capped "); } }
client
public class Client { public static void main(String[] args) { // TODO Auto-generated method stub CommonHouse commonHouse = new CommonHouse(); commonHouse.build(); } }
Problem Analysis in the Traditional Way
- The advantage is that it is easier to understand and easy to operate.
- The designed program structure is too simple, the cache layer object is not designed, and the program expansion and maintenance are not good That is to say, this design scheme packages the product (i.e., the house) and the process of creating the product (i.e., the building process), and the coupling is enhanced
- Solution: Decouple product and product building process => Builder pattern.
Basic introduction to builder mode
- The Builder Pattern, also known as the Builder Pattern, is an object construction pattern. It can abstract the construction process of complex objects (abstract category), so that different implementation methods of this abstract process can construct objects with different performance (attributes).
- The builder pattern is to create a complex object step by step, it allows users to build complex objects only by specifying their type and content, the user does not need to know the specific construction details inside.
The Four Characters of Builder Mode
- Product: A specific product object.
- Builder (abstract builder): Creates an interface/abstract class specified by each component of a Product object.
- ConcreteBuilder (concrete builder): implements the interface, builds and assembles the various components.
- Director: Constructs an object using 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, and the other is to control the production process of product objects.
Applications
Top-level builder base class
public abstract class HouseBuilder { protected House house = new House(); //Write the construction process, abstract method public abstract void buildBasic(); public abstract void buildWalls(); public abstract void roofed(); //Build the house well, return the product (house) public House buildHouse() { return house; } }
Concrete builder implementation class
public class CommonHouse extends HouseBuilder { @Override public void buildBasic() { // TODO Auto-generated method stub System.out.println(" Ordinary house lays foundation 5 meters "); } @Override public void buildWalls() { // TODO Auto-generated method stub System.out.println(" ordinary house wall 10 cm "); } @Override public void roofed() { // TODO Auto-generated method stub System.out.println(" ordinary house roof "); } }
public class HighBuilding extends HouseBuilder { @Override public void buildBasic() { // TODO Auto-generated method stub System.out.println(" The foundation of high-rise building is 100 meters "); } @Override public void buildWalls() { // TODO Auto-generated method stub System.out.println(" Building walls 20 cm "); } @Override public void roofed() { // TODO Auto-generated method stub System.out.println(" Transparent roof of tall building "); } }
Commander, according to the builder to formulate the process
//Commander, go here to specify the production process and return to the product public class HouseDirector { HouseBuilder houseBuilder = null; //The constructor passes in houseBuilder public HouseDirector(HouseBuilder houseBuilder) { this.houseBuilder = houseBuilder; } //Pass in houseBuilder via setter public void setHouseBuilder(HouseBuilder houseBuilder) { this.houseBuilder = houseBuilder; } //How to handle the process of building a house, leave it to the conductor public House constructHouse() { houseBuilder.buildBasic(); houseBuilder.buildWalls(); houseBuilder.roofed(); return houseBuilder.buildHouse(); } }
Application and source code analysis of builder pattern in JDK
Builder pattern in java.lang.StringBuilder
stringBuilder implements the AbstractStringBuilder abstract class
But in AbstractStringBuilder has actually implemented the append method of Appendable
Analysis of the role of the builder mode in the source code
- The Appendable interface defines multiple append methods (abstract methods), that is, Appendable is an abstract builder and defines abstract methods
- AbstractStringBuilder implements the Appendable interface method, where AbstractStringBuilder is already a builder, but cannot be instantiated
- StringBuilder acts as a conductor and a specific builder. The implementation of the construction method is completed by AbstractStringBuilder.
into, and StringBuilder inherits AbstractStringBuilder
Builder Mode Notes and Details
-
The client (using program) does not need to know the details of the internal composition of the product, decoupling the product itself from the product creation process, so that the same creation process can create different product objects
-
Each specific builder is relatively independent and has nothing to do with other specific builders, so it is easy to replace specific builder or add new specific builder, and users can get different product objects by using different specific builder
-
More granular control over the product creation process. Breaking down the steps of creating complex products into different methods makes the creation process clearer and easier to use programs to control the creation process
-
Adding new concrete builders does not need to modify the code of the original class library, the commander class is programmed for the abstract builders class, the system is easy to expand, and conforms to the "open-closed principle"
-
Products created by the builder mode generally have more in common, and their components are similar. If the differences between the products are large, the builder mode is not suitable for use, so its scope of use is limited.
-
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 very large system, so in this case, consider whether to choose the builder mode.
-
Abstract Factory Pattern VS Builder Pattern
The abstract factory pattern realizes the creation of a product family. A product family is a series of products: product combinations with different classification dimensions. Using the abstract factory pattern does not need to care about the construction process, but only cares about which products are produced by which factories. The builder mode is to build a product according to a specified blueprint, and its main purpose is to generate a new product by assembling spare parts