设计模式：03-建造者模式

kikock2023-04-132023-04-13

1、盖房项目需求

1）需要建房子：这一过程为打桩、砌墙、封顶

2）房子有各种各样的，比如普通房，高楼，别墅，各种房子的过程虽然一样，但是要求不相同的。

3）请编写程序，完成需求。

2、传统方式解决盖房需求

1）思路分析（图解）

7mwat

2）代码演示

AbstractHouse 盖房子抽象类


public abstract class AbstractHouse {  
    /**  
     * 打地基  
     */  
    public abstract void buildBasic();  
    /**  
     * 砌墙  
     */  
    public abstract void buildWalls();  
    /**  
     * 封顶  
     */  
    public abstract void roofed();  
    public void build() {  
        buildBasic();  
        buildWalls();  
        roofed();  
    }  
}

CommonHouse 普通房子类



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("给普通房子封顶");  
    }  
}

HighBuilding 高楼房子


public class HighBuilding extends AbstractHouse {  
    /**  
     * 打地基  
     */  
    @Override  
    public void buildBasic() {  
        System.out.println("给高楼打地基");  
    }  
    /**  
     * 砌墙  
     */  
    @Override  
    public void buildWalls() {  
        System.out.println("给高楼砌墙");  
    }  
    /**  
     * 封顶  
     */  
    @Override  
    public void roofed() {  
        System.out.println("给高楼封顶");  
    }  
}

Clieng 客户端


public class Client {  
    public static void main(String[] args) {  
        // 盖普通房子  
        new CommonHouse().build();  
        // 盖高楼  
        new HighBuilding().build();  
    }  
}

3、传统方式解决盖房需求问题分析

1）优点是比较好理解，简单易操作。

2）设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展性和维护不好，也就是说，这种设计方案，把产品（即：房子）和创建产品的过程（即：建房子流程）封装在一起，耦合性增强了。

3）解决方案：将产品和产品建造过程解耦 => 建造者模式。

4、建造者模式

4.1 基本介绍

1）建造者模式（Builder Patter）：又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

2）建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

4.2 四个角色

1）Product（产品角色）：一个具体的产品对象，定义对象的基本结构和接口。

2）Builder（抽象建造者）：创建一个 Product 对象的各个部件指定的接口/抽象类，实现抽象产品的具体功能。

3）ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件，定义创建步骤并提供构建方法。

4）Director（指挥者）：构建一个使用 Builder 接口的对象。他主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。可选，用于协调建造过程的步骤顺序

4.3 应用实例

1）需要建房子：这一过程为打桩、砌墙、封顶。不管是普通房子也好，别墅也好都需要经历这些过程，下面我们使用建造者模式（Builder Pattern）来完成。

3）代码实现

House 房子类


public class House {  
    /**  
     * 地基  
     */  
    private String basic;  
    /**  
     * 墙  
     */  
    private String wall;  
    /**  
     * 屋顶  
     */  
    private String roofed;  
    public String getBasic() {  
        return basic;  
    }  
    public void setBasic(final String basic) {  
        this.basic = basic;  
    }  
    public String getWall() {  
        return wall;  
    }  
    public void setWall(final String wall) {  
        this.wall = wall;  
    }  
    public String getRoofed() {  
        return roofed;  
    }  
    public void setRoofed(final String roofed) {  
        this.roofed = roofed;  
    }  
}

HouseBuilder 房子建造者抽象类


public abstract class HouseBuilder {  
    protected House house = new House();  
    /**  
     * 打地基  
     */  
    public abstract void buildBasic();  
    /**  
     * 砌墙  
     */  
    public abstract void buildWall();  
    /**  
     * 封顶  
     */  
    public abstract void roofed();  
    /**  
     * 建造房子好后，将产品（房子）返回  
     *  
     * @return 建造的房子  
     */  
    public House build() {  
        return house;  
    }  
}

CommonHouse 普通房子类


public class CommonHouse extends HouseBuilder {  
    /**  
     * 打地基  
     */  
    @Override  
    public void buildBasic() {  
        System.out.println("普通房子打地基5米");  
    }  
    /**  
     * 砌墙  
     */  
    @Override  
    public void buildWall() {  
        System.out.println("普通房子砌墙10cm");  
    }  
    /**  
     * 封顶  
     */  
    @Override  
    public void roofed() {  
        System.out.println("普通房子封顶");  
    }  
}

HighBuilding 高楼房子类


public class HighBuilding extends HouseBuilder {  
    /**  
     * 打地基  
     */  
    @Override  
    public void buildBasic() {  
        System.out.println("高楼打地基100米");  
    }  
    /**  
     * 砌墙  
     */  
    @Override  
    public void buildWall() {  
        System.out.println("高楼砌墙20cm");  
    }  
    /**  
     * 封顶  
     */  
    @Override  
    public void roofed() {  
        System.out.println("高楼封顶");  
    }  
}

HouseDirector 房子指挥者类


public class HouseDirector {  
    private HouseBuilder houseBuilder;  
    // 构造器传入 HouseBuilder    
    public HouseDirector(HouseBuilder houseBuilder) {  
        this.houseBuilder = houseBuilder;  
    }  
    // 通过setter 传入 HouseBuilder    
    public void setHouseBuilder(final HouseBuilder houseBuilder) {  
        this.houseBuilder = houseBuilder;  
    }  
    /**  
     * 如何处理建造房子的流程，交给指挥者  
     *  
     * @return 建造的房子  
     */  
    public House construct() {  
        houseBuilder.buildBasic();  
        houseBuilder.buildWall();  
        houseBuilder.roofed();  
        return houseBuilder.build();  
    }  
}

Client 客户端类


public class Client {  
    public static void main(String[] args) {  
        // 盖普通房子  
        CommonHouse commonHouse = new CommonHouse();  
        // 准备创建房子的指挥者  
        HouseDirector houseDirector = new HouseDirector(commonHouse);  
        // 完成盖房子，返回产品(普通房子)  
        houseDirector.construct();  
  
        System.out.println("------------------");  
  
        // 盖高楼  
        HighBuilding highBuilding = new HighBuilding();  
        // 重置建造者  
        houseDirector.setHouseBuilder(highBuilding);  
        // 完成盖房子，返回产品(高楼)  
        houseDirector.construct();  
    }  
}

5、建造者模式在 JDK 的应用和源码分析

1）java.lang.StringBuilder 中的建造者模式

2）代码说明 + Debug源码

3）源码中建造者模式角色分析

Appendable 接口定义了多个 append 方法（抽象方法），即 Appendable 为抽象建造者，定义了抽象方法
AbstractStringBuilder 实现了 Appendable 接口方法，这里的 AbstractStringBuilder 已经是建造者，只是不能实例化
StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由AbstractStringBuilder 完成，而 StringBuilder 继承了 AbstractStringBuilder