建造者模式

简介

　　建造者模式使用多个简单的对象创建一个复杂的对象，用于将一个复杂的构建与其表示分离，使得同样的构建过程可以创建不同的表示，然后通过一个builder类创建最终的对象。

　　注意，建造者模式与工厂模式的最大区别是，建造者模式更关注产品的组合方式和装配顺序，而工厂模式关注产品的生产本身。

　　建造者模式在设计时有以下几种角色。

　　Builder：创建一个复杂产品对象的抽象接口。

　　ConcreteBuilder：Builder接口的实现类，用于定义复杂产品各个部件的装配流程。

　　Director：构造一个使用Builder接口的对象。

　　Product：表示被构造的复杂对象。ConcreteBuilder定义了该复杂对象的装配流程，而Product定义了该复杂对象的结构和内部表示。

　　以生产一个电脑为例，电脑的生产包括CPU，Memory，Disk等生产过程，这些生产过程对顺序不敏感，这里的Product就是电脑。

具体实现

　　1.定义需要生产的Computer

public class Computer {
    private String cpu;
    private String memory;
    private String disk;

    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 getDisk() {
        return disk;
    }

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

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

　　以上代码定义了一个Computer类来描述我们要生产的产品。

　　2.定义抽象接口ComputerBuilder来描述产品构造和装配的过程。

public interface ComputerBuilder {
    void buildCpu();
    void buildMemory();
    void buildDisk();
    Computer buildComputer();
}

　　3.定义ComputerBuilder接口实现类ComputerConcreteBuilder以实现构造和装配该产品的各个细节。

public class ComputerConcreteBuilder implements ComputerBuilder {

    Computer computer;

    public ComputerConcreteBuilder(){
        computer = new Computer();
    }

    @Override
    public void buildCpu() {
        System.out.println("build cpu...");
        computer.setCpu("8 core");
    }

    @Override
    public void buildMemory() {
        System.out.println("build memory...");
        computer.setMemory("16 GB");
    }

    @Override
    public void buildDisk() {
        System.out.println("build disk...");
        computer.setDisk("1 TB");
    }

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

　　4.定义ComputerDirector使用Builder接口实现产品的装配

public class ComputerDirector {
    public Computer constructComputer(ComputerBuilder computerBuilder){
        computerBuilder.buildCpu();
        computerBuilder.buildMemory();
        computerBuilder.buildDisk();
        return computerBuilder.buildComputer();
    }
}

　　以上代码定义了ComputerDirector来调用ComputerBuilder接口实现电脑的组装，具体组装顺序为buildCpu，buildMemory，buildDisk和buildComputer。该类是建造者模式对产品生产过程的封装，在需求发生变化且需要先装配完磁盘再装配内存时，只需要调整Director的顺序即可，每个组件的装配都稳定不变。

　　5.构建Computer

public class Test {
    public static void main(String[] args) {
        ComputerDirector computerDirector = new ComputerDirector();
        ComputerBuilder computerBuilder = new ComputerConcreteBuilder();
        Computer computer = computerDirector.constructComputer(computerBuilder);
        System.out.println(computer);
    }
}

　　以上代码首先定义了一个ComputerDirector和ComputerBuilder为构建Computer做好准备，然后通过调用ComputerDirector的constructComputer实现产品Computer的构建，运行结果如下

build cpu...
build memory...
build disk...
Computer{cpu='8 core', memory='16 GB', disk='1 TB'}