设计模式- 建造者模式(Builder Pattern)结构|原理|优缺点|场景|示例

​​​​​​​ 设计模式(分类) 设计模式(六大原则)

创建型(5种) 工厂方法 抽象工厂模式 单例模式 建造者模式 原型模式

结构型(7种) 适配器模式 装饰器模式 代理模式 ​​​​​​外观模式 桥接模式 组合模式 享元模式

行为型(11种) 策略模式 模板方法模式 观察者模式 迭代器模式 责任链模式 命令模式

备忘录模式 状态模式 访问者模式 中介者模式


建造者模式(Builder Pattern)是一种创建型设计模式,其主要目的是将复杂对象的构建过程与它的表示分离,使得相同的构建过程可以创建不同的表示。这种模式适用于创建包含多个可选部件、步骤复杂且可能需要逐步构建的复杂对象,它能将构建过程分解为多个独立的、可复用的步骤,使得对象的创建过程更加清晰、灵活且易于扩展。

模式结构

建造者模式通常包含以下角色:

  • 产品(Product):表示要构建的复杂对象,包含多个组成部件。
  • 抽象建造者(Abstract Builder):定义创建产品各个部件的接口,并声明一个方法返回最终的完整产品。
  • 具体建造者(Concrete Builders):实现抽象建造者的接口,提供创建产品各个部件的详细实现,并在最后返回一个完整的具体产品实例。
  • 导演者(Director):负责调用具体建造者的相关方法来一步步构建产品,它不涉及具体产品的部件创建细节,只负责按特定顺序安排建造过程。

工作原理

  • 客户端:创建一个具体建造者实例,并将其交给导演者。客户端不直接与产品交互,而是通过导演者指定构建过程。
  • 导演者:持有具体建造者实例,调用其方法按照预定的步骤构建产品。导演者不关心具体建造者的内部实现细节,只关注构建过程的顺序。
  • 具体建造者:实现抽象建造者接口,提供构建产品各个部件的方法。每个具体建造者对应一种产品的不同构建方式。
  • 产品:定义产品的组成部分和接口,供外界使用。具体建造者通过构建产品的各个部件来创建完整的产品实例。

优缺点

优点
  • 封装性:将复杂对象的构建过程封装在建造者内部,与对象的表示分离,使客户端无需了解对象的内部构造细节。
  • 灵活性:可以通过改变具体建造者来改变产品的内部结构,无需修改导演者和客户端代码,符合"开闭原则"。
  • 可扩展性:易于扩展以构建不同类型的复杂对象,只需增加新的具体建造者即可。
  • 可复用性:抽象建造者和具体建造者可以被多个导演者重用,构建过程可以独立于使用过程。
缺点
  • 代码复杂度增加:引入了多个类(抽象建造者、具体建造者、导演者),增加了系统的复杂性,对于简单的对象构建可能显得过度设计。
  • 产品结构固化:如果产品的内部结构需要频繁变动,可能需要不断修改建造者,维护成本较高。

适用场景

  • 对象构建过程复杂:当对象的创建涉及多个步骤,且这些步骤的顺序和组合可能有多种变化时,适合使用建造者模式。
  • 需要灵活改变产品内部结构:当需要构建的产品内部结构可变,或者存在多种不同结构的产品需要构建时,建造者模式可以提供灵活的构建方式。
  • 构建过程独立于使用过程:当构建过程与产品的使用过程分离,且构建过程需要独立封装时,建造者模式能够很好地满足需求。

代码示例(以Java为例)

java 复制代码
// 产品(复杂对象)
class Computer {
    private String cpu;
    private String ram;
    private String hdd;

    public Computer(String cpu, String ram, String hdd) {
        this.cpu = cpu;
        this.ram = ram;
        this.hdd = hdd;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", hdd='" + hdd + '\'' +
                '}';
    }
}

// 抽象建造者
interface ComputerBuilder {
    void buildCPU(String cpu);
    void buildRAM(String ram);
    void buildHDD(String hdd);
    Computer build();
}

// 具体建造者
class DesktopBuilder implements ComputerBuilder {
    private String cpu;
    private String ram;
    private String hdd;

    @Override
    public void buildCPU(String cpu) {
        this.cpu = cpu;
    }

    @Override
    public void buildRAM(String ram) {
        this.ram = ram;
    }

    @Override
    public void buildHDD(String hdd) {
        this.hdd = hdd;
    }

    @Override
    public Computer build() {
        return new Computer(cpu, ram, hdd);
    }
}

