建造者模式全方位深度解析

一、模式定义

建造者模式是一种创建型设计模式，用于分步构建复杂对象。它将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

二、Java源代码实现

1. 经典建造者模式实现

// 1. 产品类（需要构建的复杂对象）
public class Computer {
    // 必需组件
    private final String CPU;
    private final String RAM;
    private final String storage;
    
    // 可选组件
    private final String GPU;
    private final String motherboard;
    private final String powerSupply;
    private final String coolingSystem;
    private final boolean hasWifi;
    private final boolean hasBluetooth;
    private final String OS;
    
    // 私有构造方法，只能通过Builder构建
    private Computer(Builder builder) {
        this.CPU = builder.CPU;
        this.RAM = builder.RAM;
        this.storage = builder.storage;
        this.GPU = builder.GPU;
        this.motherboard = builder.motherboard;
        this.powerSupply = builder.powerSupply;
        this.coolingSystem = builder.coolingSystem;
        this.hasWifi = builder.hasWifi;
        this.hasBluetooth = builder.hasBluetooth;
        this.OS = builder.OS;
    }
    
    // 2. 静态内部建造者类
    public static class Builder {
        // 必需参数
        private final String CPU;
        private final String RAM;
        private final String storage;
        
        // 可选参数 - 使用默认值
        private String GPU = "Integrated Graphics";
        private String motherboard = "Standard Motherboard";
        private String powerSupply = "500W";
        private String coolingSystem = "Air Cooling";
        private boolean hasWifi = false;
        private boolean hasBluetooth = false;
        private String OS = "No OS";
        
        // 必需参数通过构造方法传入
        public Builder(String CPU, String RAM, String storage) {
            this.CPU = CPU;
            this.RAM = RAM;
            this.storage = storage;
        }
        
        // 设置可选参数的方法，返回Builder支持链式调用
        public Builder GPU(String GPU) {
            this.GPU = GPU;
            return this;
        }
        
        public Builder motherboard(String motherboard) {
            this.motherboard = motherboard;
            return this;
        }
        
        public Builder powerSupply(String powerSupply) {
            this.powerSupply = powerSupply;
            return this;
        }
        
        public Builder coolingSystem(String coolingSystem) {
            this.coolingSystem = coolingSystem;
            return this;
        }
        
        public Builder hasWifi(boolean hasWifi) {
            this.hasWifi = hasWifi;
            return this;
        }
        
        public Builder hasBluetooth(boolean hasBluetooth) {
            this.hasBluetooth = hasBluetooth;
            return this;
        }
        
        public Builder OS(String OS) {
            this.OS = OS;
            return this;
        }
        
        // 构建方法
        public Computer build() {
            validate();
            return new Computer(this);
        }
        
        // 验证逻辑
        private void validate() {
            if (CPU == null || CPU.isEmpty()) {
                throw new IllegalStateException("CPU不能为空");
            }
            if (RAM == null || RAM.isEmpty()) {
                throw new IllegalStateException("RAM不能为空");
            }
            if (storage == null || storage.isEmpty()) {
                throw new IllegalStateException("存储不能为空");
            }
            // 更多验证逻辑...
        }
    }
    
    // Getters
    public String getCPU() { return CPU; }
    public String getRAM() { return RAM; }
    public String getStorage() { return storage; }
    public String getGPU() { return GPU; }
    public String getMotherboard() { return motherboard; }
    public String getPowerSupply() { return powerSupply; }
    public String getCoolingSystem() { return coolingSystem; }
    public boolean isHasWifi() { return hasWifi; }
    public boolean isHasBluetooth() { return hasBluetooth; }
    public String getOS() { return OS; }
    
    @Override
    public String toString() {
        return "Computer{" +
                "CPU='" + CPU + ''' +
                ", RAM='" + RAM + ''' +
                ", storage='" + storage + ''' +
                ", GPU='" + GPU + ''' +
                ", motherboard='" + motherboard + ''' +
                ", powerSupply='" + powerSupply + ''' +
                ", coolingSystem='" + coolingSystem + ''' +
                ", hasWifi=" + hasWifi +
                ", hasBluetooth=" + hasBluetooth +
                ", OS='" + OS + ''' +
                '}';
    }
}

2. 导演者（Director）扩展模式

