【设计模式】建造者模式

定义

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

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

即：一个复杂对象的构成组件经常变化，但是这个复杂对象的构建过程是不变的。此时可以用建造者模式将将变与不变分离开。

与工厂模式的比较

与工厂系列模式不同的是，建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类，最终实现用同一套标准的制造工序能够产出不同的产品。

优缺点

优点：建造者独立，易扩展。便于控制细节风险。

缺点： 1. 产品必须有共同点，范围有限制。 2. 如内部变化复杂，会有很多的建造类。

例子

一个建房子的例子，房子类由地基、墙壁和屋顶组成。

public class Building {

    //建筑物的组件
    private List<String> buildingComponents = new ArrayList<>();

    public void setBasement(String basement){
        //地基
        this.buildingComponents.add(basement);
    }

    public void setWall(String wall){
        //墙体
        this.buildingComponents.add(wall);
    }

    public void setRoof(String roof){
        //屋顶
        this.buildingComponents.add(roof);
    }

    @Override
    public String toString(){
        String buildingStr = "";
        for (int i = buildingComponents.size(); i >= 0; i--) {
            buildingStr += buildingComponents.get(i);
        }
        return buildingStr;
    }
}

但是房子有别墅和公寓等等这类，不同的房子的地基、墙壁和屋顶的建造方式是不同的。也就是说：房子这个负责对象的构成组件是变化的。

//施工方接口
interface Builder{
    public void buildBasement();
    public void buildWall();
    public void buildRoof();
    public Building getBuilding();
}

//别墅施工队
public class HouseBuilder implements Builder{
    private Building house;
    public HouseBuilder(){
        house = new Building();
    }

    @Override
    public void buildBasement(){
        System.out.println("Hous打地基...");
        house.setBasement("House 地基\n");
    }

    @Override
    public void buildWall(){
        System.out.println("House垒墙壁...");
        house.setWall("House 墙壁");
    }

    @Override
    public void buildRoof(){
        System.out.println("House建屋顶...");
        house.setRoof("House 屋顶");
    }

    @Override
    public Building getBuilding(){
        return house;
    }
}

//公寓施工队
public class ApartmentBuilder implements Builder{
    private Building house;
    public ApartmentBuilder(){
        house = new Building();
    }

    @Override
    public void buildBasement(){
        System.out.println("Apartment打地基...");
        house.setBasement("Apartment 地基\n");
    }

    @Override
    public void buildWall(){
        System.out.println("Apartment垒墙壁...");
        house.setWall("Apartment 墙壁");
    }

    @Override
    public void buildRoof(){
        System.out.println("Apartment建屋顶...");
        house.setRoof("Apartment 屋顶");
    }

    @Override
    public Building getBuilding(){
        return house;
    }
}

建造顺序都是先打地基，再垒墙壁、最后盖屋顶。也就是说：房子这个复杂对象的构建过程是不变的。

我们可以将这个不变的构建过程抽象成一个建造者，用它建造房子：即Director类

//工程总监类
public class Director{
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }

    public void setBuilder(Builder builder){
        this.builder = builder;
    }

    public Building direct(){
        System.out.println("****工程项目启动****");
        builder.buildBasement();
        builder.buildRoof();
        builder.buildRoof();
        System.out.println("****工程项目竣工****");
        return builder.getBuilding();
    }
}

切换施工队变得很方便：

public class Client{
    public static void main(String[] args) {
        //组件别墅施工队
        Director director = new Director(new HouseBuilder())
        //别墅施工队施工
        System.out.println(director.direct());
        //替换施工队
        director.setBuilder(new ApartmentBuilder());
        System.out.println(director.direct());
    }
}

Peter's Blog

【设计模式】建造者模式

定义

与工厂模式的比较

优缺点

例子