// 导演者
class Director {
    public Computer constructComputer(ComputerBuilder builder) {
        builder.buildCPU("Intel i7");
        builder.buildRAM("16GB DDR4");
        builder.buildHDD("1TB SSD");
        return builder.build();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Director director = new Director();
        ComputerBuilder desktopBuilder = new DesktopBuilder();
        Computer computer = director.constructComputer(desktopBuilder);
        System.out.println(computer); // 输出:Computer{cpu='Intel i7', ram='16GB DDR4', hdd='1TB SSD'}
    }
}

在这个Java示例中:

  • Computer类是复杂的产品对象,包含CPU、RAM和HDD三个部件。
  • ComputerBuilder接口定义了构建计算机各个部件的方法,以及返回完整计算机对象的方法。
  • DesktopBuilder类实现了ComputerBuilder接口,提供了构建计算机部件的具体实现。
  • Director类负责调用DesktopBuilder的构建方法,按照特定顺序构建计算机,并返回构建完成的计算机对象。
  • 客户端代码通过Director来构建计算机,无需关心具体的构建细节。如果需要构建不同类型的计算机(如笔记本电脑),只需创建新的具体建造者类并传递给Director即可。

代码示例(以Python为例)

python 复制代码
# 产品(复杂对象)
class Computer:
    def __init__(self, cpu, ram, hdd):
        self.cpu = cpu
        self.ram = ram
        self.hdd = hdd

    def __str__(self):
        return f"Computer(cpu={self.cpu}, ram={self.ram}, hdd={self.hdd})"

# 抽象建造者
class ComputerBuilder:
    def build_cpu(self, cpu):
        raise NotImplementedError("Subclasses must implement this method")

    def build_ram(self, ram):
        raise NotImplementedError("Subclasses must implement this method")

    def build_hdd(self, hdd):
        raise NotImplementedError("Subclasses must implement this method")

    def build(self):
        raise NotImplementedError("Subclasses must implement this method")

# 具体建造者
class DesktopBuilder(ComputerBuilder):
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.hdd = None

    def build_cpu(self, cpu):
        self.cpu = cpu

    def build_ram(self, ram):
        self.ram = ram

    def build_hdd(self, hdd):
        self.hdd = hdd

    def build(self):
        return Computer(self.cpu, self.ram, self.hdd)

# 导演者
class Director:
    def construct_computer(self, builder):
        builder.build_cpu("Intel i7")
        builder.build_ram("16GB DDR4")
        builder.build_hdd("1TB SSD")
        return builder.build()

# 客户端代码
def main():
    director = Director()
    builder = DesktopBuilder()
    computer = director.construct_computer(builder)
    print(computer)  # 输出:Computer(cpu=Intel i7, ram=16GB DDR4, hdd=1TB SSD)

if __name__ == "__main__":
    main()

在这个Python示例中:

  • Computer类是复杂的产品对象,包含CPU、RAM和HDD三个部件,并提供了__str__方法以便打印输出。
  • ComputerBuilder类作为抽象建造者,定义了构建计算机各个部件的方法(build_cpubuild_rambuild_hdd)以及返回完整计算机对象的build方法,这些方法在抽象类中均抛出NotImplementedError,要求子类必须实现。
  • DesktopBuilder类继承自ComputerBuilder,实现了具体构建计算机部件的方法,并在build方法中返回一个新建的Computer实例。
  • Director类负责调用DesktopBuilder的构建方法,按照特定顺序构建计算机,并返回构建完成的计算机对象。
  • 客户端代码通过Director来构建计算机,无需关心具体的构建细节。如果需要构建不同类型的计算机(如笔记本电脑),只需创建新的具体建造者类并传递给Director即可。
相关推荐
xyliiiiiL11 分钟前
一文总结常见项目排查
java·服务器·数据库
shaoing12 分钟前
MySQL 错误 报错:Table ‘performance_schema.session_variables’ Doesn’t Exist
java·开发语言·数据库
腥臭腐朽的日子熠熠生辉1 小时前
解决maven失效问题(现象:maven中只有jdk的工具包,没有springboot的包)
java·spring boot·maven
ejinxian1 小时前
Spring AI Alibaba 快速开发生成式 Java AI 应用
java·人工智能·spring
杉之1 小时前
SpringBlade 数据库字段的自动填充
java·笔记·学习·spring·tomcat
圈圈编码1 小时前
Spring Task 定时任务
java·前端·spring
俏布斯2 小时前
算法日常记录
java·算法·leetcode
27669582922 小时前
美团民宿 mtgsig 小程序 mtgsig1.2 分析
java·python·小程序·美团·mtgsig·mtgsig1.2·美团民宿
爱的叹息2 小时前
Java 连接 Redis 的驱动(Jedis、Lettuce、Redisson、Spring Data Redis)分类及对比
java·redis·spring
程序猿chen2 小时前
《JVM考古现场(十五):熵火燎原——从量子递归到热寂晶壁的代码涅槃》
java·jvm·git·后端·java-ee·区块链·量子计算