// 导演者类 - 封装构建过程
public class ComputerDirector {
    private Computer.Builder builder;
    
    public ComputerDirector(Computer.Builder builder) {
        this.builder = builder;
    }
    
    // 构建游戏电脑
    public Computer buildGamingComputer() {
        return builder
                .GPU("NVIDIA RTX 4090")
                .motherboard("ASUS ROG Z790")
                .powerSupply("1000W Gold")
                .coolingSystem("Liquid Cooling")
                .hasWifi(true)
                .hasBluetooth(true)
                .OS("Windows 11 Pro")
                .build();
    }
    
    // 构建办公电脑
    public Computer buildOfficeComputer() {
        return builder
                .GPU("Integrated Graphics")
                .motherboard("Standard B660")
                .powerSupply("600W Bronze")
                .coolingSystem("Air Cooling")
                .hasWifi(true)
                .hasBluetooth(false)
                .OS("Windows 10 Pro")
                .build();
    }
    
    // 构建服务器
    public Computer buildServer() {
        return builder
                .GPU(null) // 服务器通常不需要独立显卡
                .motherboard("Server-grade Motherboard")
                .powerSupply("1200W Redundant")
                .coolingSystem("Server-grade Cooling")
                .hasWifi(false)
                .hasBluetooth(false)
                .OS("Ubuntu Server 22.04")
                .build();
    }
}

3. 客户端使用示例

public class BuilderClient {
    public static void main(String[] args) {
        System.out.println("=== 基础建造者模式使用 ===");
        testBasicBuilder();
        
        System.out.println("\n=== 导演者模式使用 ===");
        testDirectorPattern();
        
        System.out.println("\n=== 复杂对象构建示例 ===");
        testComplexObject();
        
        System.out.println("\n=== 验证逻辑测试 ===");
        testValidation();
    }
    
    private static void testBasicBuilder() {
        // 1. 构建基础配置电脑
        Computer basicComputer = new Computer.Builder("Intel i5", "16GB", "512GB SSD")
                .build();
        System.out.println("基础电脑: " + basicComputer);
        
        // 2. 构建高级配置电脑（链式调用）
        Computer gamingComputer = new Computer.Builder("AMD Ryzen 9", "32GB", "2TB NVMe SSD")
                .GPU("NVIDIA RTX 4080")
                .motherboard("MSI MPG Z790")
                .powerSupply("850W Gold")
                .coolingSystem("Liquid Cooling")
                .hasWifi(true)
                .hasBluetooth(true)
                .OS("Windows 11 Home")
                .build();
        System.out.println("游戏电脑: " + gamingComputer);
        
        // 3. 部分参数构建
        Computer officeComputer = new Computer.Builder("Intel i7", "16GB", "1TB SSD")
                .GPU("Intel UHD Graphics")
                .hasWifi(true)
                .OS("Windows 10 Pro")
                .build();
        System.out.println("办公电脑: " + officeComputer);
    }
    
    private static void testDirectorPattern() {
        ComputerDirector director = new ComputerDirector(
                new Computer.Builder("Intel i7", "32GB", "1TB SSD")
        );
        
        // 使用导演者构建不同类型电脑
        Computer gamingPc = director.buildGamingComputer();
        System.out.println("导演者构建的游戏电脑: " + gamingPc);
        
        Computer officePc = director.buildOfficeComputer();
        System.out.println("导演者构建的办公电脑: " + officePc);
        
        Computer server = director.buildServer();
        System.out.println("导演者构建的服务器: " + server);
    }
    
    private static void testComplexObject() {
        // 构建一个复杂的订单对象
        Order order = new Order.Builder("ORD-20240101-001")
                .customer("张三")
                .item("笔记本电脑", 2)
                .item("鼠标", 5)
                .shippingAddress("北京市朝阳区")
                .billingAddress("北京市海淀区")
                .paymentMethod("信用卡")
                .discountCode("SPRING2024")
                .notes("请下午送货")
                .build();
        
        System.out.println("复杂订单对象: " + order);
        System.out.println("订单总金额: $" + order.calculateTotal());
    }
    
    private static void testValidation() {
        try {
            // 测试验证逻辑 - 缺少必需参数
            Computer invalidComputer = new Computer.Builder("", "16GB", "512GB SSD")
                    .build();
        } catch (IllegalStateException e) {
            System.out.println("验证失败: " + e.getMessage());
        }
    }
}

