首页
/ 正文

建造者模式（一文讲透）

更新时间: 2025-03-31 23:29:48

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;

《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前，星球内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习，欢迎点击围观

在软件开发中，对象的创建过程往往伴随着复杂性。当一个对象需要多个参数或步骤才能完成初始化时，代码可能会变得臃肿且难以维护。例如，想象一个订单系统，用户需要同时设置商品列表、支付方式、配送地址和优惠券信息，这样的场景下直接通过构造函数传递参数显然不够优雅。此时，建造者模式便能派上用场。它通过分步骤构建复杂对象，将对象的构造过程与表示分离，帮助开发者以更清晰、可扩展的方式管理对象创建的逻辑。

本文将从基础概念出发，结合实际案例和代码示例，逐步解析建造者模式的核心思想、应用场景以及实现方法，帮助读者理解其设计哲学，并掌握如何在实际项目中应用这一模式。

什么是建造者模式？

建造者模式（Builder Pattern）是一种创建型设计模式，其核心思想是将一个复杂对象的构建过程与其表示分离。通过将对象的构造步骤分解为多个独立的阶段，建造者模式允许用户以灵活的方式组合不同组件，最终生成完整的对象。

形象比喻：可以将建造者模式想象为“乐高积木的组装过程”。每一块积木（组件）需要按特定顺序拼接，但用户无需关心具体的组装细节，只需通过简单的指令（如“添加车轮”“安装引擎”）即可完成构建。

核心角色与职责

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

Builder（抽象建造者）：定义产品各个组件的构建方法，但不指定具体的实现。
ConcreteBuilder（具体建造者）：实现抽象建造者的接口，负责具体组件的构建与组合。
Director（指挥者）：负责协调建造者按照特定顺序执行构建步骤，但不直接操作产品。
Product（产品）：最终生成的复杂对象，包含多个组件。

表格对比角色关系：
| 角色 | 职责描述 |
|---------------|--------------------------------------------------------------------------|
| Builder | 定义构建产品的抽象方法，如 build_part() 和 get_product()。 |
| ConcreteBuilder | 实现 Builder 接口，具体实现每个构建步骤。 |
| Director | 调用 Builder 的方法，按固定顺序执行构建流程。 |
| Product | 最终生成的复杂对象，由各个组件组合而成。 |

建造者模式的适用场景

建造者模式并非万能，但它在以下场景中能显著提升代码的可维护性和可扩展性：

对象构造步骤复杂：当一个对象需要多个参数或步骤才能初始化时，直接通过构造函数传递参数会导致代码冗长。
对象包含可选组件：例如，创建一个订单时，用户可能选择是否添加优惠券或备注信息。
需要逐步构建对象：例如，生成一个复杂的配置文件或报表，需分步骤添加不同部分。
希望隔离构建逻辑与业务逻辑：避免在业务代码中直接暴露对象的构建细节，提高代码解耦性。

对比其他模式：建造者 vs 工厂模式

有人可能会将建造者模式与工厂模式混淆。两者的核心区别在于：

工厂模式：关注“创建单一对象的实例”，例如通过工厂方法返回一个已完整构建的对象。
建造者模式：关注“分步骤构建复杂对象”，强调将构建过程与产品本身分离。

例如，工厂模式可能直接返回一个 Car 对象，而建造者模式则通过 CarBuilder 逐步添加引擎、轮胎等组件，最后生成完整的 Car 对象。

建造者模式的实现步骤

以下是实现建造者模式的典型流程：

步骤 1：定义抽象建造者（Builder）

抽象建造者声明所有构建方法的接口，但不提供具体实现。例如：

public abstract class CarBuilder {  
    protected Car car;  

    public abstract void buildEngine();  
    public abstract void buildWheels();  
    public abstract void buildBody();  

    public Car getResult() {  
        return car;  
    }  
}

步骤 2：实现具体建造者（ConcreteBuilder）

具体建造者继承抽象建造者，并实现各个构建方法。例如：

public class SportsCarBuilder extends CarBuilder {  
    public SportsCarBuilder() {  
        car = new Car();  
    }  

    @Override  
    public void buildEngine() {  
        car.setEngine("V8 High-Performance Engine");  
    }  

    @Override  
    public void buildWheels() {  
        car.setWheels("Alloy Wheels");  
    }  

    @Override  
    public void buildBody() {  
        car.setBody("Aerodynamic Carbon Fiber Body");  
    }  
}

步骤 3：定义指挥者（Director）

指挥者负责协调建造者的构建步骤，通常包含一个 build() 方法：

public class Director {  
    private CarBuilder builder;  

    public Director(CarBuilder builder) {  
        this.builder = builder;  
    }  

    public Car construct() {  
        builder.buildEngine();  
        builder.buildWheels();  
        builder.buildBody();  
        return builder.getResult();  
    }  
}

步骤 4：使用模式

客户端代码通过指挥者调用构建流程，无需直接操作具体建造者：

public class Client {  
    public static void main(String[] args) {  
        CarBuilder builder = new SportsCarBuilder();  
        Director director = new Director(builder);  
        Car car = director.construct();  
        System.out.println(car);  
    }  
}

建造者模式的扩展与优化

1. 支持可选组件

在实际开发中，某些组件可能是可选的。例如，在构建订单时，优惠券和备注信息可能不总是需要。此时，可以在具体建造者中提供可选方法：

public abstract class OrderBuilder {  
    protected Order order;  

