Java设计模式：建造者模式详解与实践指南

原创

wx65dfdaaec020c 2025-07-14 08:56:43 博主文章分类：设计模式 ©著作权

©著作权归作者所有：来自51CTO博客作者wx65dfdaaec020c的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java设计模式：建造者模式详解与实践指南

摘要

建造者模式（Builder Pattern）是一种创建型设计模式，它将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。本文将全面解析建造者模式的核心概念、实现方式、变体模式以及实际应用场景，通过丰富的Java代码示例展示如何优雅地构建复杂对象，并分析其与工厂模式的区别与适用场景。

一、建造者模式概述

建造者模式旨在解决复杂对象创建过程中的灵活性问题，其主要特点包括：

分步构建：将复杂对象的构建过程分解为多个步骤
表示独立：相同的构建过程可以创建不同的产品表示
精细控制：对对象的创建过程有更精确的控制
代码可读性：提高客户端代码的可读性和可维护性

建造者模式适用于以下场景： • 需要创建的对象具有复杂的内部结构

• 对象的属性之间存在依赖关系或约束条件

• 需要创建的对象有多个变体

• 希望避免"重叠构造函数"问题（Telescoping Constructor）

二、传统对象创建方式的问题

重叠构造函数问题

// 重叠构造函数示例 public class NutritionFacts { private final int servingSize; // 必需 private final int servings; // 必需 private final int calories; // 可选 private final int fat; // 可选 private final int sodium; // 可选 private final int carbohydrate; // 可选

public NutritionFacts(int servingSize, int servings) {
    this(servingSize, servings, 0);
}

public NutritionFacts(int servingSize, int servings, int calories) {
    this(servingSize, servings, calories, 0);
}

public NutritionFacts(int servingSize, int servings, int calories, int fat) {
    this(servingSize, servings, calories, fat, 0);
}

public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
    this(servingSize, servings, calories, fat, sodium, 0);
}

public NutritionFacts(int servingSize, int servings, int calories, 
                     int fat, int sodium, int carbohydrate) {
    this.servingSize = servingSize;
    this.servings = servings;
    this.calories = calories;
    this.fat = fat;
    this.sodium = sodium;
    this.carbohydrate = carbohydrate;
}

}

JavaBean模式的缺陷

// JavaBean模式示例 public class NutritionFacts { private int servingSize = -1; // 必需; 无默认值 private int servings = -1; // 必需; 无默认值 private int calories = 0; private int fat = 0; private int sodium = 0; private int carbohydrate = 0;

public NutritionFacts() {}

// Setters
public void setServingSize(int val) { servingSize = val; }
public void setServings(int val) { servings = val; }
public void setCalories(int val) { calories = val; }
public void setFat(int val) { fat = val; }
public void setSodium(int val) { sodium = val; }
public void setCarbohydrate(int val) { carbohydrate = val; }

}

// 使用示例 - 对象可能处于不一致状态 NutritionFacts cocaCola = new NutritionFacts(); cocaCola.setServingSize(240); cocaCola.setServings(8); cocaCola.setCalories(100); cocaCola.setSodium(35); cocaCola.setCarbohydrate(27);

三、建造者模式的结构

核心角色组成

角色职责典型实现

Product 要构建的复杂对象包含多个部件的类

Builder 抽象构建器接口定义构建步骤的抽象方法

ConcreteBuilder 具体构建器实现构建步骤，提供获取产品的方法

Director 指挥者（可选）控制构建过程

UML类图示例

[Director] --> [Builder] [Builder] <|-- [ConcreteBuilder] [ConcreteBuilder] --> [Product]

四、建造者模式的实现方式

标准建造者模式实现

// 产品类 class Pizza { private String dough = ""; private String sauce = ""; private String topping = "";

public void setDough(String dough) { this.dough = dough; }
public void setSauce(String sauce) { this.sauce = sauce; }
public void setTopping(String topping) { this.topping = topping; }

public String toString() {
    return "Pizza with " + dough + " dough, " + sauce + " sauce and " 
           + topping + " topping. Enjoy!";
}

}

// 抽象建造者 abstract class PizzaBuilder { protected Pizza pizza;

public Pizza getPizza() { return pizza; }
public void createNewPizzaProduct() { pizza = new Pizza(); }

public abstract void buildDough();
public abstract void buildSauce();
public abstract void buildTopping();

}

// 具体建造者 - 意大利辣香肠披萨 class SpicyPizzaBuilder extends PizzaBuilder { public void buildDough() { pizza.setDough("pan baked"); } public void buildSauce() { pizza.setSauce("hot"); } public void buildTopping() { pizza.setTopping("pepperoni+salami"); } }

// 具体建造者 - 夏威夷披萨 class HawaiianPizzaBuilder extends PizzaBuilder { public void buildDough() { pizza.setDough("cross"); } public void buildSauce() { pizza.setSauce("mild"); } public void buildTopping() { pizza.setTopping("ham+pineapple"); } }

// 指挥者 class Waiter { private PizzaBuilder pizzaBuilder;

