建立型模式：建造者模式

我的公众号原文：
建立型模式：建造者模式

五大建立型模式之四：建造者模式。

简介

姓名 ：建造者模式

英文名 ：Builder Pattern

价值观 ：专治丢三落四

我的介绍 ：

Separate the construction of a complex object from its representation so that the same construction process can create different representations.
将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。
（来自《设计模式之禅》）

今天给你们介绍的是建造者模式。建造者模式的使用场景是：建立复杂的对象。什么才能算复杂对象？若是一个对象只须要经过 new XXX() 的方式建立，那就算是一个简单对象；若是须要 new XXX()，而且还要设置不少属性，那这种就能够称为复杂对象了，由于它的构建过程比较复杂。采用建造者模式，能够把这个复杂的构建过程抽离开，使它不依赖建立者。下面咱们经过故事来说解。

你要的故事

还记得小时候刚开始学煮汤，不了解怎么煮，第一次是煮了板栗排骨汤，由于板栗比较难熟，因此是跟排骨一块儿下锅，而后煮了 40 分钟，加了盐就能够出锅啦。第二次煮了冬瓜排骨汤，不懂得冬瓜容易熟，就和排骨一块儿下锅，煮了也差很少 40 分钟，下了盐和香菜，发现怎么这汤有点浓，冬瓜咋都不见了（全都煮透了），我妈看到这锅汤，才跟我说冬瓜容易熟，得先熬排骨，再放冬瓜进去煮。那时才发现熬汤特么还有这差别。

上面是背景哈，接下来咱们来实现这个煲汤过程，冬瓜排骨汤是先加排骨，熬制 30 分钟，加冬瓜，熬制 18 分钟，加盐加香菜；板栗排骨汤是先加排骨和板栗，熬制 40 分钟，再加盐。这汤都须要加肉、加菜、熬制、加配料。咱们使用下面代码实现这个煲冬瓜排骨汤和板栗排骨汤的过程。

public class NoBuilderTest {

    public static void main(String[] args) {
        // 熬制冬瓜排骨汤
        DongGuaPaiGuSoup dongGuaPaiGuSoup = new DongGuaPaiGuSoup();
        // 加排骨
        dongGuaPaiGuSoup.addMeat();
        // 熬制 30 分钟
        dongGuaPaiGuSoup.waitMinute(30);
        // 加冬瓜
        dongGuaPaiGuSoup.addVegetables();
        // 熬制 10 分钟
        dongGuaPaiGuSoup.waitMinute(10);
        // 加盐加香菜
        dongGuaPaiGuSoup.addIngredients();

        // 熬制板栗排骨汤
        BanLiPaiGuSoup banLiPaiGuSoup = new BanLiPaiGuSoup();
        // 加排骨
        banLiPaiGuSoup.addMeat();
        // 加板栗
        banLiPaiGuSoup.addVegetables();
        // 熬制 40 分钟
        banLiPaiGuSoup.waitMinute(40);
        // 加盐
        banLiPaiGuSoup.addIngredients();
    }

}

/**
 * 煲汤接口
 */
interface Soup {

    /** 加肉 */
    void addMeat();
    /** 加菜 */
    void addVegetables();
    /** 熬制 */
    void waitMinute(int minute);
    /** 加配料 */
    void addIngredients();

}

/**
 * 冬瓜排骨汤
 */
class DongGuaPaiGuSoup implements Soup {

    @Override
    public void addMeat() {
        System.out.println("加排骨");
    }

    @Override
    public void addVegetables() {
        System.out.println("加冬瓜");
    }

    @Override
    public void waitMinute(int minute) {
        System.out.println("熬制 " + minute + " 分钟");
    }

    @Override
    public void addIngredients() {
        System.out.println("加盐、加香菜");
    }
}

/**
 * 板栗排骨汤
 */
class BanLiPaiGuSoup implements Soup {

    @Override
    public void addMeat() {
        System.out.println("加排骨");
    }

    @Override
    public void addVegetables() {
        System.out.println("加板栗");
    }

    @Override
    public void waitMinute(int minute) {
        System.out.println("熬制 " + minute + " 分钟");
    }

    @Override
    public void addIngredients() {
        System.out.println("加盐");
    }
}

上面代码简单实现了煲冬瓜排骨汤和板栗排骨汤。煲汤咱们要关注的点是：各操做的顺序，是先加肉先煮再加菜，仍是肉和菜一块儿放进锅煮。上面代码中，这个过程是谁控制的？是煲汤的人，因此顺序由煲汤的人决定，甚至有可能忘记放配料啥的，这样子的汤就味道不够好。那怎么去解决这些问题？

