【设计模式】建造者模式

1. 概述

建造者模式将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，从而更精确控制复杂对象的生产过程；

通过隔离复杂对象的构建与使用，也就是将产品的创建与产品本身分离开来，使得同样的构建过程可以创建不同的对象；

并且每个具体创建者都相互独立，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象；

但建造者模式的缺陷是要求创建的产品具有较多的共同点、组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式。

同时，如果产品的内部变化复杂，可能会导致需要定义很多具体建造者者类来实现这种变化，导致系统变得很庞大。

 
意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示；

主要解决：主要解决在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定；

何时使用：一些基本部件不会变，而其组合经常变化的时候；

如何解决：将变与不变分离开；

应用实例：Java中的 StringBuilder，lombok 的 @Builder 注解；

优点：1、建造者独立、易扩展；2、便于控制细节风险；

缺点：1、产品必须有共同点，范围有限制；2、如内部变化复杂，会有很多的建造类；

使用场景：1、需要生成的对象具有复杂的内部结构；2、需要生成的对象内部属性本身相互依赖；

注意事项：与工厂模式的区别是：建造者模式更关注于零件装配的顺序。

 

2. UML图

• 抽象建造者 Builder: 相当于建筑蓝图，声明了创建 Product 对象的各个部件指定的接口；
• 具体建造者 ConcreteBuilder: 实现 Builder 抽象接口，构建和装配各个部件，定义并明确它所创建的过程，并提供一个检索产品的接口；
• 指挥者 Director: 构建一个使用 Builder 接口的对象。主要有两个作用：一是隔离用户与对象的生产过程；二是负责控制产品对象的生产过程；
• 产品角色 Product: 被构造的复杂对象。ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

 

3. 代码与测试

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

套餐类

public class Meal {
    private String food;
    private String drink;

    public void setFood(String food) {
        this.food = food;
    }
    public String getFood() {
        return food;
    }
    public void setDrink(String drink) {
        this.drink = drink;
    }
    public String getDrink() {
        return drink;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

套餐构造器

public abstract class MealBuilder {

    public abstract void buildFood();

    public abstract void buildDrink();

    public abstract Meal getMeal();
}
1
2
3
4
5
6
7
8

套餐A、套餐B，这两个套餐都实现抽象套餐类（即套餐构造器，它定义了每个套餐共同的一些生产步骤）

public class MealA extends MealBuilder {
    Meal meal = new Meal();
    
    @Override
    public void buildFood() {
        meal.setFood("三个鸡腿");
    }
    @Override
    public void buildDrink() {
        meal.setDrink("一杯柠檬果汁");
    }
    @Override
    public Meal getMeal() {
        return meal;
    }
}

public class MealB extends MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildFood() {
        meal.setFood("一个薯条");
    }
    @Override
    public void buildDrink() {
        meal.setDrink("一杯咖啡");
    }
    @Override
    public Meal getMeal() {
        return meal;
    }
}
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
29
30
31
32
33

KFC服务员，它相当于一个指挥者，它决定了套餐的实现过程，然后给你一个完成的套餐。

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

客户类

public class Consumer {
    public static void main(String[] args) {
        // 服务员
        KFCWaiter waiter = new KFCWaiter();
        // 客户指定套餐A
        MealA mealA = new MealA();
        // 通知服务员准备套餐A
        waiter.setMealBuilder(mealA);
        // 获得套餐
        Meal meal = waiter.construct();

        System.out.println("套餐A的组成部分: " + meal.getFood() + " " + meal.getDrink());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试

 

4. 抽象工厂模式与建造者模式的区别

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

2. 在抽象工厂模式中使用 “工厂” 来描述构建者，而在建造者模式中使用 “车间” 来描述构建者。

   (1) 抽象工厂模式就好比一个一个的工厂，宝马车工厂生产宝马SUV和宝马VAN，奔驰车工厂生产奔驰车SUV和奔驰VAN，它是从一个更高层次去看对象的构建，具体到工厂内部还有很多的车间，如制造引擎的车间、装配引擎的车间，但这些都是隐藏在工厂内部的细节，对外不公布。也就是对领导者来说，他只要关心一个工厂到底是生产什么产品的，不用关心具体怎么生产；

   (2) 建造者模式就不同了，它是由车间组成，不同的城建完成不同的创建和装配任务，一个完整的汽车生产过程需要引擎制造车间、引擎装配车间的配合才能完成，它们配合的基础就是设计蓝图，而这个蓝图是掌握在车间主任(Director)手中的，它给建造车间什么蓝图就能生产什么产品，建造者模式更关心建造过程。虽然从外界看来一个车间还是生产车辆，但是这个车间的转型是非常快的，只要重新设计一个蓝图，即可生产不同的产品，这有赖于建造者模式的功劳；

3. 相对来说，抽象工厂模式比建造者模式的力度更大，它关注产品整体；而建造者模式关注构建过程，所以建造者模式可以很容易地构建出一个崭新的产品，只要指挥类 Director 能够提供具体的工艺流程。也正因为如此，两者的应用场景截然不同：如果希望屏蔽对象的创建过程，只提供一个封装良好的对象，则可以选择抽象工厂模式；而建造者模式可以用在构件的装配方面，如通过装配不同的组件或者相同组件的不同顺序可以生产出一个新的对象，它可以产生一个非常灵活的架构，方便地扩展和维护系统。

 

5. 应用实例

(1) Java 中的 StringBuilder 和 StringBuffer

可以对 StringBuilder 对象执行 append()、reverse() 等方法，最后执行 toString() 方法获取到 String 对象，并且由于执行的各方法顺序不同产生不同的 String 对象，这就是典型的建造者模式。

public class Demo {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("abc");
        stringBuilder.reverse();
        stringBuilder.append("def");
        String str = stringBuilder.toString();
        System.out.println(str);
    }
}
1
2
3
4
5
6
7
8
9
10

 
(2) Lombok 的 @Builder 注解

Lombok 中的 @Builder 注解，在一个 POJO 类上加上这个注解，就可以使用建造者模式来创建这个类的实例了。

实体类

package com.design.pattern;

import lombok.Builder;
import lombok.Data;

/**
 * @author albert.tan
 * @date 2022/11/20
 */
@Data
@Builder
public class Dinner {

    private String food;

    private String drink;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

测试

package com.design.pattern;


/**
 * @author albert.tan
 * @date 2022/11/20
 */
public class Demo {
    public static void main(String[] args) {
        Dinner dinner = Dinner.builder()
                .food("Hamburger")
                .drink("Orange Juice")
                .build();
        System.out.println(dinner);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 

 

参考文献

[1] https://blog.csdn.net/a745233700/article/details/83625236