建造者模式（Builder Pattern） - alvinlkk的个人空间

背景

在软件开发过程中，存在构造非常复杂的对象，对于用户或者客户端来说，如果要了解构造的细节，属性以及顺序是一件很头疼的事情，好比给你一堆零件，让你自己组装出一辆车。所以能不能客户端直接说我要一个xx的对象，然后系统返回一个构建好的对象。而建造者模式恰恰解决这个问题。

定义

建造者模式将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式构建复杂对象就像造汽车一样，是一个一个组件一个一个步骤创建出来的，它允许用户通过指定的对象类型和内容来创建他们，但是用户并不需要知道这个复杂对象是如何构建的，它只需要明白通过这样做我可以得到一个完整的复杂对象实例。

模式结构

产品类：

public class Product {

    public void doSomething() {
        System.out.println("product   ");
    }

}

抽象建造者：

public abstract class Builder {

    public abstract void builderPart1();

    public abstract void builderPart2();

    public abstract Product buildProduct();
}

具体建造者：

public class ConcreteBuilder extends Builder {

    private Product product = new Product();

    @Override
    public void builderPart1() {
        System.out.println("构件1");
    }

    @Override
    public void builderPart2() {
        System.out.println("构件2");
    }

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

指挥类：

public class Director {

    private Builder builder = new ConcreteBuilder();

    public Product getAProduct() {
        builder.builderPart1();
        builder.builderPart2();
        return builder.buildProduct();
    }

    public Product getBProduct() {
        builder.builderPart2();
        builder.builderPart1();
        return builder.buildProduct();
    }
}

模式实现

场景 ：KFC里面一般都有好几种可供客户选择的套餐，它可以根据客户所点的套餐，然后在后面做这些套餐，返回给客户的事一个完整的、美好的套餐。下面我们将会模拟这个过程，我们约定套餐主要包含汉堡、薯条、可乐、鸡腿等等组成部分，使用不同的组成部分就可以构建出不同的套餐。 产品类：

public class Meal {

    private String food;

    private String drink;

    public String getFood() {
        return food;
    }

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

    public String getDrink() {
        return drink;
    }

    public void setDrink(String drink) {
        this.drink = drink;
    }
}

抽象建造者：

public abstract class MealBuilder {
    Meal meal = new Meal();

    public abstract void buildFood();

    public abstract void buildDrink();

    public Meal getMeal() {
        return meal;
    }

}

具体建造者类：

public class MealABuilder extends MealBuilder {

    @Override
    public void buildFood() {
        meal.setFood("汉堡");
    }

    @Override
    public void buildDrink() {
        meal.setDrink("可乐");
    }
}
public class MealBBuilder extends MealBuilder {

    @Override
    public void buildFood() {
        meal.setFood("炸鸡");    }

    @Override
    public void buildDrink() {
        meal.setDrink("牛奶");
    }
}

指挥类：

public class MealWaiter {

    private MealBuilder mealBuilder;

    public MealWaiter(MealBuilder mealBuilder) {
        this.mealBuilder = mealBuilder;
    }

    public Meal buildMeal() {
        mealBuilder.buildFood();
        mealBuilder.buildDrink();
        return mealBuilder.getMeal();
    }
}

场景类：

public class Client {

    public static void main(String[] args) {
        MealWaiter mealWaiter = new MealWaiter(new MealABuilder());
        Meal meal = mealWaiter.buildMeal();
    }
}

模式优缺点

优点

• 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，使得我们能够更加精确的控制复杂对象的产生过程。
• 将产品的创建过程与产品本身分离开来，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
• 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

模式使用场景

• 相同的方法，不同的执行顺序，产生不同事件结时，可以采用建造者模式。
• 多个部件或者零件都可以装配到一个对象中，但是产生的运行结果又不相同，可以使用该模式。
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

应用