Java建造者案例

本文目录导读：

1. 经典建造者模式案例
2. 简化版（使用Lombok或静态工厂）
3. 链条式建造者（更灵活）
4. 建造者模式优点总结
5. 使用场景

我来为您展示一个完整的Java建造者模式案例，以订餐系统为例：

经典建造者模式案例

产品类（美食订单）

public class Meal {
    private String mainDish;      // 主菜
    private String sideDish;      // 配菜
    private String drink;         // 饮料
    private String dessert;       // 甜点
    private boolean hasToy;       // 是否包含玩具
    private String notes;         // 备注
    // 私有构造函数，只能通过建造者创建
    private Meal() {}
    public void setMainDish(String mainDish) {
        this.mainDish = mainDish;
    }
    // ... 其他setter方法
    @Override
    public String toString() {
        return "Meal{" +
                "mainDish='" + mainDish + '\'' +
                ", sideDish='" + sideDish + '\'' +
                ", drink='" + drink + '\'' +
                ", dessert='" + dessert + '\'' +
                ", hasToy=" + hasToy +
                ", notes='" + notes + '\'' +
                '}';
    }
}

抽象建造者接口

public interface MealBuilder {
    MealBuilder buildMainDish(String dish);
    MealBuilder buildSideDish(String side);
    MealBuilder buildDrink(String drink);
    MealBuilder buildDessert(String dessert);
    MealBuilder buildToy(boolean hasToy);
    MealBuilder buildNotes(String notes);
    Meal build();
}

具体建造者实现

public class StandardMealBuilder implements MealBuilder {
    private Meal meal;
    public StandardMealBuilder() {
        this.meal = new Meal();
    }
    @Override
    public MealBuilder buildMainDish(String dish) {
        meal.setMainDish(dish);
        return this;
    }
    @Override
    public MealBuilder buildSideDish(String side) {
        meal.setSideDish(side);
        return this;
    }
    @Override
    public MealBuilder buildDrink(String drink) {
        meal.setDrink(drink);
        return this;
    }
    @Override
    public MealBuilder buildDessert(String dessert) {
        meal.setDessert(dessert);
        return this;
    }
    @Override
    public MealBuilder buildToy(boolean hasToy) {
        meal.setHasToy(hasToy);
        return this;
    }
    @Override
    public MealBuilder buildNotes(String notes) {
        meal.setNotes(notes);
        return this;
    }
    @Override
    public Meal build() {
        return meal;
    }
}

导演类（可选，用于控制构建顺序）

public class MealDirector {
    private MealBuilder builder;
    public MealDirector(MealBuilder builder) {
        this.builder = builder;
    }
    // 儿童套餐
    public Meal constructKidsMeal() {
        return builder
                .buildMainDish("迷你汉堡")
                .buildSideDish("薯条")
                .buildDrink("橙汁")
                .buildDessert("冰淇淋")
                .buildToy(true)
                .buildNotes("不要洋葱")
                .build();
    }
    // 健康套餐
    public Meal constructHealthyMeal() {
        return builder
                .buildMainDish("鸡胸肉沙拉")
                .buildSideDish("蔬菜")
                .buildDrink("绿茶")
                .buildNotes("少盐")
                .build();
    }
}

客户端代码

public class BuilderPatternDemo {
    public static void main(String[] args) {
        System.out.println("=== 建造者模式示例 ===\n");
        // 方式1：直接使用建造者
        Meal meal = new StandardMealBuilder()
                .buildMainDish("牛肉汉堡")
                .buildSideDish("薯条")
                .buildDrink("可乐")
                .buildDessert("苹果派")
                .buildToy(true)
                .buildNotes("多放番茄酱")
                .build();
        System.out.println("自定义订单: " + meal);
        // 方式2：使用导演类
        MealBuilder builder = new StandardMealBuilder();
        MealDirector director = new MealDirector(builder);
        Meal kidsMeal = director.constructKidsMeal();
        System.out.println("\n儿童套餐: " + kidsMeal);
        Meal healthyMeal = director.constructHealthyMeal();
        System.out.println("\n健康套餐: " + healthyMeal);
    }
}

简化版（使用Lombok或静态工厂）

// Lombok @Builder 方式
import lombok.Builder;
import lombok.ToString;
@Builder
@ToString
public class Product {
    private String name;
    private String brand;
    private double price;
    private String category;
    private String manufacturer;
    private int stock;
}

链条式建造者（更灵活）

public class Computer {
    // 必需属性
    private final String cpu;
    private final String ram;
    // 可选属性
    private String gpu;
    private String storage;
    private String display;
    private String keyboard;
    private String mouse;
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.gpu = builder.gpu;
        this.storage = builder.storage;
        this.display = builder.display;
        this.keyboard = builder.keyboard;
        this.mouse = builder.mouse;
    }
    public static class Builder {
        // 必需参数
        private final String cpu;
        private final String ram;
        // 可选参数
        private String gpu;
        private String storage;
        private String display;
        private String keyboard;
        private String mouse;
        public Builder(String cpu, String ram) {  // 必需参数在构造函数中
            this.cpu = cpu;
            this.ram = ram;
        }
        public Builder gpu(String val) { gpu = val; return this; }
        public Builder storage(String val) { storage = val; return this; }
        public Builder display(String val) { display = val; return this; }
        public Builder keyboard(String val) { keyboard = val; return this; }
        public Builder mouse(String val) { mouse = val; return this; }
        public Computer build() {
            return new Computer(this);
        }
    }
    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", gpu='" + gpu + '\'' +
                ", storage='" + storage + '\'' +
                ", display='" + display + '\'' +
                ", keyboard='" + keyboard + '\'' +
                ", mouse='" + mouse + '\'' +
                '}';
    }
    public static void main(String[] args) {
        Computer computer = new Computer.Builder("i9-13900K", "32GB DDR5")
                .gpu("RTX 4090")
                .storage("2TB NVMe SSD")
                .display("27\" 4K")
                .keyboard("机械键盘")
                .build();
        System.out.println(computer);
    }
}

建造者模式优点总结

✔ 优点：

• 将复杂对象的构建过程分离
• 灵活性强，可以按需构建
• 代码可读性好，参数语义清晰
• 支持链式调用

❌ 缺点：

• 对于简单对象可能过度设计
• 需要额外创建Builder类

使用场景

1. 参数过多的对象：超过4-5个参数
2. 参数有可选性：不是所有参数都需要
3. 参数之间有依赖关系：构建顺序重要
4. 不可变对象：需要防止修改

这种模式在java.lang.StringBuilder、java.util.stream.Stream等JDK类中都有应用。