创建型-建造者模式

概述

建造者模式（Builder Pattern）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用场景

• 创建复杂对象，由多个部分组成
• 对象的创建过程独立于创建该对象的类
• 需要隔离复杂对象的创建和使用
• 需要生成的对象有多种表示

角色组成

• Product（产品）：被构建的复杂对象
• Builder（抽象建造者）：定义创建产品各部分的接口
• ConcreteBuilder（具体建造者）：实现Builder接口
• Director（指挥者）：构建使用Builder接口的对象

代码实现

1. 产品类

public class Computer {
    private String cpu;
    private String memory;
    private String disk;
    private String gpu;
    
    public void setCpu(String cpu) { this.cpu = cpu; }
    public void setMemory(String memory) { this.memory = memory; }
    public void setDisk(String disk) { this.disk = disk; }
    public void setGpu(String gpu) { this.gpu = gpu; }
    
    @Override
    public String toString() {
        return "Computer{cpu='" + cpu + "', memory='" + memory + 
               "', disk='" + disk + "', gpu='" + gpu + "'}";
    }
}

2. 抽象建造者

public abstract class ComputerBuilder {
    protected Computer computer = new Computer();
    
    public abstract void buildCpu();
    public abstract void buildMemory();
    public abstract void buildDisk();
    public abstract void buildGpu();
    
    public Computer getResult() {
        return computer;
    }
}

3. 具体建造者

// 游戏电脑建造者
public class GamingComputerBuilder extends ComputerBuilder {
    @Override
    public void buildCpu() {
        computer.setCpu("Intel i9-13900K");
    }
    
    @Override
    public void buildMemory() {
        computer.setMemory("64GB DDR5");
    }
    
    @Override
    public void buildDisk() {
        computer.setDisk("2TB NVMe SSD");
    }
    
    @Override
    public void buildGpu() {
        computer.setGpu("RTX 4090");
    }
}

// 办公电脑建造者
public class OfficeComputerBuilder extends ComputerBuilder {
    @Override
    public void buildCpu() {
        computer.setCpu("Intel i5-13400");
    }
    
    @Override
    public void buildMemory() {
        computer.setMemory("16GB DDR4");
    }
    
    @Override
    public void buildDisk() {
        computer.setDisk("512GB SSD");
    }
    
    @Override
    public void buildGpu() {
        computer.setGpu("集成显卡");
    }
}

4. 指挥者

public class Director {
    private ComputerBuilder builder;
    
    public Director(ComputerBuilder builder) {
        this.builder = builder;
    }
    
    public Computer construct() {
        builder.buildCpu();
        builder.buildMemory();
        builder.buildDisk();
        builder.buildGpu();
        return builder.getResult();
    }
}

5. 客户端

public class Client {
    public static void main(String[] args) {
        // 构建游戏电脑
        ComputerBuilder gamingBuilder = new GamingComputerBuilder();
        Director director = new Director(gamingBuilder);
        Computer gamingPC = director.construct();
        System.out.println("游戏电脑: " + gamingPC);
        
        // 构建办公电脑
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();
        director = new Director(officeBuilder);
        Computer officePC = director.construct();
        System.out.println("办公电脑: " + officePC);
    }
}

# 输出
游戏电脑: Computer{cpu='Intel i9-13900K', memory='64GB DDR5', disk='2TB NVMe SSD', gpu='RTX 4090'}
办公电脑: Computer{cpu='Intel i5-13400', memory='16GB DDR4', disk='512GB SSD', gpu='集成显卡'}

链式调用（常用变体）

public class User {
    private final String name;      // 必需
    private final String email;     // 必需
    private final int age;          // 可选
    private final String phone;     // 可选
    private final String address;   // 可选
    
    private User(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }
    
    public static class Builder {
        // 必需参数
        private final String name;
        private final String email;
        
        // 可选参数
        private int age = 0;
        private String phone = "";
        private String address = "";
        
        public Builder(String name, String email) {
            this.name = name;
            this.email = email;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }
        
        public Builder address(String address) {
            this.address = address;
            return this;
        }
        
        public User build() {
            return new User(this);
        }
    }
}

// 使用
User user = new User.Builder("张三", "zhangsan@example.com")
    .age(25)
    .phone("13800138000")
    .address("北京市")
    .build();

类图

JDK 中的应用

• java.lang.StringBuilder
• java.lang.StringBuffer
• java.util.stream.Stream.Builder
• java.nio.ByteBuffer#put()

Lombok @Builder

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class Person {
    private String name;
    private int age;
    private String email;
}

// 使用
Person person = Person.builder()
    .name("李四")
    .age(30)
    .email("lisi@example.com")
    .build();

优缺点

优点：

• 封装性好，构建和表示分离
• 扩展性好，建造者独立，易于扩展
• 便于控制细节风险

缺点：

• 产品必须有共同点，范围有限制
• 内部变化复杂时，建造者会很多