23种设计模式-创建型模式-建造者模式（又名生成器模式）

1. 描述

无论是在现实世界中还是在软件系统中，都存在一些复杂的对象，它们拥有多个组成部分，如汽车，它包括车轮、方向盘、发送机等各种部件。而对于大多数用户而言，无须知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完整的汽车，可以通过建造者模式对其进行设计与描述，建造者模式可以将组成部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节.
在这里插入图片描述

2. 优点

客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。
可以更加精细地控制产品的创建过程。
增加新的具体建造者无须修改原有类库的代码

3.UML图

在这里插入图片描述

4. 抽象工厂模式VS建造者模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

5. 主要包含的四个角色

Product（产品角色）：一个具体的产品对象。
Builder（抽象建造者）：创建一个Product对象的各个部件指定的抽象接口。
ConcreteBuilder（具体建造者）：实现抽象接口，构建和装配各个部件。
Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程（其实就是让对象的使用和对象的创建分离）。

6. 案例一：KFC套餐

建造者模式可以用于描述KFC如何创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客。
在这里插入图片描述

//Product（产品角色）
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;
    }
}

//Builder（抽象建造者）
public abstract class MealBuilder {
    Meal meal = new Meal();
    public abstract void buildFood();
    public abstract void buildDrink();
    public Meal getMeal(){
        return meal;
    }
}

//ConcreteBuilder（具体建造者），A套餐
public class MealA extends MealBuilder{
    public void buildDrink() {
        meal.setDrink("可乐");
    }
    public void buildFood() {
        meal.setFood("薯条");
    }
}

//ConcreteBuilder（具体建造者），B套餐
public class MealB extends MealBuilder{
    public void buildDrink() {
        meal.setDrink("柠檬果汁");
    }
    public void buildFood() {
        meal.setFood("鸡翅");
    }
}

//Director（指挥者）
public class KFCWaiter {
    private MealBuilder mealBuilder;
    public KFCWaiter(MealBuilder mealBuilder) {
        this.mealBuilder = mealBuilder;
    }
    public Meal construct(){
        //准备食物
        mealBuilder.buildFood();
        //准备饮料
        mealBuilder.buildDrink();
        //准备完毕，返回一个完整的套餐给客户
        return mealBuilder.getMeal();
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //套餐A
        MealA a = new MealA();
        //准备套餐A的服务员
        KFCWaiter waiter = new KFCWaiter(a);
        //获得套餐
        Meal mealA = waiter.construct();      
        System.out.print("套餐A的组成部分:");
        System.out.println("食物："+mealA.getFood()+"；   "+"饮品："+mealA.getDrink());
    }
}

输出结果：

套餐A的组成部分:食物：薯条；饮品：可乐

9. 案例二：做蛋糕

假如有一个蛋糕Cake对象，蛋糕这个对象有一个必选属性size，还有一些可选属性apple，banana，orange，mango等，必选属性代表用户必须要指定蛋糕的大小，可选属性代表这些蛋糕要加哪些材料。考虑到可选属性组合可能特别多并且可能可选属性间存在依赖性或则有先后顺序。采用建造者模式，但不考虑扩展，在这里用简化版的建造者模式。

public class Cake {
   private int size;
   private String apple;
   private String banana;
   private String orange;
   private String mango;
   //private,让外面无法直接创建
   private Cake(Builer builer) {
       this.size = builer.size;
       this.apple = builer.apple;
       .....
   }
   //专门用来与外界打交道
   public static class Builer {
       private int size;
       private String apple;
       private String banana;
       private String orange;
       private String mango;
       //返回参数改为Builer
       public Builer setSize(int size) {
           this.size = size;
           return this;
       }

       public Builer setApple(String apple) {
           this.apple = apple;
           return this;
       }
       //为了省点代码，其他的省略
       public Cake build() {
           //检查参数之间的依赖关系是否正确
           return new Cake(this);
       }
   }
}

//链式使用（是不是很收悉）：
Cake cake = new Cake.Builer()
           .setSize(30)
           .setApple("apple")
           .setOrange("orange")
           .build();

8.在JDK中的应用

java.lang.StringBuilder 中的建造者模式
StringBuilder 的继承实现关系如下所示：
在这里插入图片描述
Appendable 接口如下：

public interface Appendable {
    Appendable append(CharSequence csq) throws IOException;
    Appendable append(CharSequence csq, int start, int end) throws IOException;
    Appendable append(char c) throws IOException;
}

StringBuilder 中的 append 方法使用了建造者模式（可以理解为StringBuilder在未调用toString()方法获得结果之前都是一直在构建对象，如一直调用append 方法构建对象），不过装配方法只有一个，并不算复杂，append 方法返回的是 StringBuilder 自身。

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence {
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    // ...省略...
}

StringBuilder 的父类 AbstractStringBuilder 实现了 Appendable 接口

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    int count;

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    // ...省略...
}

我们可以看出，Appendable 为抽象建造者，定义了建造方法，StringBuilder 既充当指挥者角色，又充当产品角色，又充当具体建造者，建造方法的实现由 AbstractStringBuilder 完成，而 StringBuilder 继承了 AbstractStringBuilder。

参考博文：
https://blog.csdn.net/qq_22771739/article/details/86614309
https://blog.csdn.net/qq_22771739/article/details/86614187
https://blog.csdn.net/qq_34337272/article/details/80540059