// 复杂对象示例：订单
class Order {
    private final String orderId;
    private final String customer;
    private final Map<String, Integer> items;
    private final String shippingAddress;
    private final String billingAddress;
    private final String paymentMethod;
    private final String discountCode;
    private final String notes;
    private final LocalDateTime orderDate;
    
    private Order(Builder builder) {
        this.orderId = builder.orderId;
        this.customer = builder.customer;
        this.items = new HashMap<>(builder.items);
        this.shippingAddress = builder.shippingAddress;
        this.billingAddress = builder.billingAddress;
        this.paymentMethod = builder.paymentMethod;
        this.discountCode = builder.discountCode;
        this.notes = builder.notes;
        this.orderDate = builder.orderDate;
    }
    
    public double calculateTotal() {
        // 模拟计算逻辑
        return items.size() * 100.0;
    }
    
    public static class Builder {
        private final String orderId;
        private String customer = "Guest";
        private Map<String, Integer> items = new HashMap<>();
        private String shippingAddress = "";
        private String billingAddress = "";
        private String paymentMethod = "Cash";
        private String discountCode = "";
        private String notes = "";
        private LocalDateTime orderDate = LocalDateTime.now();
        
        public Builder(String orderId) {
            this.orderId = orderId;
        }
        
        public Builder customer(String customer) {
            this.customer = customer;
            return this;
        }
        
        public Builder item(String name, int quantity) {
            this.items.put(name, quantity);
            return this;
        }
        
        public Builder shippingAddress(String address) {
            this.shippingAddress = address;
            return this;
        }
        
        public Builder billingAddress(String address) {
            this.billingAddress = address;
            return this;
        }
        
        public Builder paymentMethod(String method) {
            this.paymentMethod = method;
            return this;
        }
        
        public Builder discountCode(String code) {
            this.discountCode = code;
            return this;
        }
        
        public Builder notes(String notes) {
            this.notes = notes;
            return this;
        }
        
        public Order build() {
            return new Order(this);
        }
    }
    
    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + ''' +
                ", customer='" + customer + ''' +
                ", items=" + items +
                ", orderDate=" + orderDate +
                '}';
    }
}

4. 建造者模式的变体实现

// 变体1：接口式建造者
public interface UserBuilder {
    UserBuilder firstName(String firstName);
    UserBuilder lastName(String lastName);
    UserBuilder age(int age);
    UserBuilder email(String email);
    UserBuilder phone(String phone);
    User build();
}

// 具体建造者实现
public class DefaultUserBuilder implements UserBuilder {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    private String phone;
    
    @Override
    public UserBuilder firstName(String firstName) {
        this.firstName = firstName;
        return this;
    }
    
    @Override
    public UserBuilder lastName(String lastName) {
        this.lastName = lastName;
        return this;
    }
    
    @Override
    public UserBuilder age(int age) {
        this.age = age;
        return this;
    }
    
    @Override
    public UserBuilder email(String email) {
        this.email = email;
        return this;
    }
    
    @Override
    public UserBuilder phone(String phone) {
        this.phone = phone;
        return this;
    }
    
    @Override
    public User build() {
        return new User(firstName, lastName, age, email, phone);
    }
}

// 变体2：分步建造者
public class StepBuilder<T> {
    public interface FirstStep<T> {
        SecondStep<T> setFirstName(String firstName);
    }
    
    public interface SecondStep<T> {
        ThirdStep<T> setLastName(String lastName);
    }
    
    public interface ThirdStep<T> {
        BuildStep<T> setAge(int age);
    }
    
    public interface BuildStep<T> {
        BuildStep<T> setEmail(String email);
        BuildStep<T> setPhone(String phone);
        T build();
    }
    
    // 实现分步构建
    public static FirstStep<User> newBuilder() {
        return new Steps();
    }
    
    private static class Steps implements FirstStep<User>, SecondStep<User>, 
                                           ThirdStep<User>, BuildStep<User> {
        private String firstName;
        private String lastName;
        private int age;
        private String email;
        private String phone;
        
        @Override
        public SecondStep<User> setFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }
        
        @Override
        public ThirdStep<User> setLastName(String lastName) {
            this.lastName = lastName;
            return this;
        }
        
