设计模式之建造者

前言

最近绝地逃生这个游戏大火，好多朋友为了吃鸡，都会自己组装一个高配主机来支持自己打游戏 。而这个组装主机的过程就是建造者模式最真实的写照....~。~

什么是建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建工程可以创建不同的表示。

UML类图

• Product:要构造的复杂的对象
• Builder:定义一个抽象构造接口，规范产品每个部件的构造，并不涉及具体实现
• ConcreteBuilder:真正的构造者，对产品每个部件的构造给出具体实现，并提供该产品的实例
• Director:作为一个导演，它的职责就是调用ConcreteBuilder，让产品的部件按照我们指定的顺序去设置，然后返回我们的实例

代码分析

public class Computer {

    private String cpu;
    //主板
    private String mainboard;
    //内存
    private String memory;
    //显卡
    private String graphicsCard;
    //电源
    private String powerSource;

    public String getCpu() {
        return cpu;
    }

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

    public String getMainboard() {
        return mainboard;
    }

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

    public String getMemory() {
        return memory;
    }

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

    public String getGraphicsCard() {
        return graphicsCard;
    }

    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }

    public String getPowerSource() {
        return powerSource;
    }

    public void setPowerSource(String powerSource) {
        this.powerSource = powerSource;
    }

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

public interface ComputerBuilder {

    void buildCpu();
    void buildMainboard();
    void buildMemory();
    void buildGraphicsCard();
    void buildPowerSource();

    Computer build();
}

public class ConcreteComputerBuilder implements ComputerBuilder {

    private Computer computer = new Computer();

    @Override
    public void buildCpu() {
        computer.setCpu("intel 7700");
    }

    @Override
    public void buildMainboard() {
        computer.setMainboard("华硕b5");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("海盗船16g内存条双交火");
    }

    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("n卡1080");
    }

    @Override
    public void buildPowerSource() {
        computer.setPowerSource("安钛克全模组金牌额定500w");
    }

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

public class ComputerDirector {

    private ComputerBuilder builder = new ConcreteComputerBuilder();

    public Computer getComputer(){

        builder.buildCpu();
        builder.buildGraphicsCard();
        builder.buildMainboard();
        builder.buildMemory();
        builder.buildPowerSource();

        return builder.build();
    }

}

public class Client {

    public static void main(String[] args) {

        ComputerDirector computerDirector = new ComputerDirector();
        Computer computer = computerDirector.getComputer();

        System.out.println("这个电脑的配置为:"+computer.toString());

    }
}
测试结果:这个电脑的配置为:Computer{cpu='intel 7700', mainboard='华硕b5', memory='海盗船16g内存条双交火', graphicsCard='n卡1080', powerSource='安钛克全模组金牌额定500w'}

使用场景

• 需要产生的对象有复杂的结构
• 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。
• 相同的方法，不同的执行顺序产生不同的结果。

或许会有人对第三个不是特别理解，因为在装机这个业务体现的不是特别明显。我们不妨换个场景考虑，煮汤都有特定的工序，什么时候加水，先加什么调料后加什么调料，如果你加的顺序不一样，做出的汤的味道都会有差别，对于此种场景可以使用该模式

总结

使用建造者模式，可以屏蔽产品内部实现的细节，直接生产产品即可。建造者都是独立的，我们可以对建造过程进行优化和细化，不会对其他的模块产生影响。建造者模式和工厂模式十分相像，但建造者模式关注的是配件和装配工艺（顺序），而工厂模式的中心是对象的创建.