设计模式-建造者模式

建造者模式（创建型模式）

定义

建造者模式（Builder），将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。[DP]

自己的理解：建造者模式是把复杂得对象的构建分离出来，然后调用者不用知道对象的构建细节，只需要指定类型，就可以得到构建好的对象，且对象完整。

特点

具体产品构建出来的顺序不变
指挥者按顺序调用建造者的各个方法
产品的构建步骤被拆分成每一个方法

结构

Builder：建造者父接口

ConcreteBuilder1：具体建造者

ConcreteBuilder2：具体建造者

Director：指挥者，构建一个产品时，调用建造者的各个方法

Product：具体产品

代码

例子：一个完整的小人作为具体产品，完整的产品必须有头、身体、手、腿，构建两个不同的小人作为两个具体的建造者，创建小人的所有步骤由指挥者调用，客户端调用只需指定需要哪种小人，就可以得到完整的小人（不会缺手缺脚）。

建造者父接口

/**
 * @ Author     ：fonxi
 * @ Date       ：2019/5/24 15:59
 * @ Description：创建一个Product对象的各个不见置顶的抽象接口
 */
public abstract class Builder {
    public abstract void buildHead();
    public abstract void buildBody();
    public abstract void buildHand();
    public abstract void buildFoot();

    public abstract Product GetResult();

}

　　具体建造者

/**
 * @ Author     ：fonxi
 * @ Date       ：2019/5/24 15:59
 * @ Description：具体的建造者
 */
public class ConcreteBuilder1 extends Builder{
    private Product product = new Product();

    @Override
    public void buildHead() { product.add("大大的头"); }

    @Override
    public void buildBody() { product.add("小小的身体"); }

    @Override
    public void buildHand() { product.add("胖胖的手"); }

    @Override
    public void buildFoot() { product.add("短短的腿"); }

    public Product GetResult(){
        return product;
    }
}

/**
 * @ Author     ：fonxi
 * @ Date       ：2019/5/24 15:59
 * @ Description：具体建造者
 */
public class ConcreteBuilder2 extends Builder{
    private Product product = new Product();

    @Override
    public void buildHead() { product.add("圆圆的头"); }

    @Override
    public void buildBody() { product.add("有点胖的身体"); }

    @Override
    public void buildHand() { product.add("漂亮的手"); }

    @Override
    public void buildFoot() { product.add("长长的腿"); }

    @Override
    public Product GetResult() {
        return product;
    }
}

　　指挥者

/**
 * @ Author     ：fonxi
 * @ Date       ：2019/5/24 16:00
 * @ Description：指挥者，构建一个使用Builder接口的对象
 */
public class Director {
    public void cooking(Builder builder){
        builder.buildHead();
        builder.buildBody();
        builder.buildHand();
        builder.buildFoot();
    }
}

　　具体产品

/**
 * @ Author     ：fonxi
 * @ Date       ：2019/5/24 16:00
 * @ Description  具体产品
 */
public class Product {
    private List<String> list = new ArrayList<>();

    //产品构建
    public void add(String str){
        list.add(str);
    }

    //创建出一个构建好的 产品
    public void show(){
        list.forEach(System.out::println);
    }
}

　　客户端调用类

/**
 * @ Author     ：fonxi
 * @ Date       ：2019/5/24 15:58
 * @ Description：客户端调用类
 */
public class TestController {
    public void print(){
        Director director = new Director();
        Builder concreteBuilder1 = new ConcreteBuilder1();
        Builder concreteBuilder2 = new ConcreteBuilder2();

        System.out.println("不漂亮的小人");
        director.cooking(concreteBuilder1);
        Product product = concreteBuilder1.GetResult();
        product.show();

        System.out.println("漂亮的小人");
        director.cooking(concreteBuilder2);
        product = concreteBuilder2.GetResult();
        product.show();
    }
}

　　输出

不漂亮的小人
大大的头
小小的身体
胖胖的手
短短的腿

漂亮的小人
圆圆的头
有点胖的身体
漂亮的手
长长的腿

　　只需要指定需要哪种类型的对象，那这个对象就会完完整整的拿到，不用关系构建的细节，也不会出现对象不完整。

使用场景

需要的创建的对象构建时非常复杂，且对象构建的过程是稳定的，但对象内部的构建通常面临着复杂的变化

优缺点

优点：

每一个建造者都相对独立，不管是替换还是新增都很方便，可扩展性性高
对象构建步骤拆分，能够更细的控制对象的创建过程
客户端调用不需要知道对象的构建细节，也不用去进行复杂得构建，简便

缺点：

构建的产品必须相同的建构步骤
类增多，项目变得复杂、庞大

总结

建造者模式和工厂类有点象，但更关注对象构建的顺序。建造者模式能解决产品建构时复杂，产品创建类型多变的情况，但是要求产品构建时稳定，所以有一定局限。

来源：https://www.cnblogs.com/fonxi/p/10934706.html

标签

建造者

director