介绍
定义
建造者模式是一种创建型模式，它的定义如下
建造者模式(Builder Pattern) - 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。又可以称为生成器模式
适用场景
隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
多个部件都可以装配到一个对象中，但产生的运行结果不相同
产品类非常复杂或者产品类因为调用顺序不同而产生不同作用
初始化一个对象时，参数过多，或者很多参数具有默认值
Builder模式不适合创建差异性很大的产品类。产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本
需要生成的产品对象有复杂的内部结构，这些产品对象具备共性
建造者模式角色及类图
建造者模式角色以及职责
- 产品类(Product)：具体产品
- 抽象建造者(Builder)：为创建一个Product产品对象的各个部件指定的抽象接口
- 具体建造者(ConcreteBuilder)：具体建造者、实现Builder接口，构建和装配各个部件
- 指挥者(Director)：构建一个使用Builder接口的对象
UML类图
工厂模式和建造者模式的区别
构建者模式和工厂模式很类似，区别在于构建者模式是一种个性化产品的创建，通过组装零配件而创建一个新产品。而工厂模式是一种标准化的产品创建，不关心产品的构建过程，只关心什么产品是由什么工厂产生的
实例
简单实例
以一个点餐的过程为例，我们去到快餐店，每个人都可以根据自己的喜好自由搭配食物和饮料，最后生成的订单也不尽相同，如下
产品类
public class Meal {
private List<String> foods;
private List<String> drinks;
public Meal() {
this.foods = new ArrayList<>();
this.drinks = new ArrayList<>();
}
public List<String> getFoods() {
return foods;
}
public void setFoods(List<String> foods) {
this.foods = foods;
}
public List<String> getDrinks() {
return drinks;
}
public void setDrinks(List<String> drinks) {
this.drinks = drinks;
}
@Override
public String toString() {
return "Meal{" + "foods=" + foods + ", drinks=" + drinks + '}';
}
}
具体建造类
public class MealBuilder {
private Meal meal;
public MealBuilder() {
meal = new Meal();
}
public MealBuilder addFood(String foodName) {
meal.getFoods().add(foodName);
return this;
}
public MealBuilder addDrink(String drinkName) {
meal.getDrinks().add(drinkName);
return this;
}
public Meal build() {
return meal;
}
}
指挥者/测试
public class MealDirector {
@Test
public void test(){
MealBuilder mealBuilder = new MealBuilder();
// 组装一个产品
Meal meal = mealBuilder.addFood("汉堡").addFood("鸡肉卷").addDrink("可乐").build();
System.out.println(meal);
}
}
测试
Meal{foods=[汉堡, 鸡肉卷], drinks=[可乐]}
模板方法模式扩展
上面的例子，在构建实例的时候要我们按照需求动态的组装零配件，例如用餐的搭配组合。另外，我们也可以使用模板方法模式对建造者模式进行扩展，把零配件的组装屏蔽封装，例如我们在点餐的时候会有一些套餐，这些套餐就是模板，已经帮我们搭配好零配件
抽象建造者
public abstract class AbstractMealBuilder {
protected Meal meal;
public AbstractMealBuilder() {
meal = new Meal();
}
public abstract void buildFood();
public abstract void buildDrink();
public Meal build() {
return meal;
}
}
具体建造者：A套餐
public class ConcreteMealBuilderA extends AbstractMealBuilder{
@Override
public void buildFood() {
meal.getFoods().add("辣鸡堡");
meal.getFoods().add("鸡肉卷");
}
@Override
public void buildDrink() {
meal.getDrinks().add("可乐");
}
}
具体建造者：B套餐
public class ConcreteMealBuilderB extends AbstractMealBuilder{
@Override
public void buildFood() {
meal.getFoods().add("牛肉堡");
meal.getFoods().add("薯条");
}
@Override
public void buildDrink() {
meal.getDrinks().add("橙汁");
}
}
指挥者
public class Director {
private AbstractMealBuilder mealBuilder;
public Director(AbstractMealBuilder mealBuilder) {
this.mealBuilder = mealBuilder;
}
public Meal construct() {
mealBuilder.buildFood();
mealBuilder.buildDrink();
return mealBuilder.build();
}
}
测试
public class DirectorDemo {
@Test
public void test() {
AbstractMealBuilder mealBuilderA = new ConcreteMealBuilderA();
Director directorA = new Director(mealBuilderA);
System.out.println("A套餐：" + directorA.construct());
AbstractMealBuilder mealBuilderB = new ConcreteMealBuilderB();
Director directorB = new Director(mealBuilderB);
System.out.println("B套餐：" + directorB.construct());
}
}
测试结果
A套餐：Meal{foods=[辣鸡堡, 鸡肉卷], drinks=[可乐]}
B套餐：Meal{foods=[牛肉堡, 薯条], drinks=[橙汁]}
