详解设计模式 建造者模式

建造者模式

建造者模式属于创建型设计模式，用来组装复杂的实例

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

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

模式类图

角色

1. 抽象建造者：Builder，目的是为了将建造的具体过程交给它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品
2. 具体的建造者： ConcreteBuilder，实现抽象建造者的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品
3. 产品类：Product，一般是一个较为复杂的对象
4. 管理类：Director，负责调用适当的建造者来组建产品，被用来封装程序中易变的部分

优点

1. 客户端不必知道产品内部组成的细节，封装性好
2. 建造者独立，容易扩展

实现

源码地址：github.com/mingyuHub/d…

以电脑为例，电脑拥有cpu，内存，硬盘，涉及的类：Builder(抽象建造者)，ConcreteBuilder(具体的建造者)，Computer(产品类)，Director(管理类)

抽象建造者

/**
 * @author: chenmingyu
 * @date: 2019/3/4 17:05
 * @description: 抽象建造者
 */
public abstract class Builder {

    /**
     * 组装cpu
     */
    public abstract void builderCpu(String cpu);

    /**
     * 组装内存
     */
    public abstract void builderMemory(String memory);

    /**
     * 组装硬盘
     */
    public abstract void builderDisk(String disk);

    /**
     * 获取电脑
     * @return
     */
    public abstract Computer getComputer();

}

具体的建造者

/**
 * @author: chenmingyu
 * @date: 2019/3/4 17:14
 * @description: 具体的建造者
 */
public class ConcreteBuilder extends Builder {

    private Computer computer = new Computer();

    @Override
    public void builderCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void builderMemory(String memory) {
        computer.setMemory(memory);
    }

    @Override
    public void builderDisk(String disk) {
        computer.setDisk(disk);
    }

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

产品类

/**
 * @author: chenmingyu
 * @date: 2019/3/4 16:57
 * @description: 电脑产品
 */
@Data
public class Computer {

    private String cpu;

    private String memory;

    private String disk;

}

主管类

/**
 * @author: chenmingyu
 * @date: 2019/3/4 17:10
 * @description: 主管类
 */
public class Director {

    private Builder builder = new ConcreteBuilder();

    /**
     * 组装电脑
     */
    public Computer builderComputer(String cpu, String memory, String disk){
        builder.builderCpu(cpu);
        builder.builderMemory(memory);
        builder.builderDisk(disk);
        return builder.getComputer();
    }
}

测试

public static void main(String[] args) {
    Director director = new Director();
    Computer computer = director.builderComputer("Intel cpu","内存","硬盘");
    System.out.println(computer);
}

输出

Computer(cpu=Intel cpu, memory=内存, disk=硬盘)

建造者模式与工程方法模式的不同在于建造者模式关注的是零件类型和装配工艺（顺序）

更常见的使用方式

使用静态内部类

public class Cache {

    private final String name;

    private final String condition;

    protected Cache(Builder b) {
        this.name = b.name;
        this.condition = b.condition;
    }

    public String getName() {
        return name;
    }

    public String getCondition() {
        return condition;
    }

    public static class Builder {

        private String name = "";
        private String condition = "";

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

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

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

使用时：

new Cache.Builder().setName("cmy").setCondition("condition").build()；

相关阅读

详解设计模式 单例模式

详解设计模式 工厂方法

详解设计模式 抽象工厂