设计模式-建造者模式

建造者模式（Builder Pattern）又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同的对象

• 建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。所以它也属于创建型模式
• 建造者模式意图将一个复杂的构建与其表示相分离，将变与不变分开
• 当想要创建基本组件不会变，但是组合方式经常变化的复杂对象，就可以使用建造者模式

建造者模式的4个角色：

1）Product（产品角色）：一个具体的产品对象

2）Builder（抽象建造者）：创建一个Product对象的各个部件指定的 接口 / 抽象类

3）ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件

4）Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。其作用有两个：① 隔离了客户与对象的生产过程 ② 负责控制产品对象的生产过程

来看看下面的示例吧：

具体产品

public class Meal {
    private String food;
    private String menu;
    private String plateStyle;

    public String getFood() {
        return food;
    }

    public void setFood(String food) {
        this.food = food;
    }

    public String getMenu() {
        return menu;
    }

    public void setMenu(String menu) {
        this.menu = menu;
    }

    public String getPlateStyle() {
        return plateStyle;
    }

    public void setPlateStyle(String plateStyle) {
        this.plateStyle = plateStyle;
    }

    @Override
    public String toString() {
        return "Meal{" +
                "food='" + food + '\'' +
                ", menu='" + menu + '\'' +
                ", plateStyle='" + plateStyle + '\'' +
                '}';
    }
}

抽象建造者

public abstract class MealBuilder {

    /**
     * 做的是吃的东西（具体产品），子类会继承
     */
    protected Meal meal = new Meal();

    /**
     * 准备食材
     */
    public abstract void prepareFood();

    /**
     * 烹饪食材
     */
    public abstract void cookFood();

    /**
     * 食物装盘
     */
    public abstract void plateFood();

    /**
     * 开做!!!（子类都会继承这个方法）
     * @return Meal
     */
    public Meal cook() {
        return meal;
    }
}

具体建造者

public class Noodle extends MealBuilder{
    @Override
    public void prepareFood() {
        this.meal.setFood("面条");
        System.out.println("准备好面条~");
    }

    @Override
    public void cookFood() {
        this.meal.setMenu("用开水煮面");
        System.out.println("待水煮开下入面条~");
    }

    @Override
    public void plateFood() {
        this.meal.setPlateStyle("装进面碗");
        System.out.println("用面碗装~");
    }
}

public class Rice extends MealBuilder {
    @Override
    public void prepareFood() {
        this.meal.setFood("米饭");
        System.out.println("准备好米饭~");
    }

    @Override
    public void cookFood() {
        this.meal.setMenu("放进电饭锅煮");
        System.out.println("放进电饭锅里煮~");
    }

    @Override
    public void plateFood() {
        this.meal.setPlateStyle("装进饭碗里");
        System.out.println("用饭碗装~");
    }
}

指挥者

public class MealDirector {
    MealBuilder builder = null;

	// 通过有参构造来注入具体建造者属性
    public MealDirector(MealBuilder builder) {
        this.builder = builder;
    }

	// 调用具体建造者的方法，最后返回产品给客户端
    public Meal cookMeal() {
        builder.prepareFood();
        builder.cookFood();
        builder.plateFood();
        return builder.cook();
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        // 做米饭咯~
        Rice rice = new Rice();
        // 通过 director来操作整个创造流程
        MealDirector director = new MealDirector(rice);
        // 开做~
        Meal meal1 = director.cookMeal();
        System.out.println("让我们看看究竟做了什么: " + "哇哦，竟然是" + meal1);

        System.out.println("----------------");
        System.out.println("开始第二道烹饪");
        System.out.println("----------------");

        // 做面条咯~
        Noodle noodle = new Noodle();
        // 通过 director来操作整个创造流程
        director = new MealDirector(noodle);
        // 开做~
        Meal meal2 = director.cookMeal();
        System.out.println("让我们看看究竟做了什么: " + "哇哦，竟然是" + meal2);
    }
}

结果

准备好米饭~
放进电饭锅里煮~
用饭碗装~
让我们看看究竟做了什么: 哇哦，竟然是Meal{food='米饭', menu='放进电饭锅煮', plateStyle='装进饭碗里'}
----------------
开始第二道烹饪
----------------
准备好面条~
待水煮开下入面条~
用面碗装~
让我们看看究竟做了什么: 哇哦，竟然是Meal{food='面条', menu='用开水煮面', plateStyle='装进面碗'}

UML类图