【设计模式】创建型模式（四）：建造者模式

创建型模式（四）：建造者模式

1.概念
2.案例
3.优化

1.概念

建造者模式 是一种创建型设计模式，它允许你创建复杂对象的步骤与表示方式相分离。

建造者模式是一种创建型设计模式，它的主要目的是将一个复杂对象的 构建过程 与其表示相分离，从而可以创建具有不同表示形式的对象。

概要	说明
意图	将一个复杂的构建过程与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决	在软件系统中，一个复杂对象的创建通常由多个部分组成，这些部分的组合经常变化，但组合的算法相对稳定。
何时使用	当一些基本部件不变，而其组合经常变化时。
如何解决	将变与不变的部分分离开。
关键代码	1️⃣ 建造者：创建并提供实例。 2️⃣ 导演：管理建造出来的实例的依赖关系和控制构建过程。
应用实例	1️⃣ 去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出不同的 “套餐”。 2️⃣ Java 中的 StringBuilder。
优点	1️⃣ 分离构建过程和表示，使得构建过程更加灵活，可以构建不同的表示。 2️⃣ 可以更好地控制构建过程，隐藏具体构建细节。 3️⃣ 代码复用性高，可以在不同的构建过程中重复使用相同的建造者。
缺点	1️⃣ 如果产品的属性较少，建造者模式可能会导致代码冗余。 2️⃣ 增加了系统的类和对象数量。
使用场景	1️⃣ 需要生成的对象具有复杂的内部结构。 2️⃣ 需要生成的对象内部属性相互依赖。
注意事项	与工厂模式的区别是：建造者模式更加关注于零件装配的顺序。

建造者模式包含以下几个主要角色：

指导者（Director）：负责调用建造者的方法来构建产品，指导者并不了解具体的构建过程，只关心产品的构建顺序和方式。
抽象建造者（Builder）：定义了构建产品的抽象接口，包括构建产品的各个部分的方法。
具体建造者（Concrete Builder）：实现抽象建造者接口，具体确定如何构建产品的各个部分，并负责返回最终构建的产品。
产品（Product）：要构建的复杂对象。产品类通常包含多个部分或属性。

在这里插入图片描述

2.案例

我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold Drink）。

汉堡（Burger）可以是 素食汉堡（Veg Burger）或 鸡肉汉堡（Chicken Burger），它们是包在纸盒中。
冷饮（Cold Drink）可以是 可口可乐（Coke）或 百事可乐（Pepsi），它们是装在瓶子中。

我们将创建一个表示 食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类，以及一个表示 食物包装 的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。

然后我们创建一个 Meal 类，带有 Item 的 ArrayList 和一个 通过结合 Item 来创建不同类型的 Meal 对象 的 MealBuilder。BuilderPatternDemo 类使用 MealBuilder 来创建一个 Meal。

在这里插入图片描述

1️⃣ Item.java、Packing.java：创建一个表示 食物条目 和 食物包装 的接口。

public interface Item {
   public String name();
   public Packing packing();
   public float price();    
}

public interface Packing {
   public String pack();
}

2️⃣ Wrapper.java、Bottle.java：创建实现 Packing 接口的实体类。

public class Wrapper implements Packing {
 
   @Override
   public String pack() {
      return "Wrapper";
   }
}

public class Bottle implements Packing {
 
   @Override
   public String pack() {
      return "Bottle";
   }
}

3️⃣ Burger.java、ColdDrink.java：创建实现 Item 接口的抽象类，该类提供了默认的功能。

public abstract class Burger implements Item {
 
   @Override
   public Packing packing() {
      return new Wrapper();
   }
 
   @Override
   public abstract float price();
}

public abstract class ColdDrink implements Item {
 
    @Override
    public Packing packing() {
       return new Bottle();
    }
 
    @Override
    public abstract float price();
}

4️⃣ VegBurger.java、ChickenBurger.java、Coke.java、Pepsi.java：创建扩展了 Burger 和 ColdDrink 的实体类。