咱们经过建造者模式能够解决上面的 2 个问题：煲汤顺序问题和忘记加配料这种丢三落四行为。咱们将这个煲汤顺序从煲汤者分离开来，让煲汤者只须要决定煲什么汤就好，让建造者来保证煲汤顺序问题和防止漏加配料。

咱们用一个 SoupBuilder 来规范化煲汤过程，方法 buildSoup 给实现者提供一个设置煲汤顺序的地方。由于冬瓜排骨汤和板栗排骨汤熬制的过程不同，因此分别用 DongGuaPaiGuSoupBuilder 和 BanLiPaiGuSoupBuilder 来具体实现冬瓜排骨汤和板栗排骨汤的熬制过程，也就是消除熬制过程和煲汤者的依赖关系。 Director 则至关于一个菜单，提供为熬汤者来选择熬什么汤。具体代码以下所示。

public class BuilderTest {

    public static void main(String[] args) {
        Director director = new Director();
        // 熬制冬瓜排骨汤
        director.buildDongGuaPaiGuSoup();
        // 熬制板栗排骨汤
        director.buildBanLiPaiGuSoup();
    }

}

/**
 * 煲汤建造接口
 */
interface SoupBuilder {
    void buildSoup();
    Soup getSoup();
}

/**
 * 冬瓜排骨汤建造者
 */
class DongGuaPaiGuSoupBuilder implements SoupBuilder {

    private DongGuaPaiGuSoup dongGuaPaiGuSoup = new DongGuaPaiGuSoup();

    @Override
    public void buildSoup() {
        // 加排骨
        dongGuaPaiGuSoup.addMeat();
        // 熬制 30 分钟
        dongGuaPaiGuSoup.waitMinute(30);
        // 加冬瓜
        dongGuaPaiGuSoup.addVegetables();
        // 熬制 10 分钟
        dongGuaPaiGuSoup.waitMinute(10);
        // 加盐加香菜
        dongGuaPaiGuSoup.addIngredients();
    }

    @Override
    public Soup getSoup() {
        return dongGuaPaiGuSoup;
    }
}

/**
 * 板栗排骨汤建造者
 */
class BanLiPaiGuSoupBuilder implements SoupBuilder {

    BanLiPaiGuSoup banLiPaiGuSoup = new BanLiPaiGuSoup();

    @Override
    public void buildSoup() {
        // 加排骨
        banLiPaiGuSoup.addMeat();
        // 加板栗
        banLiPaiGuSoup.addVegetables();
        // 熬制 40 分钟
        banLiPaiGuSoup.waitMinute(40);
        // 加盐
        banLiPaiGuSoup.addIngredients();
    }

    @Override
    public Soup getSoup() {
        return banLiPaiGuSoup;
    }
}

/**
 * 生产方
 */
class Director {
    private DongGuaPaiGuSoupBuilder dongGuaPaiGuSoupBuilder = new DongGuaPaiGuSoupBuilder();
    private BanLiPaiGuSoupBuilder banLiPaiGuSoupBuilder = new BanLiPaiGuSoupBuilder();

    /**
     * 熬制冬瓜排骨汤
     */
    public DongGuaPaiGuSoup buildDongGuaPaiGuSoup() {
        dongGuaPaiGuSoupBuilder.buildSoup();
        return (DongGuaPaiGuSoup) dongGuaPaiGuSoupBuilder.getSoup();
    }

    /**
     * 熬制板栗排骨汤
     */
    public BanLiPaiGuSoup buildBanLiPaiGuSoup() {
        banLiPaiGuSoupBuilder.buildSoup();
        return (BanLiPaiGuSoup) banLiPaiGuSoupBuilder.getSoup();
    }

}

经过用建造者实现，是否是保证了熬制汤的顺序而且必定会加够料？感觉一下其中的奥秘吧。

代码：
Builder Pattern

总结

经过建造者模式，能够把原本强依赖的东西解绑，不单单解决依赖问题，还提升了封装性，让使用者不用明白内部的细节，用上面的例子说就熬汤不用关心怎么熬制的过程，就像咱们想喝冬瓜排骨汤，告诉妈妈，妈妈熬制，咱们并不知道是怎么熬制的。

参考资料：《大话设计模式》、《Java设计模式》、《设计模式之禅》、《研磨设计模式》、《Head First 设计模式》

推荐阅读：
建立型模式：单例模式
建立型模式：工厂方法
建立型模式：抽象工厂
公众号之设计模式系列文章

但愿文章对您有所帮助，设计模式系列会持续更新，感兴趣的同窗能够关注公众号：LieBrother，第一时间获取文章推送阅读，也能够一块儿交流，交个朋友。