        @Override
        public BuildStep<User> setAge(int age) {
            this.age = age;
            return this;
        }
        
        @Override
        public BuildStep<User> setEmail(String email) {
            this.email = email;
            return this;
        }
        
        @Override
        public BuildStep<User> setPhone(String phone) {
            this.phone = phone;
            return this;
        }
        
        @Override
        public User build() {
            return new User(firstName, lastName, age, email, phone);
        }
    }
}

// 使用分步建造者
class UserBuilderClient {
    public static void main(String[] args) {
        User user = StepBuilder.newBuilder()
                .setFirstName("张")
                .setLastName("三")
                .setAge(30)
                .setEmail("zhangsan@example.com")
                .setPhone("13800138000")
                .build();
        System.out.println("分步构建的用户: " + user);
    }
}

5. Lombok建造者模式注解

// 使用Lombok简化建造者模式实现
import lombok.Builder;
import lombok.Singular;
import lombok.ToString;
import java.util.List;

@Builder
@ToString
public class LombokComputer {
    @lombok.NonNull
    private final String CPU;
    @lombok.NonNull
    private final String RAM;
    @lombok.NonNull
    private final String storage;
    
    private final String GPU;
    private final String motherboard;
    private final String powerSupply;
    
    @Singular // 自动生成addXXX方法
    private final List<String> peripherals;
    
    @Builder.Default // 设置默认值
    private final boolean hasWifi = false;
    
    // 自定义构建逻辑
    public static class LombokComputerBuilder {
        public LombokComputer build() {
            // 自定义验证逻辑
            if (CPU == null || CPU.isEmpty()) {
                throw new IllegalStateException("CPU不能为空");
            }
            return new LombokComputer(CPU, RAM, storage, GPU, motherboard, 
                                     powerSupply, peripherals, hasWifi);
        }
    }
}

// 使用Lombok建造者
class LombokBuilderExample {
    public static void main(String[] args) {
        LombokComputer computer = LombokComputer.builder()
                .CPU("Intel i7")
                .RAM("16GB")
                .storage("1TB SSD")
                .GPU("NVIDIA RTX 3070")
                .peripheral("Keyboard")
                .peripheral("Mouse")
                .peripheral("Monitor")
                .build();
        System.out.println("Lombok构建的电脑: " + computer);
    }
}

三、应用场景深度解析

1. 复杂对象创建场景

• 多参数构造：对象有大量可选参数时
• 分步构建：对象构建需要多个步骤
• 配置复杂：需要配置多个相互依赖的组件

2. 特定领域应用

// 场景1：SQL查询构建器
public class SqlQueryBuilder {
    public static class Builder {
        private String select = "*";
        private String from;
        private String where;
        private String orderBy;
        private Integer limit;
        private Integer offset;
        
        public Builder select(String... columns) {
            this.select = String.join(", ", columns);
            return this;
        }
        
        public Builder from(String table) {
            this.from = table;
            return this;
        }
        
        public Builder where(String condition) {
            this.where = condition;
            return this;
        }
        
        public Builder orderBy(String column, boolean ascending) {
            this.orderBy = column + " " + (ascending ? "ASC" : "DESC");
            return this;
        }
        
        public Builder limit(int limit) {
            this.limit = limit;
            return this;
        }
        
        public Builder offset(int offset) {
            this.offset = offset;
            return this;
        }
        
        public String build() {
            StringBuilder sql = new StringBuilder("SELECT ").append(select);
            sql.append(" FROM ").append(from);
            
            if (where != null) {
                sql.append(" WHERE ").append(where);
            }
            
            if (orderBy != null) {
                sql.append(" ORDER BY ").append(orderBy);
            }
            
            if (limit != null) {
                sql.append(" LIMIT ").append(limit);
            }
            
            if (offset != null) {
                sql.append(" OFFSET ").append(offset);
            }
            
            return sql.toString();
        }
    }
}

// 场景2：HTTP请求构建
public class HttpRequest {
    private final String method;
    private final String url;
    private final Map<String, String> headers;
    private final String body;
    
    public static class Builder {
        private String method = "GET";
        private String url;
        private Map<String, String> headers = new HashMap<>();
        private String body;
        
        public Builder method(String method) {
            this.method = method.toUpperCase();
            return this;
        }
        
