设计模式之四：建造者模式（Builder Pattern）详解

茶本无香2026-01-21 10:05
  1. 模式定义

建造者模式是一种创建型设计模式，它将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。该模式通过分步骤构建复杂对象，并允许用户通过相同的构建过程生成具有不同内部状态的对象。

  1. 适用场景

• 当需要创建的对象构造过程复杂，且包含多个步骤或组件时。

• 当对象的构造过程需要独立于对象本身的组成部分时。

• 当需要避免使用构造器参数过多（"伸缩构造器"问题）或避免使用多个重载构造器时。

• 当希望构造过程能够产生不同表现形式的对象（例如，不同配置的电脑、不同口味的披萨等）。

  1. 核心结构

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

  1. Product（产品类）：被构建的复杂对象。

  2. Builder（抽象建造者）：定义构建产品各个部件的抽象接口。

  3. ConcreteBuilder（具体建造者）：实现Builder接口，完成具体部件的构建和装配。

  4. Director（指挥者）：负责控制构建过程，通常包含一个构建方法，按特定顺序调用Builder的方法。

  5. Client（客户端）：通过Director和Builder创建产品对象。

  6. Java示例：构建一台自定义电脑

4.1 基础实现：静态内部类Builder（无Director）

4.1.1 产品类：Computer

public class Computer {

private String cpu;

private String ram;

private String storage;

private String gpu;

private String motherboard;

复制代码 
// 私有构造器，通过Builder构建
private Computer(ComputerBuilder builder) {
    this.cpu = builder.cpu;
    this.ram = builder.ram;
    this.storage = builder.storage;
    this.gpu = builder.gpu;
    this.motherboard = builder.motherboard;
}

// Getters
public String getCpu() { return cpu; }
public String getRam() { return ram; }
public String getStorage() { return storage; }
public String getGpu() { return gpu; }
public String getMotherboard() { return motherboard; }

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

// 静态内部类：Builder
public static class ComputerBuilder {
    private String cpu;
    private String ram;
    private String storage;
    private String gpu;
    private String motherboard;

    // 必需参数通过构造器传入
    public ComputerBuilder(String cpu, String ram) {
        this.cpu = cpu;
        this.ram = ram;
    }

    // 可选参数通过链式方法设置
    public ComputerBuilder setStorage(String storage) {
        this.storage = storage;
        return this;
    }

    public ComputerBuilder setGpu(String gpu) {
        this.gpu = gpu;
        return this;
    }

    public ComputerBuilder setMotherboard(String motherboard) {
        this.motherboard = motherboard;
        return this;
    }

    // 构建方法
    public Computer build() {
        return new Computer(this);
    }
}

}

4.1.2 客户端使用示例

public class Client {

public static void main(String[] args) {

// 构建一台高配电脑

Computer highEndPC = new Computer.ComputerBuilder("Intel i9", "32GB DDR5")

.setStorage("2TB NVMe SSD")

.setGpu("NVIDIA RTX 4090")

.setMotherboard("ASUS ROG Maximus")

.build();

复制代码 
    // 构建一台办公电脑
    Computer officePC = new Computer.ComputerBuilder("Intel i5", "16GB DDR4")
            .setStorage("512GB SSD")
            .setMotherboard("Gigabyte B660")
            .build();

    System.out.println("高配电脑：" + highEndPC);
    System.out.println("办公电脑：" + officePC);
}

}

4.2 输出结果

高配电脑：Computer{cpu='Intel i9', ram='32GB DDR5', storage='2TB NVMe SSD', gpu='NVIDIA RTX 4090', motherboard='ASUS ROG Maximus'}

办公电脑：Computer{cpu='Intel i5', ram='16GB DDR4', storage='512GB SSD', gpu='null', motherboard='Gigabyte B660'}

  1. 引入Director角色：标准化构建流程

5.1 抽象建造者接口

public interface ComputerBuilder {

void buildCpu();

void buildRam();

void buildStorage();

void buildGpu();

void buildMotherboard();

Computer getResult();

}

5.2 具体建造者：高配电脑