public class VegBurger extends Burger {
 
   @Override
   public float price() {
      return 25.0f;
   }
 
   @Override
   public String name() {
      return "Veg Burger";
   }
}

public class ChickenBurger extends Burger {
 
   @Override
   public float price() {
      return 50.5f;
   }
 
   @Override
   public String name() {
      return "Chicken Burger";
   }
}

public class Coke extends ColdDrink {
 
   @Override
   public float price() {
      return 30.0f;
   }
 
   @Override
   public String name() {
      return "Coke";
   }
}

public class Pepsi extends ColdDrink {
 
   @Override
   public float price() {
      return 35.0f;
   }
 
   @Override
   public String name() {
      return "Pepsi";
   }
}

5️⃣ Meal.java：创建一个 Meal 类，带有上面定义的 Item 对象。

import java.util.ArrayList;
import java.util.List;
 
public class Meal {
   private List<Item> items = new ArrayList<Item>();    
 
   public void addItem(Item item){
      items.add(item);
   }
 
   public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
   }
 
   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : " + item.name());
         System.out.print(", Packing : " + item.packing().pack());
         System.out.println(", Price : " + item.price());
      }        
   }    
}

6️⃣ MealBuilder.java：创建一个 MealBuilder 类，实际的 Builder 类负责创建 Meal 对象。

public class MealBuilder {
 
   public Meal prepareVegMeal () {
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
 
   public Meal prepareNonVegMeal () {
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

7️⃣ BuilderPatternDemo.java：BuiderPatternDemo 使用 MealBuilder 来演示建造者模式（Builder Pattern）。

public class BuilderPatternDemo {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();
 
      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " + vegMeal.getCost());
 
      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " + nonVegMeal.getCost());
   }
}

8️⃣ 执行程序，输出结果。

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0

Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

3.优化

我们将第 2 节中的步骤 6️⃣ 和 7️⃣ 拆解一下，使之更清晰。

指导者

public class Director {    
    public void Constuct(Builder builder){        
        builder.prepareVegMeal();        
        builder.prepareNonVegMeal();    
    }
}

抽象建造者

public class Builder {    
    public Meal meal = new Meal();    
    public void prepareVegMeal() {};    
    public void prepareNonVegMeal() {};    
    public Meal getMeal() { return null };
};

具体建造者 1

public class VegMealBuilder extends Builder{
	@Override    
    public void prepareVegMeal() {        
        meal.addItem(new VegBurger());        
        meal.addItem(new Coke());
    }
    
    @Override    
    public void prepareNonVegMeal() { }    
    
    @Override
    public Meal getMeal() {        
        return meal;    
    }
}

具体建造者 2

public class NonVegMealBuilder extends Builder {    
    @Override    
    public void prepareVegMeal() { }    
    
    @Override    
    public void prepareNonVegMeal() {        
        meal.addItem(new ChickenBurger());        
        meal.addItem(new Pepsi());    
    }    
   
    @Override   
    public Meal getMeal() {        
        return meal;    
    }
}

Client

public class Test {    
    @Test    
    public void BuilderPatternDemo() {
    	// 创建指挥者        
        Director director = new Director();        
        
        // 创建建造者
        VegMealBuilder b1 = new VegMealBuilder();        
        NonVegMealBuilder b2 = new NonVegMealBuilder();        
        
        // 注入建造者，然后指挥者构建午餐
        director.Constuct(b1);        
        director.Constuct(b2);        
        
        // 获取构建好的 Meal 对象
        Meal vegMeal = b1.getMeal();        
        System.out.println("Veg Meal");        
        vegMeal.showItems();        
        System.out.println("Total Cost: " +vegMeal.getCost());        
        
        // 获取构建好的 Meal 对象
        Meal nonVegMeal = b2.getMeal();        
        System.out.println("\n\nNon-Veg Meal");        
        nonVegMeal.showItems();       
        System.out.println("Total Cost: " +nonVegMeal.getCost());    
    }
}