建造者模式

介绍

建造者模式（Builder Pattern）是一种创建型设计模式，用于构建复杂对象。它允许我们通过指定对象的类型和内容来创建对象，而不需要经过复杂的构造过程。建造者模式将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。

原理

建造者模式的核心原理包括：

1. 产品：要构建的复杂对象
2. 抽象建造者：定义构建产品各个部分的接口
3. 具体建造者：实现抽象建造者的接口，负责具体的构建过程
4. 指挥者：负责安排构建的顺序，调用具体建造者来构建产品

图示

+----------------+        +----------------+
|   Product      |<-------|   Builder      |
+----------------+        +----------------+
| + parts[]      |        | + buildPartA() |
| + show()       |        | + buildPartB() |
+----------------+        | + getResult()  |
                          +--------^-------+
                                  |
+----------------+        +--------+-------+
|   Director     |<------| ConcreteBuilder |
+----------------+        +----------------+
| + construct()  |        | + buildPartA() |
+----------------+        | + buildPartB() |
                          | + getResult()  |
                          +----------------+

代码示例

产品

public class Product {
    private List<String> parts = new ArrayList<>();
    
    public void add(String part) {
        parts.add(part);
    }
    
    public void show() {
        System.out.println("产品组件:");
        for (String part : parts) {
            System.out.println("- " + part);
        }
    }
}

抽象建造者

public abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}

具体建造者

public class ConcreteBuilder1 extends Builder {
    private Product product = new Product();
    
    @Override
    public void buildPartA() {
        product.add("部件A");
    }
    
    @Override
    public void buildPartB() {
        product.add("部件B");
    }
    
    @Override
    public Product getResult() {
        return product;
    }
}

public class ConcreteBuilder2 extends Builder {
    private Product product = new Product();
    
    @Override
    public void buildPartA() {
        product.add("部件X");
    }
    
    @Override
    public void buildPartB() {
        product.add("部件Y");
    }
    
    @Override
    public Product getResult() {
        return product;
    }
}

指挥者

public class Director {
    public void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        
        Builder builder1 = new ConcreteBuilder1();
        director.construct(builder1);
        Product product1 = builder1.getResult();
        product1.show();
        
        Builder builder2 = new ConcreteBuilder2();
        director.construct(builder2);
        Product product2 = builder2.getResult();
        product2.show();
    }
}

解决方案

应用场景

1. 创建复杂对象：当对象包含多个组成部分时
2. 分步构建对象：需要分步骤创建对象，且步骤顺序可能变化
3. 构建不同表示：同样的构建过程需要创建不同的表示
4. 链式调用：实现流式API，提高代码可读性

最佳实践

1. 使用流式接口：让建造者方法返回this，支持链式调用
2. 实现构建验证：在构建完成前验证对象是否有效
3. 静态内部建造者：将建造者作为产品类的静态内部类实现
4. 简化指挥者：在简单场景中，可以省略指挥者角色

优缺点

优点：

• 分离复杂对象的构建和表示
• 允许相同的构建过程创建不同的表示
• 提供对构建步骤的精细控制
• 隐藏产品的内部结构

缺点：

• 增加代码复杂度
• 需要创建多个类

工具推荐

1. Lombok：提供@Builder注解自动生成建造者模式代码
2. Google AutoValue：自动生成不可变对象的建造者
3. Immutables：注解处理器，用于生成不可变对象和建造者
4. Builder Pattern Generator：IntelliJ IDEA插件，自动生成建造者模式代码