设计模式 - 建造者模式_在建造者模式中,为更加精细地控制产品的创建过程

什么是建造者模式

建造者模式也称生成器模式 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示（依赖倒转）

建造者模式的四个角色

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

建造者模式的注意事项和细节

1. 1)客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象

2. 2)每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，

用户使用不同的具体建造者即可得到不同的产品对象

3. 3)可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰， 也更方便使用程序来控制创建过程

4. 4)增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”

5. 5)建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

6. 6)如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式.

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

类图：

代码：

产品

/*
 * 套餐类
 */
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;  
    }  
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

抽象建造者

/*
 * 套餐构造器
 */
public abstract class MealBuilder {  
    protected Meal meal = new Meal();  

    public abstract void buildFood();  

    public abstract void buildDrink();  

    public Meal getMeal(){  
        return meal;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

具体建造者

/*
 * A套餐
 */
public class MealA ： MealBuilder{  

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

    public   override  void buildFood() {  
        meal.setFood("一盒薯条");  
    }  

}
/*
 * B套餐
 */
public class MealB ： MealBuilder{  

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

    public void buildFood() {  
        meal.setFood("三个鸡翅");  
    }  

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

指挥类

/*
 * 服务生
 */
public class KFCWaiter {  
    private MealBuilder mealBuilder;  

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

    public Meal construct(){  
        //准备食物  
        mealBuilder.buildFood();  
        //准备饮料  
        mealBuilder.buildDrink();  

        //准备完毕，返回一个完整的套餐给客户  
        return mealBuilder.getMeal();  
    }  
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

客户端

/*
 * 客户端
 */
public class App {  
    public static void main(String[] args) {  
        //服务员  
        KFCWaiter waiter = new KFCWaiter();  
        //套餐A  
        MealA a = new MealA();  
        //服务员准备套餐A  
        waiter.setMealBuilder(a);  
        //获得套餐  
        Meal mealA = waiter.construct();  

        //System.out.print("套餐A的组成部分:\r\n");  
        System.out.println(mealA.getFood()+"\r\n"+mealA.getDrink());  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

总结

1. 概念：
   建造者模式是一种创建型设计模式，它主要用于将一个复杂对象的构建过程与其表示分离。通过使用不同的构建者，可以创建具有不同属性和组成部分的对象，同时保持构建过程的一致性。

2. 结构：
   建造者模式包含以下几个主要组件：

Product（产品）： 被构建的复杂对象，包含多个部分。

Builder（抽象建造者）： 定义构建产品的接口，包括创建各个部分的方法。

ConcreteBuilder（具体建造者）： 实现抽象建造者接口，负责构建产品的各个部分，并提供方法获取最终产品。

Director（指挥者）： 负责指导构建过程的顺序和流程。它不直接构建产品，而是通过抽象建造者来构建。

3. 优缺点：
   建造者模式的优点在于：

分离构建过程： 将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。

更好的控制： 可以更精确地控制产品的构建过程，每个具体建造者负责自己的部分。

易于扩展： 可以增加新的具体建造者，无需修改现有代码，符合开闭原则。

重用性： 可以通过不同的具体建造者来构建相似的产品，提高代码的重用性。

建造者模式的缺点在于：

增加类的数量： 需要定义多个类，可能会增加系统的复杂性。
4. 多个维度解释：

多个表示： 建造者模式允许通过不同的具体建造者创建不同表示的产品。比如，在制作电脑时，可以有不同的建造者分别创建游戏电脑、办公电脑等。

多个步骤： 产品的构建可能涉及多个步骤，每个具体建造者负责其中的一部分。这使得构建过程更清晰、易于管理。

多个属性： 复杂对象通常具有多个属性，每个具体建造者可以逐步构建这些属性，确保对象在构建完成时是完整和一致的。

多个组装方式： 指挥者可以根据需要制定不同的构建顺序，从而创建不同组装方式的产品。

多个配置： 不同的具体建造者可以有不同的配置选项，如汽车的外观、内饰、引擎等。

5. 适用场景：

创建复杂对象，其构建过程需要多个步骤和多个部件的组合。
需要创建具有不同属性或组装方式的对象变体。
希望隔离产品的构建和表示，以便可以更灵活地组合和复用构建过程。
需要控制产品构建的流程和顺序，或者需要在构建过程中执行一些特定操作。
综上所述，建造者模式通过分离构建过程和表示，允许创建复杂对象的不同变体，从而提供了更好的灵活性、可控性和重用性。它适用于需要创建具有多个属性、步骤或变体的复杂对象的情况。