        public Builder url(String url) {
            this.url = url;
            return this;
        }
        
        public Builder header(String key, String value) {
            this.headers.put(key, value);
            return this;
        }
        
        public Builder body(String body) {
            this.body = body;
            return this;
        }
        
        public HttpRequest build() {
            if (url == null || url.isEmpty()) {
                throw new IllegalStateException("URL不能为空");
            }
            return new HttpRequest(method, url, headers, body);
        }
    }
}

3. 不可变对象创建

// 不可变的配置对象
public class AppConfig {
    private final String appName;
    private final String version;
    private final String environment;
    private final int port;
    private final boolean debug;
    private final DatabaseConfig database;
    
    // 只能通过Builder创建
    private AppConfig(Builder builder) {
        this.appName = builder.appName;
        this.version = builder.version;
        this.environment = builder.environment;
        this.port = builder.port;
        this.debug = builder.debug;
        this.database = builder.database;
    }
    
    public static Builder builder() {
        return new Builder();
    }
    
    // Builder类
    public static class Builder {
        private String appName = "MyApp";
        private String version = "1.0.0";
        private String environment = "development";
        private int port = 8080;
        private boolean debug = false;
        private DatabaseConfig database;
        
        public Builder appName(String appName) {
            this.appName = appName;
            return this;
        }
        
        public Builder version(String version) {
            this.version = version;
            return this;
        }
        
        public Builder environment(String environment) {
            this.environment = environment;
            return this;
        }
        
        public Builder port(int port) {
            if (port < 1 || port > 65535) {
                throw new IllegalArgumentException("端口号必须在1-65535之间");
            }
            this.port = port;
            return this;
        }
        
        public Builder debug(boolean debug) {
            this.debug = debug;
            return this;
        }
        
        public Builder database(DatabaseConfig database) {
            this.database = database;
            return this;
        }
        
        public AppConfig build() {
            return new AppConfig(this);
        }
    }
}

四、优缺点深度解析

优点

1. 良好的封装性

   • 构建过程封装在Builder内部
   • 客户端无需了解产品内部细节
   • 构建逻辑与业务逻辑分离

2. 良好的可扩展性

   • 新增产品部件时只需修改Builder
   • 支持构建不同表示的产品
   • 易于扩展新的构建过程

3. 提高代码可读性

   • 链式调用使代码清晰易懂
   • 命名良好的setter方法增强可读性
   • 避免过长的构造函数参数列表

4. 构建过程可控

   • 可以分步构建复杂对象
   • 可以在build()方法中添加验证逻辑
   • 支持构建不可变对象

5. 良好的灵活性

   • 可以动态改变产品的内部表示
   • 支持构建过程的重用
   • 可以与工厂模式、模板方法模式结合

缺点

1. 代码复杂度增加

   • 需要创建多个Builder类
   • 增加了类的数量
   • 对于简单对象可能过度设计

2. 产品必须有共同接口

   • 不同产品需要相似的构建过程
   • 如果产品差异过大，Builder模式不适用

3. 内存开销

   • Builder对象在构建过程中占用内存
   • 对于大量简单对象创建可能不高效

4. 学习成本

   • 新开发人员需要理解Builder模式
   • 可能被误用或过度使用

五、使用要点与最佳实践

1. 参数验证策略

// 策略1：构建时验证
public class ValidatedBuilder {
    private final String requiredField;
    private String optionalField;
    
    public static class Builder {
        private String requiredField;
        private String optionalField;
        
        public Builder requiredField(String field) {
            this.requiredField = field;
            return this;
        }
        
        public Builder optionalField(String field) {
            this.optionalField = field;
            return this;
        }
        
        public ValidatedBuilder build() {
            // 构建时验证
            validate();
            return new ValidatedBuilder(this);
        }
        
        private void validate() {
            if (requiredField == null || requiredField.trim().isEmpty()) {
                throw new IllegalStateException("必需字段不能为空");
            }
            if (optionalField != null && optionalField.length() > 100) {
                throw new IllegalStateException("可选字段长度不能超过100");
            }
        }
    }
}

// 策略2：延迟验证
public class LazyValidationBuilder {
    private List<RuntimeException> errors = new ArrayList<>();
    
