2025/9/19日 每日总结 设计模式实践：用建造者模式实现计算机组装

设计模式实践：用建造者模式实现计算机组装

在软件开发中，经常会遇到需要构建复杂对象的场景。这些对象由多个部件组成，且构建过程有固定的步骤，但具体部件的实现可能存在差异。这时，建造者模式就能派上用场——它将对象的构建与表示分离，让同样的构建过程可以创建不同的产品。本文就以计算机组装为例，分享建造者模式的实践过程。

一、模式理解：为什么选择建造者模式？

计算机组装场景有两个核心特点：

  1. 组成固定：无论笔记本还是台式机，都由CPU、内存、硬盘、主机四大核心部件组成；
  2. 实现差异：笔记本的硬件是便携优化版，台式机的硬件是性能优化版，部件具体实现不同。
    如果直接在代码中硬编码构建逻辑，会导致代码冗余、扩展性差（新增平板设备时需大量修改）。而建造者模式通过以下角色解决这个问题：

  • 产品（Product）：最终构建的复杂对象（本文中的Computer）；

  • 抽象建造者（Builder）：定义构建产品的抽象方法（组装各部件）；

  • 具体建造者（ConcreteBuilder）：实现抽象方法，构建具体产品（笔记本/台式机建造者）；

  • 指挥者（Director）：控制构建流程，按顺序调用建造者的方法（组装工厂）。
    这种结构让构建流程与部件实现解耦，新增产品类型时只需添加新的具体建造者，无需修改现有逻辑。

    二、代码实现：一步步构建计算机组装系统

    1. 产品类：Computer

    封装计算机的核心部件，提供getter/setter方法用于部件赋值和获取。

    public class Computer {
private String cpu;
private String memory;
private String hardDisk;
private String mainFrame;
// Getter和Setter方法
public String getCpu() { return cpu; }
public void setCpu(String cpu) { this.cpu = cpu; }
public String getMemory() { return memory; }
public void setMemory(String memory) { this.memory = memory; }
public String getHardDisk() { return hardDisk; }
public void setHardDisk(String hardDisk) { this.hardDisk = hardDisk; }
public String getMainFrame() { return mainFrame; }
public void setMainFrame(String mainFrame) { this.mainFrame = mainFrame; }
}

    2. 抽象建造者：Builder

    定义组装计算机的抽象方法，每个方法对应一个部件的构建，同时提供获取最终产品的方法。

    public abstract class Builder {
protected Computer computer = new Computer();
// 抽象构建方法：子类需实现具体部件
public abstract void buildCpu();
public abstract void buildMemory();
public abstract void buildHardDisk();
public abstract void buildMainFrame();
// 返回构建完成的计算机
public Computer getComputer() {
return computer;
}
}

    3. 具体建造者：笔记本/台式机建造者

    分别实现抽象建造者的方法，为不同类型的计算机配置对应的硬件部件。

    笔记本电脑建造者（LaptopBuilder）

    public class LaptopBuilder extends Builder {
@Override
public void buildCpu() {
computer.setCpu("Intel Core i7-1165G7 (笔记本专用)");
}
@Override
public void buildMemory() {
computer.setMemory("16GB DDR4 3200MHz (笔记本内存)");
}
@Override
public void buildHardDisk() {
computer.setHardDisk("1TB NVMe SSD (笔记本硬盘)");
}
@Override
public void buildMainFrame() {
computer.setMainFrame("轻薄型笔记本主机");
}
}

    台式机建造者（DesktopBuilder）

    public class DesktopBuilder extends Builder {
@Override
public void buildCpu() {
computer.setCpu("AMD Ryzen 7 5800X (台式机CPU)");
}
@Override
public void buildMemory() {
computer.setMemory("32GB DDR4 3600MHz (台式机内存)");
}
@Override
public void buildHardDisk() {
computer.setHardDisk("2TB SATA SSD + 4TB HDD (台式机硬盘)");
}
@Override
public void buildMainFrame() {
computer.setMainFrame("ATX中塔式主机箱");
}
}

    4. 指挥者：Factory

    控制组装流程，按固定顺序调用建造者的构建方法，避免客户端直接依赖构建细节。

    public class Factory {
private Builder computerBuilder;
// 设置具体建造者
public void setBuilder(Builder builder) {
this.computerBuilder = builder;
}
// 按顺序组装部件，返回成品
public Computer construct() {
computerBuilder.buildCpu();
computerBuilder.buildMemory();
computerBuilder.buildHardDisk();
computerBuilder.buildMainFrame();
return computerBuilder.getComputer();
}
}

    5. 客户端测试：模拟组装过程

    通过切换不同的建造者，实现笔记本和台式机的组装，并输出配置信息。

    public class Store {
public static void main(String[] args) {
Builder builder;
Factory factory = new Factory();
// 组装台式机
builder = new DesktopBuilder();
factory.setBuilder(builder);
Computer desktop = factory.construct();
System.out.println("台式机配置：");
System.out.println("CPU: " + desktop.getCpu());
System.out.println("内存: " + desktop.getMemory());
System.out.println("硬盘: " + desktop.getHardDisk());
System.out.println("主机: " + desktop.getMainFrame());
System.out.println("-------------------");
// 组装笔记本
builder = new LaptopBuilder();
factory.setBuilder(builder);
Computer laptop = factory.construct();
System.out.println("笔记本电脑配置：");
System.out.println("CPU: " + laptop.getCpu());
System.out.println("内存: " + laptop.getMemory());
System.out.println("硬盘: " + laptop.getHardDisk());
System.out.println("主机: " + laptop.getMainFrame());
}
}

    三、运行结果

    台式机配置：