public void setPizzaBuilder(PizzaBuilder pb) { pizzaBuilder = pb; }
public Pizza getPizza() { return pizzaBuilder.getPizza(); }

public void constructPizza() {
    pizzaBuilder.createNewPizzaProduct();
    pizzaBuilder.buildDough();
    pizzaBuilder.buildSauce();
    pizzaBuilder.buildTopping();
}

}

// 客户端代码 public class PizzaBuilderDemo { public static void main(String[] args) { Waiter waiter = new Waiter(); PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder(); PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();

    waiter.setPizzaBuilder(hawaiianPizzaBuilder);
    waiter.constructPizza();
    Pizza pizza = waiter.getPizza();
    System.out.println(pizza);
    
    waiter.setPizzaBuilder(spicyPizzaBuilder);
    waiter.constructPizza();
    pizza = waiter.getPizza();
    System.out.println(pizza);
}

}

流式建造者模式（更现代的Java实现）

// 使用流式接口的建造者模式 public class NutritionFacts { private final int servingSize; private final int servings; private final int calories; private final int fat; private final int sodium; private final int carbohydrate;

public static class Builder {
    // 必需参数
    private final int servingSize;
    private final int servings;
    
    // 可选参数 - 初始化为默认值
    private int calories = 0;
    private int fat = 0;
    private int sodium = 0;
    private int carbohydrate = 0;
    
    public Builder(int servingSize, int servings) {
        this.servingSize = servingSize;
        this.servings = servings;
    }
    
    public Builder calories(int val) {
        calories = val;
        return this;
    }
    
    public Builder fat(int val) {
        fat = val;
        return this;
    }
    
    public Builder sodium(int val) {
        sodium = val;
        return this;
    }
    
    public Builder carbohydrate(int val) {
        carbohydrate = val;
        return this;
    }
    
    public NutritionFacts build() {
        return new NutritionFacts(this);
    }
}

private NutritionFacts(Builder builder) {
    servingSize = builder.servingSize;
    servings = builder.servings;
    calories = builder.calories;
    fat = builder.fat;
    sodium = builder.sodium;
    carbohydrate = builder.carbohydrate;
}

@Override
public String toString() {
    return "NutritionFacts [servingSize=" + servingSize + ", servings=" + servings
            + ", calories=" + calories + ", fat=" + fat + ", sodium=" + sodium
            + ", carbohydrate=" + carbohydrate + "]";
}

}

// 客户端使用 public class NutritionFactsDemo { public static void main(String[] args) { NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8) .calories(100) .sodium(35) .carbohydrate(27) .build();

    System.out.println(cocaCola);
}

}

五、建造者模式的应用场景

复杂对象构造：当对象有多个部件或属性，且构造过程复杂时
构造过程需要不同表示：当对象的构造过程需要支持不同的表示时
参数组合验证：当构造对象时需要验证参数之间的约束关系时
不可变对象：创建不可变对象时特别有用
DSL构建：用于构建领域特定语言(DSL)

实际应用案例

Java API中的StringBuilder：字符串构建器
文档转换器：如HTML到PDF的转换器构建
UI组件构建：复杂UI组件的分步构建
查询构建器：如SQL查询构建器
游戏角色创建：复杂游戏角色的属性组合 // SQL查询构建器示例 public class SqlQueryBuilder { private StringBuilder query = new StringBuilder();

public SqlQueryBuilder select(String columns) { query.append("SELECT ").append(columns); return this; }

public SqlQueryBuilder from(String table) { query.append(" FROM ").append(table); return this; }

public SqlQueryBuilder where(String condition) { query.append(" WHERE ").append(condition); return this; }

public SqlQueryBuilder orderBy(String column) { query.append(" ORDER BY ").append(column); return this; }

public String build() { return query.toString(); } }

// 使用示例 String query = new SqlQueryBuilder() .select("id, name, email") .from("users") .where("active = 1") .orderBy("name") .build();

六、建造者模式的优缺点

优点：

• 封装性好：将复杂对象的创建过程封装起来

• 灵活性高：可以分步构建对象，改变产品的内部表示

• 可读性强：客户端代码清晰易读，特别是流式接口

• 参数控制：可以精细控制对象的创建过程

• 不变性支持：便于创建不可变对象

缺点：

• 代码量增加：需要编写更多的代码

• 适用范围有限：仅适用于具有复杂构造过程的对象

• 性能开销：相比直接构造可能有轻微性能开销

• 学习曲线：对初学者可能不太直观

七、建造者模式的变体

泛型建造者

public abstract class GenericBuilder<T> { protected T object;

public GenericBuilder(Supplier<T> instantiator) {
    this.object = instantiator.get();
}

public T build() {
    return object;
}

protected <V> GenericBuilder<T> with(Consumer<T> setter, V value) {
    setter.accept(object);
    return this;
}

}

// 使用示例 class Person { private String name; private int age;

// getters and setters...

}

Person person = new GenericBuilder<>(Person::new) .with(p -> p.setName("John"), "John") .with(p -> p.setAge(30), 30) .build();