    public LazyValidationBuilder addError(RuntimeException error) {
        errors.add(error);
        return this;
    }
    
    public void validate() {
        if (!errors.isEmpty()) {
            RuntimeException exception = new IllegalArgumentException("验证失败");
            errors.forEach(exception::addSuppressed);
            throw exception;
        }
    }
}

2. 构建过程优化

// 缓存常用配置
public class CachedBuilder {
    private static final Map<String, Product> cache = new ConcurrentHashMap<>();
    
    public static class Builder {
        private String configKey;
        private Product template;
        
        public Builder fromCache(String key) {
            this.configKey = key;
            this.template = cache.get(key);
            if (template == null) {
                throw new IllegalArgumentException("缓存中不存在配置: " + key);
            }
            return this;
        }
        
        public Builder customize(String property, Object value) {
            // 基于模板定制
            return this;
        }
        
        public Product build() {
            Product product = template != null ? template.clone() : new Product();
            // 应用定制
            cache.put(configKey, product);
            return product;
        }
    }
}

3. 线程安全考虑

// 线程安全的建造者
public class ThreadSafeBuilder {
    // 使用ThreadLocal确保线程安全
    private static final ThreadLocal<Builder> threadLocalBuilder = 
        ThreadLocal.withInitial(Builder::new);
    
    public static class Builder {
        private final Object lock = new Object();
        private String data;
        
        public Builder setData(String data) {
            synchronized (lock) {
                this.data = data;
                return this;
            }
        }
        
        public Product build() {
            synchronized (lock) {
                // 构建过程
                return new Product(data);
            }
        }
    }
}

4. 与工厂模式结合

// 建造者工厂模式
public abstract class VehicleFactory {
    public abstract VehicleBuilder createBuilder();
    
    public Vehicle buildVehicle(String type) {
        VehicleBuilder builder = createBuilder();
        
        switch (type.toLowerCase()) {
            case "car":
                return builder
                    .addWheels(4)
                    .addEngine("汽油发动机")
                    .addSeats(5)
                    .build();
            case "motorcycle":
                return builder
                    .addWheels(2)
                    .addEngine("摩托车发动机")
                    .addSeats(2)
                    .build();
            case "truck":
                return builder
                    .addWheels(6)
                    .addEngine("柴油发动机")
                    .addSeats(3)
                    .build();
            default:
                throw new IllegalArgumentException("未知的车辆类型: " + type);
        }
    }
}

5. 构建器模式的高级用法

// 1. 泛型建造者
public class GenericBuilder<T> {
    private final Supplier<T> constructor;
    private List<Consumer<T>> modifiers = new ArrayList<>();
    
    public GenericBuilder(Supplier<T> constructor) {
        this.constructor = constructor;
    }
    
    public static <T> GenericBuilder<T> of(Supplier<T> constructor) {
        return new GenericBuilder<>(constructor);
    }
    
    public <U> GenericBuilder<T> with(BiConsumer<T, U> consumer, U value) {
        modifiers.add(instance -> consumer.accept(instance, value));
        return this;
    }
    
    public T build() {
        T instance = constructor.get();
        modifiers.forEach(modifier -> modifier.accept(instance));
        return instance;
    }
}

// 使用泛型建造者
class Person {
    private String name;
    private int age;
    
    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }
}

// 2. 流式建造者
public class FluentBuilder<T> {
    private T instance;
    
    public FluentBuilder(Supplier<T> supplier) {
        this.instance = supplier.get();
    }
    
    public FluentBuilder<T> with(Consumer<T> initializer) {
        initializer.accept(instance);
        return this;
    }
    
    public T build() {
        return instance;
    }
}

6. 测试策略

@Test
public void testBuilderPattern() {
    // 测试必需参数验证
    assertThrows(IllegalStateException.class, () -> {
        new Computer.Builder(null, "16GB", "512GB").build();
    });
    
    // 测试可选参数默认值
    Computer computer = new Computer.Builder("i7", "16GB", "1TB").build();
    assertEquals("Integrated Graphics", computer.getGPU());
    assertEquals("Standard Motherboard", computer.getMotherboard());
    
    // 测试链式调用
    Computer gamingPc = new Computer.Builder("i9", "32GB", "2TB")
            .GPU("RTX 4090")
            .motherboard("ROG Z790")
            .build();
    assertEquals("RTX 4090", gamingPc.getGPU());
    
    // 测试不可变性
    List<String> peripherals = new ArrayList<>();
    peripherals.add("Keyboard");
    Computer pc = new Computer.Builder("i5", "8GB", "256GB").build();
    // pc.setCPU("i7"); // 编译错误，对象不可变
    
    // 测试性能
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        new Computer.Builder("CPU", "RAM", "Storage").build();
    }
    long duration = System.currentTimeMillis() - startTime;
    assertTrue(duration < 1000, "构建10000个对象应在1秒内完成");
}

