设计模式之建造者模式

1. 建造者模式简介

• 建造者模式

  • 简单地说，就是一步步创建一个对象，它对用户屏蔽了里面构建的细节，但却可以精细地控制对象的构造过程，将复杂对象的构建与它的表示分离。

• 场景

  • 电脑有高配电脑、低配电脑，组装需要不同配置的主板、cpu、内存·····

  • 肯德基套餐，不同的食品组装成不同的套餐。

• 核心组成

  • Builder：抽象建造者，定义通用方法和构建方法
  • ConcreteBuilder：具体建造者，可以定义多个，代表不同的组合
  • Director：指挥者，控制整个组合过程，将需求交给建造者，由建造者去创建对象
  • Product：产品角色

  我们举一个电脑的例子，电脑有高配和低配两种，结构图如下所示：

2. 建造者模式举例

首先创建产品类：电脑

public class Computer {
    // cpu
    private String cpu;
    // 内存
    private String memory;
    // 主板
    private String mainboard;
    // 磁盘
    private String disk;
    //电源
    private String power;

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getMainboard() {
        return mainboard;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                ", disk='" + disk + '\'' +
                ", power='" + power + '\'' +
                '}';
    }
}

之后是抽象建造者接口Builder

定义一些公有方法

/**
 * 抽象建造者
 */
public interface Builder {
    /**
     * 接口方法
     */
    // 建造cpu
    void  buildCpu();
    // 建造内存
    void  buildMemory();
    // 建造主板
    void  buildMainboard();
    // 建造磁盘
    void  buildDisk();
    // 建造电源
    void  buildPower();
    // 指定一个电脑对象
    Computer increateComputer();
}

之后是具体建造者A：高配电脑建造者

/**
 * 具体建造者A:高配电脑建造者
 */
public class HighComputerBuilder implements Builder{
    Computer computer = new Computer();

    @Override
    public void buildCpu() {
        computer.setCpu("高配cpu");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("高配内存");
    }

    @Override
    public void buildMainboard() {
        computer.setMainboard("高配主板");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("高配磁盘");
    }

    @Override
    public void buildPower() {
        computer.setPower("高配电源");
    }

    @Override
    public Computer increateComputer() {
        return computer;
    }
}

再然后是具体建造者B：低配电脑建造者

/**
 * 具体建造者B:低配电脑
 */
public class LowComputerBuilder implements Builder{
    Computer computer = new Computer();

    @Override
    public void buildCpu() {
        computer.setCpu("低配cpu");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("低配内存");
    }

    @Override
    public void buildMainboard() {
        computer.setMainboard("低配主板");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("低配磁盘");
    }

    @Override
    public void buildPower() {
        computer.setPower("低配电源");
    }

    @Override
    public Computer increateComputer() {
        return computer;
    }
}

之后是指挥类Director，控制产品生产过程

public class Director {

    public Computer increate(Builder builder){
        builder.buildMemory();
        builder.buildCpu();
        builder.buildDisk();
        builder.buildPower();
        builder.buildMainboard();
        return builder.increateComputer();
    }
}

测试类

@Test
public void test01(){
    //  声明指挥者
    Director director = new Director();
    // 指挥者构造低配电脑
    Computer computer1 = director.increate(new LowComputerBuilder());
    // 指挥者构造高配电脑
    Computer computer2 = director.increate(new HighComputerBuilder());
    System.out.println(computer1);
    System.out.println(computer2);
}

结果

Computer{cpu='低配cpu', memory='低配内存', mainboard='低配主板', disk='低配磁盘', power='低配电源'}
Computer{cpu='高配cpu', memory='高配内存', mainboard='高配主板', disk='高配磁盘', power='高配电源'}

3. 小结

建造者模式的优点

• 封装性较好，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要逻辑封装在导演类中对整体而言可以取得比较好的稳定性。

• 客户端不必知道产品内部组成的细节，将产品的与产品的创建过程解耦开。

• 每一个具体建造者相对于其他具体建造者都独立，可以更加精细的控制产品流程。

• 增加新的具体建造者无需修改原来的代码，符合开闭原则。

建造者模式的缺点

• 建造者模式所创建的产品一般具有较多的相同点，如果产品差异大则不建议使用。

适用场景

• 产品对象内部具有复杂的结构，产品对象包含多个成员属性，使用建造者模式可以把对象和对象的创建隔离开来。

建造者模式与抽象工厂模式的比较

• 建造者模式是把对象的创建过程分散开来，每个抽象方法只负责其中的一部分。抽象工厂是每个方法负责一个对象。
• 建造者模式所有方法加到一起才能生成一个对象，抽象工厂一个方法就可以生成一个对象。

学习于：
建造者模式（Builder）及其应用
初学Java常用设计模式之——建造者模式