建造者模式

建造者模式

使用多个简单的对象一步一步构建成一个复杂的对象，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

简而言之就是使用者对于产品的构建过程是不感知的，他只需要拿到对应的产品就可以了。

核心组成

• Builder：抽象方法，抽象的构建者。抽象所有的方法

• ConcreBuilder: 具体的构建者

• Director：调度者

• productor：产品
  
  用例场景： 比如对于KFC的菜单，对于一份套餐，可以由任意不同的单品进行组装从而形成不同的套餐产品； 另外，如今大家都喜欢自行组装机器，按照个人意愿组装不同的台式机。 这些都可以适用建造者模式。如下例子选择租装电脑场景。

实践场景

• Product

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

    public Computer() {
    }

    public Computer(String cpu, String memory, String disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = 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 + '\'' +
                '}';
    }

• Builder

/**
 *  抽象方法
 */
public interface Builder {
    void buildCpu();  // cpu

    void buildMemory();  // 存储

    void buildDisk();   // 磁盘
 
    Computer create();   
}

• ConcreBuilder

/**
 * 具体的建造者
 * 低配电脑
 */
public class LowComputer implements Builder{

    private Computer computer = new Computer();
    @Override
    public void buildCpu() {
        computer.setCpu("low cpu");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("low memory");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("low disk");
    }

    @Override
    public Computer create() {
        return computer;
    }
}
/**
 * 具体的建造者
 * 高配电脑
 */
public class HighComputerBuilder implements Builder{
    private Computer computer = new Computer();
    @Override
    public void buildCpu() {
        computer.setCpu("high cpu");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("high memory");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("high disk");
    }

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

• Director

/**
 * 建造调度者
 */
public class Dircetor {
    public Computer create(Builder builder) {
        builder.buildCpu();
        builder.buildDisk();
        builder.buildMemory();
        return builder.create();
    }

}

/**
     * 实现产品本身和产品建造过程的解耦，相同的过程建造不同的产品，可以定制不同的建造内容。
     * 对于产品的使用者，不需要感知产品的具体流程
     * 符合开闭原则
     * @param args
     */
    public static void main(String[] args) {
        Dircetor dircetor = new Dircetor();
        Builder lowComputerBuilder = new LowComputerBuilder();
        System.out.println(dircetor.create(lowComputerBuilder));
        System.out.println("------------");
        Builder highComputerBuilder = new HighComputerBuilder();
        System.out.println(dircetor.create(highComputerBuilder));
    }

综述

1. 如果要增加新建造者无需修改现有代码，符合开闭原则
2. 屏蔽掉用户与产品的建造

• 不适用的场景：

  所有的具体Builder都实现于抽象方法，不管是高配电脑还是低配电脑，都是电脑，特性相似。因此在产品差异大的场景，不适用建造者模式