CPU: AMD Ryzen 7 5800X (台式机CPU)
内存: 32GB DDR4 3600MHz (台式机内存)
硬盘: 2TB SATA SSD + 4TB HDD (台式机硬盘)
主机: ATX中塔式主机箱

笔记本电脑配置：
CPU: Intel Core i7-1165G7 (笔记本专用)
内存: 16GB DDR4 3200MHz (笔记本内存)
硬盘: 1TB NVMe SSD (笔记本硬盘)
主机: 轻薄型笔记本主机

## 四、类图设计

+----------------+
| Computer |
+----------------+

  • cpu: String

  • memory: String

  • hardDisk: String

  • mainFrame: String

  • getCpu(): String

  • setCpu(String): void

  • getMemory(): String

  • setMemory(String): void

  • getHardDisk(): String

  • setHardDisk(String): void

  • getMainFrame(): String

  • setMainFrame(String): void
    +----------------+
    ^
    |
    +----------------+
    | Builder |
    +----------------+

  • computer: Computer

  • buildCpu(): void

  • buildMemory(): void

  • buildHardDisk(): void

  • buildMainFrame(): void

  • getComputer(): Computer
    +----------------+
    ^
    |
    +----------------+ +----------------+
    | LaptopBuilder | | DesktopBuilder |
    +----------------+ +----------------+

  • buildCpu(): void + buildCpu(): void

  • buildMemory(): void + buildMemory(): void

  • buildHardDisk(): void + buildHardDisk(): void

  • buildMainFrame(): void + buildMainFrame(): void
    +----------------+ +----------------+
    ^ ^
    | |
    +----------------+
    | Factory |
    +----------------+

  • builder: Builder

  • setBuilder(Builder): void

  • construct(): Computer
    +----------------+

    
## 五、模式总结与应用场景

### 核心优势

  1. 解耦构建与表示：建造者负责部件实现，指挥者负责流程，客户端只需选择建造者；

  2. 扩展性强：新增产品（如平板、服务器）时，只需添加新的具体建造者，无需修改指挥者和产品类；

  3. 控制细节：可以精确控制复杂对象的构建步骤和部件配置。

适用场景

  • 产品由多个部件组成，构建过程有固定步骤；
  • 不同产品的部件实现不同，但构建流程一致；
  • 需隐藏复杂对象的构建细节，避免客户端直接操作部件。
    通过本次计算机组装的实践，我对建造者模式的核心思想有了更直观的理解。在实际开发中，类似的场景还有很多，比如文档生成（Word/PDF文档由标题、正文、图片等部件组成）、配置文件构建等，都可以用建造者模式来优化代码结构。
posted @ 2025-12-29 14:27  Moonbeamsc  阅读(3)  评论(0)    收藏  举报
返回顶端