设计模式 -- Builder（构建器）

构建器(Builder)

将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）

在软件系统中，有时候面临着“一个复杂对象”的创建工作，期通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法却相对稳定。

Builder其实和Template Method有一些相似，而Builder主要是为了解决对象创建的问题

即一个对象创建后需要做一部分固定的工作、可以交由构建器做这一部分工作后返回

代码

假设需要构建一个房屋的对象，这个房子的建造过程相对固定的，比如打地基、修墙、装门等等，虽然步骤相对固定，但是具体的墙、门、窗可能都存在差异。
那么使用如下的代码，把固定的部分实现为接口的流程（这里的做法很像Template Method）。
具体的房子只需要实现House的类，并重写那些接口方法就行了。

方式1

interface House{
    //....
};

// 房屋构建抽象类
abstract class HouseBuilder {
    House house;

    protected HouseBuilder(House house) {
        this.house = house;
    }

    public House GetResult(){
        return house;
    }

    protected House Init() {
        BuildPart1();

        for (int i = 0; i < 4; i++){
            BuildPart2();
        }

        BuildPart3();

        BuildPart4();

        BuildPart5();

        return GetResult();
    }

    protected abstract void BuildPart1();
    protected abstract void BuildPart2();
    protected abstract void BuildPart3();
    protected abstract void BuildPart4();
    protected abstract void BuildPart5();
};

// 房屋具体实现类
class StoneHouse implements House {

};

// 房屋构建具体实现类
class StoneHouseBuilder extends HouseBuilder {

    protected StoneHouseBuilder(House house) {
        super(house);
    }

    public void BuildPart1(){
        // house.part1
    }
    public void BuildPart2(){

    }
    public void BuildPart3(){

    }
    public void BuildPart4(){

    }
    public void BuildPart5(){

    }
};

public class Main {
    private HouseBuilder houseBuilder;

    public Main(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    @Test
    public void T1() {
        // 由里面的房屋构造器做了一系列复杂的操作后返回对象
        House house = houseBuilder.Init();
    }
}

方式2

interface House{
    //....
};

// 房屋构建抽象类
abstract class HouseBuilder {
    House house;

    protected HouseBuilder(House house) {
        this.house = house;
    }
    
    public House GetResult(){
        return house;
    }

    protected abstract void BuildPart1();
    protected abstract void BuildPart2();
    protected abstract void BuildPart3();
    protected abstract void BuildPart4();
    protected abstract void BuildPart5();
};

// 房屋具体实现类
class StoneHouse implements House {

};

// 房屋构建具体实现类
class StoneHouseBuilder extends HouseBuilder {
    
    protected StoneHouseBuilder(House house) {
        super(house);
    }

    public void BuildPart1(){
        // house.part1
    }
    public void BuildPart2(){

    }
    public void BuildPart3(){

    }
    public void BuildPart4(){

    }
    public void BuildPart5(){

    }
};

class HouseDirector {

    public HouseBuilder houseBuilder;

    HouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder = houseBuilder;
    }

    House Construct(){

        houseBuilder.BuildPart1();

        for (int i = 0; i < 4; i++){
            houseBuilder.BuildPart2();
        }

        houseBuilder.BuildPart3();

        houseBuilder.BuildPart4();

        houseBuilder.BuildPart5();

        return houseBuilder.GetResult();
    }
};

public class Main {
    private HouseDirector houseDirector;
    
    public Main(HouseDirector houseDirector) {
        this.houseDirector = houseDirector;
    }

    @Test
    public void T1() {
        // 由里面的房屋构造器做了一系列复杂的操作后返回对象
        House house = houseDirector.Construct();
    }
}

总结

Builder模式主要用于“分步骤构建一个复杂对象”。在这其中“分步骤”是一个稳定算法，而复杂对象的各个部分则经常变化。
变化的点在哪里，封装哪里——Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法的需求变动”。