    public abstract void setItems(); // 必要组件  
    public void setCoupon() { /* 默认不设置 */ } // 可选组件  
    public void setNote() { /* 默认不设置 */ } // 可选组件  

    // ... 其他方法  
}

2. 参数化建造者

当需要根据输入参数动态调整构建步骤时，可以引入参数化建造者：

public class ConfigurableCarBuilder extends CarBuilder {  
    private String engineType;  

    public ConfigurableCarBuilder(String engineType) {  
        this.engineType = engineType;  
    }  

    @Override  
    public void buildEngine() {  
        car.setEngine(engineType); // 根据参数设置引擎类型  
    }  
}

3. 链式调用（Fluent Builder）

通过返回 this 实现链式调用，使代码更简洁直观：

public class FluentOrderBuilder {  
    private Order order = new Order();  

    public FluentOrderBuilder addItem(String item) {  
        order.getItems().add(item);  
        return this;  
    }  

    public FluentOrderBuilder setCoupon(String couponCode) {  
        order.setCoupon(couponCode);  
        return this;  
    }  

    public Order build() {  
        return order;  
    }  
}

实战案例：订单系统中的建造者模式

场景描述

假设我们需要构建一个订单系统，订单包含以下字段：

商品列表（必需）
支付方式（可选，默认为“支付宝”）
配送地址（必需）
优惠券代码（可选）
备注信息（可选）

实现代码

1. 定义订单类（Product）

public class Order {  
    private List<String> items;  
    private String paymentMethod = "Alipay"; // 默认支付方式  
    private String deliveryAddress;  
    private String couponCode;  
    private String note;  

    // 构造函数、getter/setter 省略  
}

2. 抽象建造者（Builder）

public abstract class OrderBuilder {  
    protected Order order;  

    public abstract void setItems(); // 必要组件  
    public void setPaymentMethod(String method) {  
        order.setPaymentMethod(method);  
    }  
    public void setDeliveryAddress(String address) {  
        order.setDeliveryAddress(address);  
    }  
    public void setCouponCode(String code) {  
        order setCouponCode(code);  
    }  
    public void setNote(String note) {  
        order.setNote(note);  
    }  

    public abstract Order getResult();  
}

3. 具体建造者（ConcreteBuilder）

public class DefaultOrderBuilder extends OrderBuilder {  
    public DefaultOrderBuilder() {  
        order = new Order();  
    }  

    @Override  
    public void setItems() {  
        // 示例：添加默认商品  
        order.getItems().add("T-shirt");  
        order.getItems().add("Jeans");  
    }  

    @Override  
    public Order getResult() {  
        return order;  
    }  
}

4. 客户端使用

public class Client {  
    public static void main(String[] args) {  
        OrderBuilder builder = new DefaultOrderBuilder();  
        // 可选：覆盖默认值  
        builder.setDeliveryAddress("123 Main St");  
        builder.setCouponCode("SUMMER20");  

        Order order = builder.getResult();  
        System.out.println(order);  
    }  
}

建造者模式的优缺点分析

优点

解耦构建与表示：将对象的构造逻辑与业务逻辑分离，提高代码的可维护性。
灵活控制构建步骤：通过指挥者协调构建顺序，支持不同构建流程的复用。
支持可选组件：允许用户选择性地添加或忽略某些组件，提升灵活性。

缺点

增加类数量：引入了多个角色（Builder、Director 等），可能导致代码复杂度上升。
过度设计风险：对于简单对象，使用建造者模式可能“小题大做”，反而降低可读性。

总结

建造者模式是一种强大的工具，尤其适用于需要分步骤构建复杂对象的场景。它通过将构建逻辑封装在独立的类中，帮助开发者以清晰、模块化的方式管理对象的创建过程。无论是订单系统、配置管理，还是复杂的数据结构生成，建造者模式都能提供优雅的解决方案。

掌握建造者模式的关键在于理解其核心思想：将“如何构建”与“最终结果”分离。通过合理设计各个角色的职责，并结合具体场景选择合适的实现方式（如链式调用或参数化建造者），开发者可以显著提升代码的可扩展性和可维护性。

希望本文能帮助读者在实际项目中灵活运用这一模式，让复杂对象的构建变得简单而优雅。

建造者模式（一文讲透）

什么是建造者模式？

核心角色与职责

建造者模式的适用场景

对比其他模式：建造者 vs 工厂模式

建造者模式的实现步骤

步骤 1：定义抽象建造者（Builder）

步骤 2：实现具体建造者（ConcreteBuilder）

步骤 3：定义指挥者（Director）

步骤 4：使用模式

建造者模式的扩展与优化

1. 支持可选组件

2. 参数化建造者

3. 链式调用（Fluent Builder）

实战案例：订单系统中的建造者模式

场景描述

实现代码

1. 定义订单类（Product）

2. 抽象建造者（Builder）

3. 具体建造者（ConcreteBuilder）

4. 客户端使用

建造者模式的优缺点分析

优点

缺点

总结

最新发布

正则表达式 – 示例（保姆级教程）

MySQL 临时表（手把手讲解）

MySQL 复制表（超详细）

MySQL 序列使用（AUTO_INCREMENT）（建议收藏）

MySQL 处理重复数据（建议收藏）

MySQL 及 SQL 注入（长文解析）

jQuery Validate（建议收藏）

jQuery Accordion（一文讲透）

jQuery Autocomplete（手把手讲解）

MySQL 导出数据（一文讲透）