建造者模式在 Java 中的深度解析與實戰應用

模式定義

將一個複雜物件的建構與其表示分離，使相同的建構過程可創建不同的表示。

適用場景

• 物件包含多個組成部分，且組裝順序/方式影響最終結果。
• 演算法應與組成部分及其組裝方式解耦。
• 需創建不同表示的複雜物件（如不同配置的電腦、報表、SQL 查詢）。

角色結構

1. Product（產品）：複雜物件，含多個部件。
2. Builder（抽象建造者）：定義建構步驟介面（buildPartX()、getResult()）。
3. ConcreteBuilder（具體建造者）：實現步驟，維護產品實例。
4. Director（指揮者）：封裝建構順序，調用 Builder 步驟組裝產品。

實戰範例：組裝電腦

1. 產品與抽象建造者（結合模板方法給預設組裝）

abstract class Computer {
    protected abstract void installCpu();
    protected abstract void installRam();
    protected abstract void installStorage();
    
    // 模板方法：預設組裝順序
    public final Computer defaultBuild() {
        installCpu(); installRam(); installStorage();
        return this;
    }
}

abstract class ComputerBuilder {
    public abstract void buildPart();
    public abstract Computer getComputer();
}

2. 具體產品

class OfficePC extends Computer {
    protected void installCpu() { System.out.println("裝入 i5-13400"); }
    protected void installRam() { System.out.println("裝入 16GB DDR4"); }
    protected void installStorage() { System.out.println("裝入 512GB SSD"); }
}

class GamingPC extends Computer {
    protected void installCpu() { System.out.println("裝入 i9-13900K"); }
    protected void installRam() { System.out.println("裝入 32GB DDR5"); }
    protected void installStorage() { System.out.println("裝入 2TB NVMe"); }
}

3. 具體建造者（自訂組裝順序/省略部件）

class OfficePCBuilder extends ComputerBuilder {
    private OfficePC pc = new OfficePC();
    public void buildPart() {
        pc.installStorage(); // 先裝硬碟
        pc.installCpu();     // 再裝 CPU
        pc.installRam();     // 最後裝記憶體
    }
    public Computer getComputer() { return pc; }
}

class GamingPCBuilder extends ComputerBuilder {
    private GamingPC pc = new GamingPC();
    public void buildPart() {
        pc.installRam();     // 客戶不要 SSD，省略 installStorage()
        pc.installCpu();
    }
    public Computer getComputer() { return pc; }
}

4. 指揮者

class Director {
    private ComputerBuilder builder;
    public Director(ComputerBuilder b) { builder = b; }
    public Computer construct() {
        builder.buildPart();
        return builder.getComputer();
    }
}

5. 客戶端使用

public class Client {
    public static void main(String[] args) {
        // 1. 使用預設模板組裝
        Computer stdOffice = new OfficePC().defaultBuild();
        
        // 2. 使用指揮者 + 具體建造者自訂組裝
        Director dir = new Director(new GamingPCBuilder());
        Computer customGaming = dir.construct();
    }
}

建造者 vs 工廠 vs 模板方法

本範例中 Computer.defaultBuild() 即模板方法；Director 類似抽象工廠但強調「建構過程」。

現代 Java 的流式建造者（Lombok @Builder / 手寫）

public class User {
    private final String name;
    private final int age;
    private final String email;
    
    private User(Builder b) {
        this.name = b.name; this.age = b.age; this.email = b.email;
    }
    
    public static class Builder {
        private String name; private int age; private String email;
        public Builder name(String v) { name = v; return this; }
        public Builder age(int v) { age = v; return this; }
        public Builder email(String v) { email = v; return this; }
        public User build() { return new User(this); }
    }
}

// 使用
User u = new User.Builder().name("Tom").age(25).email("tom@ex.com").build();

此為流式建造者，無 Director，適合參數較多、順序固定的不可變物件建構。

總結

1. 建造者模式核心：將構建過程與表示分離，支援多種表示。
2. Director 封裝構建順序，Builder 封裝具體步驟，Product 為最終產物。
3. 現代開發常用流式建造者簡化代碼，複雜組裝邏輯仍建議用經典 Director+Builder。
4. 識別「複雜物件、多部件、順序敏感」場景果斷採用建造者模式。