实例：举一个盖房项目的例子
盖房子有一系列过程比如打桩、砌墙、封顶。
房子有各种各样的，比如普通房，高楼，别墅，这些房子的盖的过程虽然一样，但是具体的要求是不相同的.
传统方式解决盖房需求1) 思路分析(图解)
首先房子有各种各样的，所以可以抽象出一个父类AbstractHouse ，提供了盖房子的功能，包括打桩、砌墙、封顶。
普通房，高楼，别墅可以去继承父类AbstractHouse，重写方法，实现具体的要求
package com.dongguo.builder;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:27
* @description:
*/
public abstract class AbstractHouse {
//打地基
public abstract void buildBasic();
//砌墙
public abstract void buildWalls();
//封顶
public abstract void roofed();
public void build() {
buildBasic();
buildWalls();
roofed();
}
}package com.dongguo.builder;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:28
* @description: 普通房子
*/
public class CommonHouse extends AbstractHouse {
@Override
public void buildBasic() {
System.out.println(" 普通房子打地基");
}
@Override
public void buildWalls() {
System.out.println(" 普通房子砌墙");
}
@Override
public void roofed() {
System.out.println(" 普通房子封顶");
}
}package com.dongguo.builder;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:29
* @description:
*/
public class Client {
public static void main(String[] args) {
CommonHouse commonHouse = new CommonHouse();
commonHouse.build();
}
}
运行结果
普通房子打地基
普通房子砌墙
普通房子封顶传统方式的问题分析
1) 优点是比较好理解，简单易操作。
2) 设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展和维护不好. 也就是说，这种设计方案，把产品(即：房子) 和创建产品的过程(即：建房子流程) 封装在一起，耦合性增强了。
解决方案：将产品和产品建造过程解耦=> 建造者模式.
建造者模式Builder模式也叫建造者模式或者生成器模式，用来隐藏复合对象的创建过程，建造者，用于对复杂对象的构造、初始化，与工厂模式不同的是，建造者的目的在于把复杂构造过程从不同对象展现中抽离出来，使得同样的构造工序可以展现出不同的产品对象。
建造者模式通常包括下面几个角色：
1、Builder（抽象建造者）：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2、ConcreteBuilder（具体建造者）：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
3、Director（指挥者）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
4、Product（产品角色）：要创建的复杂对象。
建造者模式原理类图
下面我们使用建造者模式(Builder Pattern)来解决盖房需求应用实例
思路分析图解(类图)
HouseBuilder 作为抽象建造者，CommonHouse 普通房子，HighBuilding 高楼作为具体建造者
HouseBuilder 作为指挥者指定房子的建造流程
package com.dongguo.builder.improve;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:39
* @description:
*/
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.dongguo.builder.improve;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:39
* @description: 抽象的建造者
*/
public abstract class HouseBuilder {
protected House house = new House();
//将建造的流程写好, 抽象的方法
public abstract void buildBasic();
public abstract void buildWalls();
public abstract void roofed();
//建造房子好， 将产品(房子) 返回
public House buildHouse() {
return house;
}
}package com.dongguo.builder.improve;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:40
* @description:
*/
public class CommonHouse extends HouseBuilder {
@Override
public void buildBasic() {
System.out.println(" 普通房子打地基5 米");
}
@Override
public void buildWalls() {
System.out.println(" 普通房子砌墙10cm ");
}
@Override
public void roofed() {
System.out.println(" 普通房子屋顶");
}
}package com.dongguo.builder.improve;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:40
* @description:
*/
public class HighBuilding extends HouseBuilder {
@Override
public void buildBasic() {
System.out.println(" 高楼的打地基100 米");
}
@Override
public void buildWalls() {
System.out.println(" 高楼的砌墙20cm ");
}
@Override
public void roofed() {
System.out.println(" 高楼的透明屋顶");
}
}package com.dongguo.builder.improve;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:41
* @description: 指挥者，这里去指定制作流程，返回产品
*/
public class HouseDirector {
HouseBuilder houseBuilder = null;
//构造器传入houseBuilder
public HouseDirector(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
//通过setter 传入houseBuilder
public void setHouseBuilder(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
//如何处理建造房子的流程，交给指挥者
public House constructHouse() {
houseBuilder.buildBasic();
houseBuilder.buildWalls();
houseBuilder.roofed();
return houseBuilder.buildHouse();
}
}package com.dongguo.builder.improve;
/**
* @author Dongguo
* @date 2021/8/22 0022-12:41
* @description:
*/
public class Client {
public static void main(String[] args) {
//盖普通房子
CommonHouse commonHouse = new CommonHouse();
//准备创建房子的指挥者
HouseDirector houseDirector = new HouseDirector(commonHouse);
//完成盖房子，返回产品(普通房子)
House house = houseDirector.constructHouse();
//System.out.println("输出流程");
System.out.println("--------------------------");
//盖高楼
HighBuilding highBuilding = new HighBuilding();
//重置建造者
houseDirector.setHouseBuilder(highBuilding);
//完成盖房子，返回产品(高楼)
houseDirector.constructHouse();
}
}
运行结果
普通房子打地基5 米
普通房子砌墙10cm
普通房子屋顶
--------------------------
高楼的打地基100 米
高楼的砌墙20cm
高楼的透明屋顶java.lang.StringBuilder 中的建造者模式
public class Builder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Hello World");
System.out.println(sb);
}
}
Appendable 接口定义了多个append 方法(抽象方法), 即Appendable 为抽象建造者, 定义了抽象方法
package java.lang;
import java.io.IOException;
public interface Appendable {
Appendable append(CharSequence csq) throws IOException;
Appendable append(CharSequence csq, int start, int end) throws IOException;
Appendable append(char c) throws IOException;
}AbstractStringBuilder 实现了Appendable 接口方法，这里的AbstractStringBuilder 已经是建造者，只是不能实例化
StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由AbstractStringBuilder 完成, 而StringBuilder 继承了AbstractStringBuilder
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence {
...
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
...
}
abstract class AbstractStringBuilder implements Appendable, CharSequence {
...
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
...
}
建造者模式的优点1）封装性：使用建造者模式可以是客户端不必知道产品内部组成的细节。
2）建造者独立，容易扩展：BenzBuilder和BMWBuilder是相互独立的，对系统扩展非常有利。
3）便于控制细节风险：由于具体的建造者是独立的，因此可以对建造者过程逐步细化，而不对其他的模块产生任何影响。
总结
1）相同的方法，不同的执行顺序，产生不同的事件结果时，可以使用建造者模式。
2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不想同时，可以使用建造者模式。
3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这时候可以使用建造者模式。
4）在对象创建过程中会使用到系统的一些其他对象，这些对象在产品对象的创建过程中不易得到，也可以采用建造者模式封装该对象的创建过程。这种场景只能是一个补偿的方法，因为一个对象不容易获得，而在设计阶段竟然没有发现，而要通过设计这模式来柔化创建过程，本身设计已经出问题了。
到这里，我们会发现，建造者模式和工厂方法模式有点像。
抽象工厂模式VS 建造者模式抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品