public class HighEndComputerBuilder implements ComputerBuilder {

private Computer computer;

复制代码 
public HighEndComputerBuilder() {
    this.computer = new Computer();
}

@Override
public void buildCpu() {
    computer.setCpu("Intel i9-13900K");
}

@Override
public void buildRam() {
    computer.setRam("64GB DDR5 6000MHz");
}

@Override
public void buildStorage() {
    computer.setStorage("2TB NVMe SSD + 4TB HDD");
}

@Override
public void buildGpu() {
    computer.setGpu("NVIDIA RTX 4090");
}

@Override
public void buildMotherboard() {
    computer.setMotherboard("ASUS ROG Maximus Z790");
}

@Override
public Computer getResult() {
    return computer;
}

}

5.3 具体建造者：办公电脑

public class OfficeComputerBuilder implements ComputerBuilder {

private Computer computer;

复制代码 
public OfficeComputerBuilder() {
    this.computer = new Computer();
}

@Override
public void buildCpu() {
    computer.setCpu("Intel i5-13400");
}

@Override
public void buildRam() {
    computer.setRam("16GB DDR4 3200MHz");
}

@Override
public void buildStorage() {
    computer.setStorage("512GB NVMe SSD");
}

@Override
public void buildGpu() {
    computer.setGpu("Integrated Graphics"); // 集成显卡
}

@Override
public void buildMotherboard() {
    computer.setMotherboard("MSI PRO B760");
}

@Override
public Computer getResult() {
    return computer;
}

}

5.4 产品类（支持默认构造器）

public class Computer {

private String cpu;

private String ram;

private String storage;

private String gpu;

private String motherboard;

复制代码 
// 公共构造器，供Builder使用
public Computer() {}

// Setters
public void setCpu(String cpu) { this.cpu = cpu; }
public void setRam(String ram) { this.ram = ram; }
public void setStorage(String storage) { this.storage = storage; }
public void setGpu(String gpu) { this.gpu = gpu; }
public void setMotherboard(String motherboard) { this.motherboard = motherboard; }

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

}

5.5 Director：电脑装配指挥者

public class ComputerDirector {

private ComputerBuilder builder;

复制代码 
public ComputerDirector(ComputerBuilder builder) {
    this.builder = builder;
}

public void constructComputer() {
    // 控制构建顺序：主板 → CPU → 内存 → 存储 → GPU
    builder.buildMotherboard();
    builder.buildCpu();
    builder.buildRam();
    builder.buildStorage();
    builder.buildGpu();
}

// 可选：提供快速构建方法
public Computer build() {
    constructComputer();
    return builder.getResult();
}

}

5.6 客户端使用Director

public class ClientWithDirector {

public static void main(String[] args) {

// 构建高配电脑

ComputerBuilder highEndBuilder = new HighEndComputerBuilder();

ComputerDirector highEndDirector = new ComputerDirector(highEndBuilder);

Computer highEndPC = highEndDirector.build();

复制代码 
    // 构建办公电脑
    ComputerBuilder officeBuilder = new OfficeComputerBuilder();
    ComputerDirector officeDirector = new ComputerDirector(officeBuilder);
    Computer officePC = officeDirector.build();

    System.out.println("高配电脑：" + highEndPC);
    System.out.println("办公电脑：" + officePC);
}

}

5.7 Director的作用

• 封装构建逻辑：将复杂的构建步骤和顺序隐藏在Director中。

• 确保构建一致性：所有通过Director构建的对象都遵循相同的流程。

• 提高复用性：同一Director可以搭配不同的Builder生成不同产品。

  1. 模式优点

• 封装性好：将复杂对象的构建过程封装在Builder中，客户端无需了解内部细节。

• 灵活性高：通过不同的具体建造者可以构建不同表现形式的对象。

• 代码可读性强：链式调用使代码更加清晰，避免了过长的构造器参数列表。

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

  1. 模式缺点

• 代码量增加：需要定义Builder类，对于简单对象可能显得繁琐。

• 构建过程依赖顺序：如果构建步骤有依赖关系，需要在Builder中维护顺序逻辑。

  1. 建造者模式 vs 工厂模式对比分析

8.1 核心区别对比表

特性 建造者模式 工厂模式（简单工厂/工厂方法/抽象工厂）

主要目的 分步骤构建复杂对象 创建对象实例（不关心构建细节）

构建过程 多步骤、有顺序 通常一步完成（隐藏构建细节）