六、与其他模式的比较

模式	相似点	不同点	适用场景
工厂模式​	都用于创建对象	工厂模式关注产品创建，建造者关注构建过程	简单对象用工厂，复杂对象用建造者
原型模式​	都创建对象	原型通过复制，建造者通过配置构建	已有相似对象用原型，需要定制化用建造者
模板方法​	都定义算法骨架	模板方法关注算法步骤，建造者关注对象构建	算法流程用模板方法，对象构建用建造者
组合模式​	都处理复杂结构	组合处理树形结构，建造者构建单个对象	层次结构用组合，单个复杂对象用建造者

七、实际应用示例

示例1：Spring框架中的建造者模式

// Spring中的建造者模式应用
@Configuration
public class AppConfig {
    
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create()
                .driverClassName("com.mysql.cj.jdbc.Driver")
                .url("jdbc:mysql://localhost:3306/mydb")
                .username("root")
                .password("password")
                .build();
    }
    
    @Bean
    public RestTemplate restTemplate() {
        return RestTemplateBuilder()
                .setConnectTimeout(Duration.ofSeconds(5))
                .setReadTimeout(Duration.ofSeconds(10))
                .additionalInterceptors(new LoggingInterceptor())
                .build();
    }
}

示例2：Java API中的建造者模式

// Java标准库中的建造者模式
public class JavaBuilderExample {
    public static void main(String[] args) {
        // 1. StringBuilder/StringBuffer
        StringBuilder sb = new StringBuilder()
                .append("Hello")
                .append(" ")
                .append("World")
                .append("!")
                .insert(5, ",");
        
        // 2. Locale.Builder
        Locale locale = new Locale.Builder()
                .setLanguage("zh")
                .setRegion("CN")
                .setScript("Hans")
                .build();
        
        // 3. DateTimeFormatter.Builder
        DateTimeFormatter formatter = new DateTimeFormatterBuilder()
                .appendPattern("yyyy-MM-dd")
                .appendLiteral(" ")
                .appendPattern("HH:mm:ss")
                .toFormatter();
        
        // 4. ProcessBuilder
        ProcessBuilder processBuilder = new ProcessBuilder("java", "-version")
                .directory(new File("/usr/bin"))
                .redirectOutput(ProcessBuilder.Redirect.INHERIT)
                .redirectError(ProcessBuilder.Redirect.INHERIT);
    }
}

八、注意事项

1. 避免过度设计：简单对象不需要建造者模式
2. 保持一致性：确保所有Builder方法返回this
3. 考虑不可变性：使用final字段确保对象不可变
4. 合理使用默认值：为可选参数提供合理的默认值
5. 添加验证逻辑：在build()方法中验证参数合法性
6. 考虑线程安全：多线程环境下需要特别处理
7. 文档化：为Builder方法添加清晰的文档
8. 性能考虑：避免在Builder中执行昂贵操作

九、总结

建造者模式是一种强大的对象创建模式，特别适用于：

• 对象有大量可选参数
• 需要创建不可变对象
• 构建过程复杂且需要分步进行
• 需要创建不同表示的对象

正确使用建造者模式需要：

1. 合理划分必需参数和可选参数
2. 提供良好的默认值
3. 实现链式调用提高可读性
4. 在build()方法中添加验证逻辑
5. 考虑与工厂模式、模板方法模式的结合

在Java生态中，建造者模式广泛应用于：

• 配置对象的创建（Spring Boot配置）
• 查询构建器（JPA Criteria API）
• HTTP客户端构建（OkHttp, Retrofit）
• 测试数据构建（测试框架）

掌握建造者模式能够显著提高代码的可读性、可维护性和灵活性，是Java开发者必须掌握的重要设计模式。