阶梯建造者（Step Builder）

// 阶梯建造者接口 public interface CarBuilder { static EngineStep newBuilder() { return new Steps(); }

interface EngineStep {
    TransmissionStep withEngine(String engine);
}

interface TransmissionStep {
    ColorStep withTransmission(String transmission);
}

interface ColorStep {
    BuildStep withColor(String color);
}

interface BuildStep {
    Car build();
}

// 实现类
class Steps implements EngineStep, TransmissionStep, ColorStep, BuildStep {
    private String engine;
    private String transmission;
    private String color;
    
    @Override
    public TransmissionStep withEngine(String engine) {
        this.engine = engine;
        return this;
    }
    
    @Override
    public ColorStep withTransmission(String transmission) {
        this.transmission = transmission;
        return this;
    }
    
    @Override
    public BuildStep withColor(String color) {
        this.color = color;
        return this;
    }
    
    @Override
    public Car build() {
        return new Car(engine, transmission, color);
    }
}

}

// 使用示例 Car car = CarBuilder.newBuilder() .withEngine("V8") .withTransmission("Automatic") .withColor("Red") .build();

八、模式对比：建造者 vs 工厂

对比维度建造者模式工厂模式

构建方式分步构建一步构建

产品复杂度复杂对象相对简单对象

灵活性高（可控制构建过程）一般

客户端参与客户端参与构建过程客户端不参与构建细节

适用场景对象有多个部件或复杂构造逻辑创建单一类型对象

代码复杂度较高较低

九、最佳实践与注意事项

参数验证：在build()方法中进行参数验证
不变性：考虑将产品类设计为不可变
方法链：使用流式接口提高可读性
默认值：为可选参数提供合理的默认值
文档说明：明确说明哪些参数是必需的

线程安全：建造者通常不是线程安全的，需要注意 // 包含参数验证的建造者 public class User { private final String username; // 必需 private final String email; // 必需 private final int age; // 可选

private User(Builder builder) { this.username = builder.username; this.email = builder.email; this.age = builder.age; }

public static class Builder { private String username; private String email; private int age = 18; // 默认值

 public Builder username(String username) {
     if (username == null || username.trim().isEmpty()) {
         throw new IllegalArgumentException("Username cannot be empty");
     }
     this.username = username;
     return this;
 }
 
 public Builder email(String email) {
     if (email == null || !email.contains("@")) {
         throw new IllegalArgumentException("Invalid email format");
     }
     this.email = email;
     return this;
 }
 
 public Builder age(int age) {
     if (age < 0) {
         throw new IllegalArgumentException("Age cannot be negative");
     }
     this.age = age;
     return this;
 }
 
 public User build() {
     if (username == null || email == null) {
         throw new IllegalStateException("Required fields are not set");
     }
     return new User(this);
 }

} }

十、高级应用与性能优化

缓存建造者

// 可重用的建造者 public class ReusableBuilder { private static class HeavyObject { private final String part1; private final String part2; // 更多字段...

    public HeavyObject(String part1, String part2) {
        this.part1 = part1;
        this.part2 = part2;
        // 模拟昂贵的初始化
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
}

private String cachedPart1;
private String cachedPart2;

public ReusableBuilder withPart1(String part1) {
    this.cachedPart1 = part1;
    return this;
}

public ReusableBuilder withPart2(String part2) {
    this.cachedPart2 = part2;
    return this;
}

public HeavyObject build() {
    return new HeavyObject(cachedPart1, cachedPart2);
}

public void reset() {
    cachedPart1 = null;
    cachedPart2 = null;
}

}

// 使用示例 ReusableBuilder builder = new ReusableBuilder();

// 第一次构建 HeavyObject obj1 = builder.withPart1("A").withPart2("B").build(); builder.reset();

// 第二次构建 HeavyObject obj2 = builder.withPart1("X").withPart2("Y").build();

并行建造者

// 线程安全的建造者 public class ThreadSafeBuilder { private final Object lock = new Object(); private String part1; private String part2;

public ThreadSafeBuilder withPart1(String part1) {
    synchronized (lock) {
        this.part1 = part1;
        return this;
    }
}

public ThreadSafeBuilder withPart2(String part2) {
    synchronized (lock) {
        this.part2 = part2;
        return this;
    }
}

public Product build() {
    synchronized (lock) {
        if (part1 == null || part2 == null) {
            throw new IllegalStateException("Parts not set");
        }
        return new Product(part1, part2);
    }
}

}

总结

建造者模式是处理复杂对象构造的强大工具，它通过将对象的构建过程分离出来，提供了更好的灵活性和可读性。在现代Java开发中，流式接口的建造者实现尤其受欢迎，它结合了方法链和建造者模式的优点，使得代码更加优雅。虽然建造者模式需要编写更多的代码，但对于复杂对象的构造，这种投入通常会带来更好的可维护性和更少的错误。理解何时使用建造者模式以及如何正确实现它，是编写高质量Java代码的重要技能之一。