参数控制 支持可选参数、链式调用 通常通过参数指定类型

产品复杂度 适合复杂对象（多个部件） 适合相对简单的对象

构建灵活性 高（可定制每个步骤） 中等（通过子类扩展）

代码结构 Product + Builder + Director Product + Factory

典型应用 配置对象、复杂实体 工具类、组件实例化

8.2 场景选择指南

选择建造者模式的情况：

• 对象构造需要多个步骤（如组装电脑、配置HTTP请求）。

• 需要灵活控制构建过程（可选参数、不同配置）。

• 希望避免构造器参数过多（伸缩构造器问题）。

• 需要构建过程可复用（同一过程生成不同产品）。

选择工厂模式的情况：

• 只需要创建对象实例，不关心内部构建细节。

• 对象结构相对简单，不需要分步骤构建。

• 需要通过类型参数快速创建特定子类对象。

• 需要隐藏具体类的实现细节（面向接口编程）。

8.3 代码示例对比

工厂模式示例（简单工厂）：

public class ComputerFactory {

public static Computer createComputer(String type) {

switch (type) {

case "highEnd":

return new Computer("Intel i9", "32GB", "2TB SSD", "RTX 4090", "ROG主板");

case "office":

return new Computer("Intel i5", "16GB", "512GB SSD", "集成显卡", "B660主板");

default:

throw new IllegalArgumentException("Unknown type: " + type);

}

}

}

// 使用方式

Computer pc = ComputerFactory.createComputer("highEnd");

建造者模式示例（如前文）：

Computer pc = new Computer.ComputerBuilder("Intel i9", "32GB")

.setStorage("2TB SSD")

.setGpu("RTX 4090")

.setMotherboard("ROG主板")

.build();

8.4 关键结论

• 工厂模式关注的是"创建什么"（What），隐藏创建细节。

• 建造者模式关注的是"如何创建"（How），显式控制构建过程。

• 两者可以结合使用：例如用工厂方法创建不同配置的Builder，再用Builder构建最终产品。

  1. 常见应用

• Java标准库：StringBuilder、StringBuffer是建造者模式的典型应用。

• GUI框架：如JavaFX或Android中的UI组件构建。

• 配置对象构建：如数据库连接配置、HTTP请求配置等。

总结

建造者模式通过分离复杂对象的构建与表示，提供了一种灵活、可维护的对象创建方式。在Java中，常通过静态内部类Builder实现，结合链式调用（Fluent Interface）提升代码可读性。当需要更严格的构建流程控制时，可以引入Director角色标准化构建过程。

与工厂模式相比，建造者模式在构建复杂、多步骤对象时更具优势，而工厂模式更适合简单对象的快速创建。在实际项目中，可以根据对象复杂度、构建灵活性和代码可维护性需求，选择合适的设计模式或组合使用多种模式。

相关推荐
毕设源码-赖学姐1 小时前
【开题答辩全过程】以 高校素拓分管理系统的设计与开发为例，包含答辩的问题和答案
java·eclipse
计算机学姐2 小时前
基于SpringBoot的社区互助系统
java·spring boot·后端·mysql·spring·信息可视化·推荐算法
lbb 小魔仙2 小时前
【Java】深入解析 Java 集合底层原理：HashMap 扩容与 TreeMap 红黑树实现
java·开发语言
June bug2 小时前
【配环境】安装配置Oracle JDK
java·数据库·oracle
Coder个人博客2 小时前
1233434235
java·开发语言
阿蒙Amon2 小时前
C#每日面试题-静态构造函数和普通构造函数区别
java·开发语言·c#
Java程序员威哥2 小时前
SpringBoot4.0+JDK25+GraalVM：云原生Java的性能革命与落地指南
java·开发语言·后端·python·云原生·c#
青小莫2 小时前
C++之模板
android·java·c++
阿杰 AJie2 小时前
MyBatis-Plus 的内置方法
java·数据库·mybatis
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)032025 Telegram 最新免费社工库机器人（LetsTG可[特殊字符]）搭建指南（含 Python 脚本）04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08Linux下V2Ray安装配置指南09Claude Code Skills 实用使用手册10BongoCat - 跨平台键盘猫动画工具