设计模式-建造者模式

建造者模式

使用多个简单的对象一步一步构建成一个复杂的对象，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
允许用户只通过指定复杂对象的类型和内容就可以构建他们，不需要知道内部的具体构建细节

场景举例

KFC创建套餐：套餐是一个复杂对象，它一般包含汉堡，烤翅，饮料等组成部分，不同的套餐不同的组合，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构成一份完整的套餐。

核心组成

• Builder : 抽象建造者，定义多个通用方法和构建方法
• ConcreteBuilder ：具体建造者，可以有多个
• Director：指挥者，控制整个组合过程，将需求交给建造者，由建造者去创建对象
• Product：产品角色

根据上述场景进行编码实践

/**
 * 汉堡套餐实体类
 */
public class HamburgCombo {

    private String hamburg; // 汉堡包
    private String drinks; // 饮料
    private String chickenwings; // 鸡翅
    private String snaks; // 小吃

    public String getHamburg() {
        return hamburg;
    }

    public void setHamburg(String hamburg) {
        this.hamburg = hamburg;
    }

    public String getDrinks() {
        return drinks;
    }

    public void setDrinks(String drinks) {
        this.drinks = drinks;
    }

    public String getChickenwings() {
        return chickenwings;
    }

    public void setChickenwings(String chickenwings) {
        this.chickenwings = chickenwings;
    }

    public String getSnaks() {
        return snaks;
    }

    public void setSnaks(String snaks) {
        this.snaks = snaks;
    }

    @Override
    public String toString() {
        return "HamburgCombo{" +
                "hamburg='" + hamburg + '\'' +
                ", drinks='" + drinks + '\'' +
                ", chickenwings='" + chickenwings + '\'' +
                ", snaks='" + snaks + '\'' +
                '}';
    }
}
/**
 * 声明建造者的公共方法
 */
public interface Builder {

    void buildHamburg();
    void buildDrinks();
    void buildChickenwings();
    void buildSnaks();

    HamburgCombo createCombo();
}
/**
 * KFC套餐A
 */
public class ComboA implements Builder {

    private HamburgCombo combo = new HamburgCombo();

    @Override
    public void buildHamburg() {
        combo.setHamburg("香辣鸡腿堡");
    }

    @Override
    public void buildDrinks() {
        combo.setDrinks("百事可乐");
    }

    @Override
    public void buildChickenwings() {
        combo.setChickenwings("香辣鸡翅");
    }

    @Override
    public void buildSnaks() {
        combo.setSnaks("薯条");
    }

    @Override
    public HamburgCombo createCombo() {
        return combo;
    }
}

/**
 * KFC套餐B
 */
public class ComboB implements Builder {

    private HamburgCombo combo = new HamburgCombo();
    @Override
    public void buildHamburg() {
        combo.setHamburg("奥尔良鸡腿堡");
    }

    @Override
    public void buildDrinks() {
        combo.setDrinks("雪顶咖啡");
    }

    @Override
    public void buildChickenwings() {
        combo.setChickenwings("奥尔良烤翅");
    }

    @Override
    public void buildSnaks() {
        combo.setSnaks("上校鸡块");
    }

    @Override
    public HamburgCombo createCombo() {
        return combo;
    }
}
/**
* 组装
*/
public class Director {

    public HamburgCombo create(Builder builder) {
        builder.buildHamburg();
        builder.buildDrinks();
        builder.buildChickenwings();
        builder.buildSnaks();
        return builder.createCombo();
    }
}

/**
* 具体实现
*/
Director director = new Director();
HamburgCombo combo = director.create(new ComboA());
System.out.println(combo);

建造者模式优点

• 客户端不知道产品内部组成的细节，将产品本身与产品的创建过程解耦
• 每一个具体建造者都相对独立，而与其他的具体建造者无关，更加精细的控制产品的创建过程
• 增加新的具体建造者无需修改原有类库的代码，符合开闭原则
• 建造者模式组合链式编程使用，代码上更加美观

建造者模式缺点

建造者模式所创建的产品一般具有较多的相同点，如果产品差异大则不建议使用

建造者模式与抽象工厂的比较

建造者模式返回一个组装好的完整产品，抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。

小结

设计模式的创建型模式有单例设计模式，工厂模式，建造者模式，原型模式，到现在讲解了单例设计模式，工厂模式，建造者模式，由于原型模式不常用，就不写相关博客了，可以看看别人的博文，拓展拓展知识。