建造者模式

建造者模式

引言

在软件开发工程中有时需要创建一个非常复杂的对象。比如，建造一座房子。需要建造墙壁、地面、窗户、门等，这些产品都由多个部件构成，可以灵活选择。使用工厂模式无法完成这些需求。

定义

构造者模式是将一个复杂对象的构造和表示分离，使同样的构建过程可以构建不同的表示。它将一个复杂的对象分解为一个简单的对象，一步步构建而成，他将变与不变相结合，即产品的组成部分是不变的，但每一部分可以灵活选择。

特点

优点

• 各个建造者相互独立有利于系统的扩展
• 客户端不必知道产品的内部组成细节，便于控制细节风险

缺点

• 产品的组成部分必须相同，这限制了其使用范围
• 如果该产品的内部组成复杂，该模式会增加很多建造者类

构造与实现

建造者模式由产品、抽象建造者、具体建造者、指挥者4个要素构成。

• 产品角色（Product）：它是包含多个组件的复杂对象，由具体的建造者建造各个部件
• 抽象建造者（Builder）：它是一个包含各个部件的抽象方法的接口，通常还包含一个返回复杂产品的方法getResult（）
• 具体建造者（Concrete Builder）：继承Builder抽象类，完成复杂产品的各个部件的具体创建方法
• 指挥者（Director）：它调用建造者对象各个部件的建造方法完成复杂对象的建造，在指挥者中不设计具体的产品。

模式实现

产品类

/**
 * create by wule on 2020/6/12
 * 产品-房子
 */
public class House {

    private String wall;

    private String floor;

    private String door;

    public void setWall(String wall) {
        this.wall = wall;
    }

    public void setFloor(String floor) {
        this.floor = floor;
    }

    public void setDoor(String door) {
        this.door = door;
    }

    /**
     * 显示房子属性
     * @return
     */
    public String show() {
        return "House{" +
                "wall='" + wall + '\'' +
                ", floor='" + floor + '\'' +
                ", door='" + door + '\'' +
                '}';
    }
}

抽象建造者

/**
 * create by wule on 2020/6/12
 * 抽象建造者
 */
public abstract class Builder {

    //创建产品对象
    protected House house = new House();

    public abstract void buildWall();

    public abstract void buildFloor();

    public abstract void buildDoor();

    public House getResult(){
        return house;
    }
}

具体建造者

/**
 * create by wule on 2020/6/12
 * 具体建造者
 */
public class BuilderImpl extends Builder {

    @Override
    public void buildWall() {
        house.setWall("红砖墙");
    }

    @Override
    public void buildFloor() {
        house.setFloor("木地板");
    }

    @Override
    public void buildDoor() {
        house.setDoor("防盗门");
    }
}

指挥者

/**
 * create by wule on 2020/6/12
 * 指挥者
 */
public class Director {

    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

    //建造对象
    public House builder(){
        builder.buildDoor();
        builder.buildFloor();
        builder.buildWall();
        return builder.getResult();
    }
}

客户端，使用者

/**
 * create by wule on 2020/6/12
 */
public class Client {

    public static void main(String[] args) {
        Builder builder = new BuilderImpl();
        Director director = new Director(builder);
        House house = director.builder();
        System.out.println(house.show());
    }
}

模式的使用场景

建造者模式创建的是复杂对象，其产品的各个模式经常面临着变化，但将他们组合在一起算法却相对稳定，所以通常在以下场景使用：

• 创建的对象比较复杂，由多个部件构成，各部件面临复杂的变化，但构件间的建造顺序相对稳定
• 创造复杂的对象的算法独立于该对象的组成部分以及他们的装配方式