设计模式 - 创建型模式分类之建造者模式

建造者模式是日常开发中比较常见的设计模式，它的主要作用就是将复杂事物创建的过程抽象出来，该抽象的不同实现方式不同，创建出的对象也不同。

建造者模式分为两种，一种为经典建造者模式，另一种为变种建造者模式。

经典Builder模式

从上述UML图可以看到，经典Buider模式中有四个角色：

1. 要建造的产品Product – 组装的电脑
2. 抽象的Builder – 装CPU、内存条、硬盘等抽象的步骤
3. Builder的具体实现ConcreteBuilder – 对上述抽象步骤的实现，比如装i5CPU、8G内存条、1T硬盘
4. 使用者Director – 电脑装机人员

经典Builder模式代码示例：

Computer实体类

public class Computer {
    /*CPU*/
    private String CPU;
    /*内存*/
    private String memory;
    /*硬盘*/
    private String hardDisk;
    /*键盘*/
    private String keyboard;
    /*鼠标*/
    private String mouse;

    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 getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getKeyboard() {
        return keyboard;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }

    public String getMouse() {
        return mouse;
    }

    public void setMouse(String mouse) {
        this.mouse = mouse;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "CPU='" + CPU + '\'' +
                ", memory='" + memory + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", keyboard='" + keyboard + '\'' +
                ", mouse='" + mouse + '\'' +
                '}';
    }
}

抽象Builder类

public interface ComputerConfigBuilder {
    void setCPU(String CPU);
    void setMemery(String memory);
    void setHardDisk(String hardDisk);
    void setKeyboard(String keyBoard);
    void setMouse(String mouse);
    Computer getComputer();
}

具体实现类

public class ConcreteComputerConfigBuilder implements ComputerConfigBuilder {

    private Computer mComputer;

    public ConcreteComputerConfigBuilder(){
        this.mComputer = new Computer();
    }

    @Override
    public void setCPU(String CPU) {
        mComputer.setCPU(CPU);
    }

    @Override
    public void setMemery(String memory) {
        mComputer.setMemory(memory);
    }

    @Override
    public void setHardDisk(String hardDisk) {
        mComputer.setHardDisk(hardDisk);
    }

    @Override
    public void setKeyboard(String keyBoard) {
        mComputer.setKeyboard(keyBoard);
    }

    @Override
    public void setMouse(String mouse) {
        mComputer.setMouse(mouse);
    }

    @Override
    public Computer getComputer() {
        return mComputer;
    }
}

组装Computer的类（这个类可有可无，如果属性之间没有确定的前后关系，可以不要此类，且此类的createComputer方法通用性也不好）

public class Director {
    private ConcreteComputerConfigBuilder mBuilder;
    
    public void setBuilder(ConcreteComputerConfigBuilder builder){
        this.mBuilder = builder;
    }
    
    public void createComputer(String CPU, String memory, String hardDisk, String keyBoard, String mouse){
        mBuilder.setCPU(CPU);
        mBuilder.setMemery(memory);
        mBuilder.setHardDisk(hardDisk);
        mBuilder.setKeyboard(keyBoard);
        mBuilder.setMouse(mouse);
    }
    
    public Computer getComputer(){
        return mBuilder.getComputer();
    }
}

创建Computer的测试类

Director director = new Director();		// 创建装机人员
ConcreteComputerConfigBuilder builder = new ConcreteComputerConfigBuilder();
director.setBuilder(builder); // 添加Builder类
director.createComputer("i7","16G","1T","Dell","Dell"); // 装机人员开始组装
Computer computer = director.getComputer(); // 从装机人员获取组装好的电脑
System.out.print("电脑配置：" + computer.toString());  // 查看电脑配置

变种Builder模式

变种Builder模式代码示例：

public class Person {
    /*名字（必须）*/
    private final String name;
    /*性别（必须）*/
    private final String gender;
    /*年龄（非必须）*/
    private final String age;
    /*鞋子（非必须）*/
    private final String shoes;
    /*衣服（非必须）*/
    private final String clothes;
    /*钱（非必须）*/
    private final String money;
    /*房子（非必须）*/
    private final String house;
    /*汽车（非必须）*/
    private final String car;
    /*职业（非必须）*/
    private final String career;

    private Person(Builder builder) {
        this.name = builder.name;
        this.gender = builder.gender;
        this.age = builder.age;
        this.shoes = builder.shoes;
        this.clothes = builder.clothes;
        this.money = builder.money;
        this.house = builder.house;
        this.car = builder.car;
        this.career = builder.career;
    }

    public static class Builder {
        private final String name;   // 必须属性用final修饰
        private final String gender;
        private String age;
        private String shoes;
        private String clothes;
        private String money;
        private String house;
        private String car;
        private String career;

        public Builder(String name,String gender) {
            this.name = name;
            this.gender = gender;
        }

        public Builder age(String age) {
            this.age = age;
            return this;
        }

        public Builder car(String car) {
            this.car = car;
            return this;
        }

        public Builder shoes(String shoes) {
            this.shoes = shoes;
            return this;
        }

        public Builder clothes(String clothes) {
            this.clothes = clothes;
            return this;
        }

        public Builder money(String money) {
            this.money = money;
            return this;
        }

        public Builder house(String house) {
            this.house = house;
            return this;
        }

        public Builder career(String career) {
            this.career = career;
            return this;
        }

        public Person build(){
            return new Person(this);
        }
    }
}

Person对象的创建：

Person person = new Person.Builder("zhangsan","male")
    .age("12")
    .money("1000000")
    .car("BMW")
    .build();

实际开发过程中使用变种Builder模式比较多。