设计模式系列：建造者模式

一.名称

二.问题（为了解决什么问题）

1. 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
2. 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
3. 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
4. 通俗示例：在很多游戏软件中，地图包括天空、地面、背景等组成部分，人物角色包括人体、服装、装备等组成部分，可以使用建造者模式对其进行设计，通过不同的具体建造者创建不同类型的地图或人物。

三.解决方案（主要体现在uml和核心代码上）

将一个复杂对象的构建（builder）与它的表示（对象本身）分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。建造者模式的核心在于如何一步一步的构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品。

在建造者模式结构图中包含如下几个角色：
● Builder（抽象建造者）：它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。

●ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。

●Product（产品角色）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。

● Director（指挥者）：指挥者又称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。Director该类主要有两个作用：一方面是它隔离了客户与创建过程，另一方面是它控制产品的创建过程，包括某个buildPartX方法是否被调用，以及多个buildPartX方法调用的先后次序等。在实际生活中也存在类似指挥者的角色，例如一个客户去购买计算机，计算机销售人员相当于指挥者，只要客户（Client）指定计算机的类型，计算机销售人员可以通知计算机组装人员（Builder）给客户组装计算机（产品）。可以建造者中可以引入钩子函数。

在建造者模式的定义中提到了复杂对象，那么什么是复杂对象？简单来说，复杂对象是指那些包含多个成员属性的对象，这些成员属性也称为部件或零件，如汽车包括方向盘、发动机、轮胎等部件，电子邮件包括发件人、收件人、主题、内容、附件等部件。

建造者：

public abstract class AbstractBuilder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product getProduct();
}

public class ConcreteBuilderA extends AbstractBuilder{
    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.setPartA("A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("B");
    }

    @Override
    public void buildPartC() {
        product.setPartA("C");
    }

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

产品

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }
}

导演类

public class Director {
    private AbstractBuilder builderA;

    public Director(AbstractBuilder builderA) {
        this.builderA = builderA;
    }

    public Product getProductA() {
        this.builderA.buildPartA();
        this.builderA.buildPartB();
        this.builderA.buildPartC();
        return this.builderA.getProduct();
    }

}

客户端

public class Client {
    public static void main(String[] args) {
        System.out.println("利用Director类获得不同组装方式的产品A");
        ConcreteBuilderA builderA = new ConcreteBuilderA();
        Director director = new Director(builderA);
        director.getProductA();
    }
}

和其他模式混用

  总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。
  与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。

四.例子

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

• 客户端：顾客，想去买一套套餐（这里面包括汉堡，可乐，薯条），可以有1号和2号两种套餐供顾客选择。
• 指导者角色：收银员。知道顾客想要买什么样的套餐，并告诉餐馆员工去准备套餐。
• 建造者角色：餐馆员工。按照收银员的要求去准备具体的套餐，分别放入汉堡，可乐，薯条等。
• 产品角色：最后的套餐，所有的东西放在同一个盘子里面。

产品类

/**
 * Created by annuoaichengzhang on 16/4/6.
 * 套餐类
 */
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;
    }
}

建造者

/**
 * Created by annuoaichengzhang on 16/4/6.
 * 套餐构造器
 */
public abstract class MealBuilder {
    Meal meal = new Meal();
    public abstract void buildFood();

    public abstract void buildDrink();

    public Meal getMeal() {
        return meal;
    }
}

/**
 * Created by annuoaichengzhang on 16/4/6.
 * 套餐A
 */
public class MealABuilder extends MealBuilder {
    @Override
    public void buildFood() {
        super.meal.setFood("一盒薯条");
    }

    @Override
    public void buildDrink() {
        super.meal.setDrink("一杯可乐");
    }
}

/**
 * Created by annuoaichengzhang on 16/4/6.
 */
public class MealBBuilder extends MealBuilder {
    @Override
    public void buildFood() {
        super.meal.setFood("三个鸡翅");
    }

    @Override
    public void buildDrink() {
        super.meal.setDrink("一杯柠檬汁");
    }
}

director

/**
 * Created by annuoaichengzhang on 16/4/6.
 */
public class KFCWaiter {
    private MealBuilder mealBuilder;

    public void setMealBuilder(MealBuilder mealBuilder) {
        this.mealBuilder = mealBuilder;
    }

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

client

/**
 * Created by annuoaichengzhang on 16/4/6.
 */
public class Client {
    public static void main(String[] args) {
        // 服务员
        KFCWaiter waiter = new KFCWaiter();
        // 套餐A
        MealABuilder a = new MealABuilder();
        // 服务员准备套餐A
        waiter.setMealBuilder(a);

        // 获得套餐
        Meal mealA = waiter.construct();

        System.out.println("套餐A的组成部分:");
        System.out.println(mealA.getFood() + "----" + mealA.getDrink());
    }
}

五.效果（有啥优缺点）

优点：
1. 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
2. 可以更加精细的控制产品的创建过程。

缺点：
1. 建造者模式所创建的产品一般具有较多的共同点，所以它的使用范围会因此受到限制。

常见案例

rpg游戏不同类型的游戏角色的创建。其性别、脸型、头发都不一样。

 

视频播放软件提供了完整模式、精简模式等。在不同的显示环境下，主界面的组成元素会有所差异。