当前位置：首页 > article >正文

到底应不应该使用@Builder

article 2025/1/20 13:40:23

大多数同学使用 @Builder 无非就是为了链式编程，然而 @Builder 并不是链式编程的最佳实践，它会额外创建内部类，存在继承关系时还需要使用 @SuperBuilder 注解，设置默认值时也需要额外的 @Builder.Default 去设置默认值，无疑增加了很多不必要的复杂度。

一、案例

@Builder 注解是 Lombok 库中的一个注解，用于简化 Java 对象的构建过程。它通过生成一个构建器模式（Builder Pattern）来创建对象，使得代码更简洁和易于维护。以下是一个使用 @Builder 注解的简单示例：

假设我们有一个 User 类：

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private String name;
    private int age;
    private String email;
}

在例子中，@Builder 注解会为 User 类生成一个静态内部类 UserBuilder，用于构建 User 对象。@ToString 注解则是为了方便输出对象信息。

使用 @Builder 注解生成的构建器来创建 User 对象：

public class Main {
    public static void main(String[] args) {
        User user = User.builder()
                        .name("John Doe")
                        .age(30)
                        .email("johndoe@example.com")
                        .build();
        
        System.out.println(user);
    }
}

在这个示例中，通过 User.builder() 方法获取一个 UserBuilder 实例，然后通过链式调用设置各个属性，最后调用 build() 方法创建 User 对象。

这种方式的优点是可以灵活地设置对象的属性，并且不需要创建多个构造函数来满足不同的初始化需求。特别是在属性较多的类中，使用 @Builder 可以显著提高代码的可读性和可维护性。

二、不足之处

@Builder 生成的构造器不是完美的，它不能区分哪些参数是必须的，哪些是可选的。如果没有提供必须的参数，构造器可能会创建出不完整或者不合法的对象。

假设我们有一个 Order 类，其中 orderId 是必须的，而 description 是可选的：

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class Order {
    private String orderId;  // 必须的参数
    private String description;  // 可选的参数
}

在使用 @Builder 构建 Order 对象时，可能会出现这样的情况：

public class Main {
    public static void main(String[] args) {
        // 忘记设置必须的 orderId
        Order order = Order.builder()
                           .description("This is an optional description")
                           .build();
        
        System.out.println(order);
    }
}

在这个示例中，由于 orderId 是一个必须的参数，但在构建 Order 对象时没有提供 orderId，导致生成的对象可能不合法或不完整。

很多人喜欢 @Builder 和 @Data 搭配使用，导致生成的构造器是可变的，它允许使用 setter 方法修改构造器的状态。这违反了构造器模式的原则，构造器应该是不可变的，一旦创建就不能被修改。

如果非要使用 @Builder ，那么不要用 @Data ，要用 @Getter。相对来说，反而 @Accessors 的行为更符合这个要求。

@Builder 生成的构造器不适合用于短暂的对象，它会增加代码的复杂度和冗余。构造器模式更适合用于生命周期较长、有多种变体的对象。

实际使用中经常发现 @Builder 滥用的情况，有些仅仅一两个属性的类也都要用 @Builder，真的没必要用，直接用全参的构造方法都比这更简洁。

@Builder 生成的构造器不能处理抽象类型的参数，它只能接受具体类型的对象。这限制了构造器的灵活性和扩展性，不能根据不同的需求创建不同风格的对象。

假设我们有一个抽象的 Vehicle 类和一个具体的 Car 类：

public abstract class Vehicle {
    private String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }
}

public class Car extends Vehicle {
    private int numberOfDoors;

    public Car(String brand, int numberOfDoors) {
        super(brand);
        this.numberOfDoors = numberOfDoors;
    }

    public int getNumberOfDoors() {
        return numberOfDoors;
    }
}

现在，我们尝试使用 @Builder 来创建一个包含 Vehicle 类型参数的 Garage 类：

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class Garage {
    private Vehicle vehicle;  // 抽象类型参数
}

在使用 @Builder 创建 Garage 对象时，我们会遇到问题，因为 Vehicle 是一个抽象类，无法直接实例化：

public class Main {
    public static void main(String[] args) {
        // 这段代码会有问题，因为 Vehicle 是抽象的，不能直接实例化
        Garage garage = Garage.builder()
                              .vehicle(new Vehicle("Generic Brand") {})  // 错误：不能实例化抽象类
                              .build();
        
        System.out.println(garage);
    }
}

解决方案：使用具体类型：在构建器中使用具体类型的对象，而不是抽象类型。例如，直接使用 Car 类

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", 4);
        Garage garage = Garage.builder()
                              .vehicle(car)
                              .build();
        
        System.out.println(garage);
    }
}

继承关系时，子类需要使用 @SuperBuilder。对象继承后，子类的 Builder 因为构造函数的问题，使用不当大概率会报错，并且无法设置父类的属性，还需要使用 @SuperBuilder 来解决问题。

假设我们有一个父类 Vehicle 和一个子类 Car，并希望通过构建器来设置它们的属性：通过 @SuperBuilder，我们可以在子类的构建器中设置父类的属性：

public class Main {
    public static void main(String[] args) {
        Car car = Car.builder()
                     .brand("Toyota")      // 设置父类的属性
                     .model("Corolla")     // 设置父类的属性
                     .numberOfDoors(4)     // 设置子类的属性
                     .build();
        
        System.out.println("Brand: " + car.getBrand());
        System.out.println("Model: " + car.getModel());
        System.out.println("Number of Doors: " + car.getNumberOfDoors());
    }
}

@SuperBuilder 注解：它是 @Builder 的增强版本，专门用于处理继承关系。使用 @SuperBuilder 可以在子类的构建器中访问和设置父类的属性。

final 关键字：在这个示例中，属性被声明为 final，确保它们在对象构建后不可变。

构建器链：@SuperBuilder 允许在子类的构建器中调用父类的构建器方法，从而设置父类的属性。

设置默认值需要使用 @Builder.Default。很容易因为对此不了解，导致默认值不符合预期导致出现 BUG。

import lombok.Builder;
import lombok.Getter;
import lombok.ToString;

@Getter
@Builder
@ToString
public class User {
    private final String username;
    private final String email;

    @Builder.Default
    private final boolean active = true;  // 默认值

    @Builder.Default
    private final int loginAttempts = 0;  // 默认值
}

public class Main {
    public static void main(String[] args) {
        // 使用构建器创建对象，并未显式设置 active 和 loginAttempts
        User user = User.builder()
                        .username("john_doe")
                        .email("john.doe@example.com")
                        .build();

        System.out.println(user);
        
        // 显式设置 active 和 loginAttempts
        User anotherUser = User.builder()
                               .username("jane_doe")
                               .email("jane.doe@example.com")
                               .active(false)
                               .loginAttempts(3)
                               .build();

        System.out.println(anotherUser);
    }
}