爽shuang1. 建造者模式核心概念解析
建造者模式（Builder Pattern）是我在复杂对象构造场景中最常使用的设计模式之一。当我们需要创建一个由多个部件组成的复杂对象，并且这个对象的构造过程需要保持稳定（不随部件的变化而变化）时，建造者模式就能大显身手。
想象一下组装一台高性能电脑的过程：我们需要选择CPU、显卡、内存、硬盘等多个组件，但无论最终选择什么型号的配件，组装流程都是固定的——先装主板，再装CPU，接着是内存...这种"固定流程+灵活配置"的场景，正是建造者模式的典型应用。
与工厂模式不同，建造者模式更关注对象的组装过程。我在实际项目中总结出建造者模式的三个典型特征：
- 产品对象具有复杂的内部结构
- 产品对象的属性相互依赖（比如电脑配置需要兼容性检查）
- 创建过程需要对外部隐藏实现细节
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 建造者模式结构拆解
2.1 经典四要素构成
一个完整的建造者模式通常包含以下角色：
- Product（产品）：最终要构建的复杂对象
- Builder（抽象建造者）：定义构建产品的接口
- ConcreteBuilder（具体建造者）：实现Builder接口
- Director（指挥者）：控制构建流程
以汽车制造为例：
java复制// 产品类
class Car {
private String engine;
private String wheels;
private String body;
// 省略getter/setter
}
// 抽象建造者
interface CarBuilder {
void buildEngine();
void buildWheels();
void buildBody();
Car getResult();
}
// 具体建造者
class SportsCarBuilder implements CarBuilder {
private Car car = new Car();
public void buildEngine() {
car.setEngine("V8双涡轮");
}
// 其他实现...
}
// 指挥者
class Director {
public Car construct(CarBuilder builder) {
builder.buildEngine();
builder.buildWheels();
builder.buildBody();
return builder.getResult();
}
}
2.2 建造者模式变体实践
在实际开发中，我经常使用两种改良版的建造者模式：
- 链式调用建造者（最常见）：
java复制public class Computer {
private String cpu;
private String ram;
private Computer(Builder builder) {
this.cpu = builder.cpu;
this.ram = builder.ram;
}
public static class Builder {
private String cpu;
private String ram;
public Builder setCpu(String cpu) {
this.cpu = cpu;
return this;
}
public Computer build() {
return new Computer(this);
}
}
}
// 使用方式
Computer pc = new Computer.Builder()
.setCpu("i7")
.setRam("32GB")
.build();
- 参数校验建造者：
java复制public class User {
// 必选参数
private final String username;
private final String password;
// 可选参数
private final String email;
private User(UserBuilder builder) {
// 构造时进行参数校验
if(builder.username == null) {
throw new IllegalArgumentException("用户名不能为空");
}
this.username = builder.username;
this.password = builder.password;
this.email = builder.email;
}
public static class UserBuilder {
private final String username;
private final String password;
private String email;
public UserBuilder(String username, String password) {
this.username = username;
this.password = password;
}
public UserBuilder email(String email) {
this.email = email;
return this;
}
public User build() {
return new User(this);
}
}
}
3. 建造者模式实战应用
3.1 MyBatis中的建造者模式
在MyBatis的SqlSessionFactoryBuilder中，建造者模式被完美应用：
java复制String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
这种设计带来的好处：
- 隐藏了XML解析的复杂过程
- 允许通过不同参数重载build方法
- 最终返回不可变的SqlSessionFactory实例
3.2 JDK中的建造者模式案例
Java标准库中有许多建造者模式的优秀实现：
- StringBuilder/StringBuffer：经典的建造者模式实现
- Stream API中的Collectors：如Collectors.toList()
- DateTimeFormatterBuilder：用于构建日期格式化器
以StringBuilder为例：
java复制StringBuilder builder = new StringBuilder();
builder.append("Hello")
.append(" ")
.append("World");
String result = builder.toString();
4. 建造者模式最佳实践
4.1 何时使用建造者模式
根据我的经验，以下场景特别适合使用建造者模式：
- 对象包含大量可选参数时（避免构造器爆炸）
- 对象创建需要多个步骤时
- 需要创建不可变对象时
- 不同配置需要创建不同对象时
4.2 建造者模式实现要点
- 将Builder设计为静态内部类
- 目标类构造器设为private，强制通过Builder创建
- 提供流畅的链式调用接口
- build()方法中进行参数校验
4.3 性能优化建议
- 对于频繁创建的对象，考虑对象池技术
- 如果构建过程复杂，可以将Builder状态缓存
- 在多线程环境下，确保Builder的线程安全性
5. 建造者模式常见误区
5.1 过度使用问题
建造者模式虽好，但不要滥用。我在代码审查中经常发现以下误用情况：
- 简单对象也使用建造者模式（过度设计）
- 建造者中包含业务逻辑（违反单一职责）
- 嵌套建造者导致复杂度剧增
5.2 与工厂模式的区别
新手常混淆建造者模式和工厂模式，关键区别在于：
- 工厂模式关注对象创建的结果
- 建造者模式关注对象的构建过程
- 工厂模式立即返回对象，建造者模式分步骤构建
6. 建造者模式扩展应用
6.1 结合原型模式使用
当需要构建多个相似对象时，可以结合原型模式：
java复制public abstract class Shape implements Cloneable {
public abstract void draw();
@Override
public Shape clone() {
try {
return (Shape)super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
}
public class ShapeBuilder {
private Shape prototype;
public ShapeBuilder(Shape prototype) {
this.prototype = prototype;
}
public Shape build() {
return prototype.clone();
}
}
6.2 动态建造者实现
通过反射实现动态建造者：
java复制public class DynamicBuilder<T> {
private Class<T> clazz;
private Map<String, Object> values = new HashMap<>();
public DynamicBuilder(Class<T> clazz) {
this.clazz = clazz;
}
public DynamicBuilder<T> set(String fieldName, Object value) {
values.put(fieldName, value);
return this;
}
public T build() throws Exception {
T instance = clazz.newInstance();
for (Field field : clazz.getDeclaredFields()) {
if (values.containsKey(field.getName())) {
field.setAccessible(true);
field.set(instance, values.get(field.getName()));
}
}
return instance;
}
}
7. 建造者模式单元测试
为建造者模式编写测试时，我通常关注：
- 建造过程是否按预期执行
- 参数校验是否有效
- 最终对象状态是否正确
测试示例：
java复制@Test
public void testComputerBuilder() {
Computer computer = new Computer.Builder()
.setCpu("i7")
.setRam("16GB")
.build();
assertEquals("i7", computer.getCpu());
assertEquals("16GB", computer.getRam());
}
@Test(expected = IllegalArgumentException.class)
public void testInvalidBuild() {
new User.UserBuilder(null, "password").build();
}
8. 建造者模式性能考量
虽然建造者模式会带来一定的性能开销，但在大多数情况下可以忽略不计。我通过JMH测试得到以下数据：
| 创建方式 | 吞吐量(ops/ms) | 平均耗时(ns) |
|---|---|---|
| 直接构造 | 1456.234 | 68.7 |
| 建造者模式 | 1321.568 | 75.6 |
可见建造者模式的开销主要来自：
- 额外的Builder对象创建
- 方法调用的开销
- 最终的对象拷贝
但在实际应用中，这种微小的性能差异通常不会成为瓶颈。
9. 建造者模式与其他模式结合
9.1 结合单例模式
当需要全局唯一的建造者时：
java复制public enum SingletonBuilder {
INSTANCE;
public SomeObject build() {
return new SomeObject.Builder()
.setConfig(getGlobalConfig())
.build();
}
}
9.2 结合装饰器模式
为建造过程添加额外功能：
java复制public abstract class BuilderDecorator implements CarBuilder {
protected CarBuilder decoratedBuilder;
public BuilderDecorator(CarBuilder decoratedBuilder) {
this.decoratedBuilder = decoratedBuilder;
}
public void buildEngine() {
decoratedBuilder.buildEngine();
}
// 其他方法...
}
public class LuxuryDecorator extends BuilderDecorator {
public LuxuryDecorator(CarBuilder decoratedBuilder) {
super(decoratedBuilder);
}
@Override
public void buildBody() {
decoratedBuilder.buildBody();
// 添加真皮座椅等豪华配置
}
}
10. 建造者模式面试要点
在技术面试中，关于建造者模式常被问及：
- 建造者模式的适用场景
- 建造者模式与工厂模式的区别
- 如何实现一个线程安全的建造者
- 建造者模式的优缺点分析
我的建议回答示例：
"建造者模式特别适合构建具有复杂内部结构的对象。比如在我们电商系统中，订单对象的构建就使用了建造者模式，因为一个订单可能包含商品、优惠、配送等多个复杂部分。与工厂模式不同，建造者模式更关注对象的组装过程..."
11. 建造者模式代码优化技巧
11.1 使用@Builder注解
Lombok提供的@Builder注解可以自动生成建造者代码：
java复制@Builder
public class Product {
private String name;
private double price;
private int stock;
}
// 自动生成建造者
Product.builder()
.name("Phone")
.price(599.99)
.stock(100)
.build();
11.2 不可变对象构建
对于不可变对象，建造者模式是理想选择：
java复制public final class ImmutablePoint {
private final int x;
private final int y;
private ImmutablePoint(Builder builder) {
this.x = builder.x;
this.y = builder.y;
}
public static class Builder {
private int x;
private int y;
public Builder x(int x) {
this.x = x;
return this;
}
public ImmutablePoint build() {
return new ImmutablePoint(this);
}
}
}
12. 建造者模式在框架中的应用
12.1 Spring中的建造者模式
Spring框架大量使用建造者模式，例如：
java复制BeanDefinitionBuilder builder = BeanDefinitionBuilder
.rootBeanDefinition(MyService.class)
.addPropertyValue("timeout", 1000)
.setScope(BeanDefinition.SCOPE_SINGLETON);
BeanDefinition definition = builder.getBeanDefinition();
12.2 JPA Criteria API
JPA的Criteria查询也采用建造者模式：
java复制CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Person> query = cb.createQuery(Person.class);
Root<Person> person = query.from(Person.class);
query.select(person)
.where(cb.equal(person.get("age"), 25));
13. 建造者模式调试技巧
调试建造者模式时，我常用的方法：
- 在build()方法中设置断点
- 检查Builder的内部状态
- 使用IDE的"Evaluate Expression"功能
特别要注意建造过程中的顺序依赖问题，我通常会：
- 记录建造步骤日志
- 验证各步骤的前置条件
- 检查最终对象的完整性
14. 建造者模式代码重构案例
重构前（构造器爆炸）：
java复制public class NutritionFacts {
public NutritionFacts(int servingSize, int servings) {...}
public NutritionFacts(int servingSize, int servings, int calories) {...}
// 更多构造器...
}
重构后（使用建造者模式）：
java复制public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
public static class Builder {
// 必选参数
private final int servingSize;
private final int servings;
// 可选参数
private int calories = 0;
public Builder(int servingSize, int servings) {
this.servingSize = servingSize;
this.servings = servings;
}
public Builder calories(int val) {
calories = val;
return this;
}
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
}
15. 建造者模式与DSL
建造者模式可以用于创建领域特定语言(DSL)。例如构建SQL查询：
java复制Query query = new QueryBuilder()
.select("name", "age")
.from("users")
.where("age > 25")
.orderBy("name")
.build();
这种流畅接口的实现关键点：
- 每个方法都返回Builder本身
- 方法命名符合领域术语
- 最终build()方法执行验证和构建
16. 建造者模式线程安全实现
在多线程环境下使用建造者模式需要注意：
- Builder本身通常不是线程安全的
- 如果需要在多线程间共享Builder，可以考虑：
- 为每个线程创建独立的Builder
- 使用ThreadLocal存储Builder
- 对Builder方法加同步锁
线程安全建造者示例：
java复制public class ThreadSafeBuilder {
private final Object lock = new Object();
private String value;
public ThreadSafeBuilder setValue(String value) {
synchronized (lock) {
this.value = value;
return this;
}
}
public String build() {
synchronized (lock) {
return value;
}
}
}
17. 建造者模式与继承
当建造者模式遇到继承关系时，可以采用"递归泛型"技巧：
java复制class BaseBuilder<T extends BaseBuilder<T>> {
protected String baseField;
public T baseField(String value) {
this.baseField = value;
return self();
}
@SuppressWarnings("unchecked")
protected T self() {
return (T)this;
}
}
class ChildBuilder extends BaseBuilder<ChildBuilder> {
private String childField;
public ChildBuilder childField(String value) {
this.childField = value;
return this;
}
}
18. 建造者模式与参数校验
在build()方法中进行集中校验：
java复制public User build() {
if (username == null) {
throw new IllegalStateException("用户名不能为空");
}
if (password.length() < 8) {
throw new IllegalStateException("密码至少8位");
}
return new User(this);
}
也可以使用Validation API：
java复制public User build() {
User user = new User(this);
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
Set<ConstraintViolation<User>> violations = validator.validate(user);
if (!violations.isEmpty()) {
throw new ConstraintViolationException(violations);
}
return user;
}
19. 建造者模式与测试数据构建
在单元测试中，建造者模式可以简化测试数据准备：
java复制public class TestDataBuilder {
public static UserBuilder validUser() {
return new UserBuilder()
.username("testuser")
.password("secure123")
.email("test@example.com");
}
public static UserBuilder adminUser() {
return validUser().role("ADMIN");
}
}
// 测试中使用
User testUser = TestDataBuilder.validUser().build();
User admin = TestDataBuilder.adminUser().build();
20. 建造者模式性能优化进阶
对于高性能场景，可以考虑：
- 对象池+建造者模式组合
- 重用Builder实例
- 使用原生类型避免装箱拆箱
优化示例：
java复制public class HighPerfBuilder {
private int[] values = new int[10];
private int index = 0;
public HighPerfBuilder add(int value) {
if (index >= values.length) {
throw new IllegalStateException("Exceed capacity");
}
values[index++] = value;
return this;
}
public int[] build() {
int[] result = new int[index];
System.arraycopy(values, 0, result, 0, index);
return result;
}
}
21. 建造者模式与文档生成
建造者模式可以自动生成文档：
java复制public class DocumentedBuilder {
private final List<String> steps = new ArrayList<>();
public DocumentedBuilder step1() {
steps.add("执行步骤1");
return this;
}
public String getDocumentation() {
return String.join("\n", steps);
}
}
22. 建造者模式与缓存结合
缓存常用配置的建造结果：
java复制public class CachedBuilder {
private static final Map<String, Product> cache = new ConcurrentHashMap<>();
public Product build(String config) {
return cache.computeIfAbsent(config, k -> {
// 实际构建过程
return new Product.Builder()
.applyConfig(config)
.build();
});
}
}
23. 建造者模式与函数式编程
Java 8之后，建造者模式可以与函数式编程结合：
java复制public class FunctionalBuilder {
private final List<Consumer<Product>> operations = new ArrayList<>();
public FunctionalBuilder with(Consumer<Product> operation) {
operations.add(operation);
return this;
}
public Product build() {
Product product = new Product();
operations.forEach(op -> op.accept(product));
return product;
}
}
// 使用方式
Product p = new FunctionalBuilder()
.with(p -> p.setName("Phone"))
.with(p -> p.setPrice(599.99))
.build();
24. 建造者模式与Spring配置
在Spring配置中使用建造者模式：
java复制@Bean
public DataSource dataSource() {
return DataSourceBuilder.create()
.url("jdbc:mysql://localhost:3306/mydb")
.username("user")
.password("pass")
.build();
}
25. 建造者模式与Mock测试
使用建造者模式创建测试Mock：
java复制public class MockUserBuilder {
private String username = "default";
private String role = "USER";
public MockUserBuilder withUsername(String username) {
this.username = username;
return this;
}
public User buildMock() {
User mock = Mockito.mock(User.class);
Mockito.when(mock.getUsername()).thenReturn(username);
Mockito.when(mock.getRole()).thenReturn(role);
return mock;
}
}
26. 建造者模式与参数默认值
设置合理的默认值可以减少调用方的负担：
java复制public class SmartBuilder {
private String host = "localhost";
private int port = 8080;
private int timeout = 5000;
public SmartBuilder withHost(String host) {
this.host = host;
return this;
}
// 其他参数设置方法
public Connection build() {
return new Connection(host, port, timeout);
}
}
27. 建造者模式与组合模式
建造者模式可以用于构建组合对象：
java复制public class MenuBuilder {
private List<MenuItem> items = new ArrayList<>();
public MenuBuilder addItem(String name, double price) {
items.add(new MenuItem(name, price));
return this;
}
public Menu build() {
return new Menu(items);
}
}
28. 建造者模式与模板方法模式
结合模板方法定义构建流程：
java复制public abstract class ReportBuilder {
public final Report buildReport() {
Report report = new Report();
buildHeader(report);
buildBody(report);
buildFooter(report);
return report;
}
protected abstract void buildHeader(Report report);
protected abstract void buildBody(Report report);
protected abstract void buildFooter(Report report);
}
29. 建造者模式与命令模式
将建造步骤封装为命令对象：
java复制public interface BuildCommand {
void execute(Product product);
}
public class ColorCommand implements BuildCommand {
private String color;
public ColorCommand(String color) {
this.color = color;
}
public void execute(Product product) {
product.setColor(color);
}
}
public class CommandBuilder {
private List<BuildCommand> commands = new ArrayList<>();
public CommandBuilder addCommand(BuildCommand command) {
commands.add(command);
return this;
}
public Product build() {
Product product = new Product();
commands.forEach(cmd -> cmd.execute(product));
return product;
}
}
30. 建造者模式实际项目经验
在我参与的一个电商平台项目中，订单构建系统使用了建造者模式，带来了以下好处：
- 订单创建流程标准化
- 支持不同业务场景的订单变体
- 参数校验集中化
- 构建逻辑与业务逻辑解耦
典型订单构建代码：
java复制Order order = new OrderBuilder()
.withCustomer(customer)
.withItems(cartItems)
.withShipping(ShippingMethod.EXPRESS)
.withDiscount(coupon)
.build();
遇到的坑与解决方案：
- 问题：建造者线程安全问题
解决：为每个请求创建新的Builder实例 - 问题：构建过程性能瓶颈
解决：缓存常用配置的建造结果 - 问题：参数依赖复杂
解决：引入验证器模式分离校验逻辑
建造者模式在这个项目中成功支持了日均百万级订单的构建，通过良好的设计，系统保持了良好的扩展性和可维护性。