如何更优雅构建对象？

1. 使用 Lombok 的 @Builder 注解

Lombok 的 @Builder 是一种非常简洁且强大的工具，可以自动生成 Builder 模式的代码。它避免了手动编写大量样板代码，并且支持链式调用和不可变对象的设计。

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Person {
    private String name;
    private int age;
    private String address;
}

使用 @Builder 后，你可以通过以下方式构建对象

Person person = Person.builder()
    .name("Alice")
    .age(25)
    .address("New York")
    .build();

优点

• 减少样板代码 ：自动生成 Builder 类。
• 链式调用 ：通过方法链逐步构建对象。
• 支持不可变性 ：可以轻松创建不可变对象。

2. 使用传统的 Builder 模式

如果你不使用 Lombok，传统的方式是手动实现 Builder 类。这种方式虽然繁琐，但在需要自定义逻辑时仍然很有用。

public class Person {
    private final String name;
    private final int age;
    private final String address;

    public static class Builder {
        private String name;
        private int age;
        private String address;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public Person build() {
            return new Person(name, age, address);
        }
    }

    private Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}

优点

• 灵活性 ：可以自定义逻辑。
• 可维护性 ：适合复杂的构建逻辑。

3. 使用 Fluent（链式）API

Fluent API 是一种通过方法链逐步构建对象的设计模式。它类似于 Builder 模式，但通常用于更简单的对象构建场景。

public class Email {
    private String to;
    private String subject;
    private String body;

    public static EmailBuilder newEmail() {
        return new EmailBuilder();
    }

    private static final class EmailBuilder {
        private String to;
        private String subject;
        private String body;

        public EmailBuilder to(String to) {
            this.to = to;
            return this;
        }

        public EmailBuilder subject(String subject) {
            this.subject = subject;
            return this;
        }

        public EmailBuilder body(String body) {
            this.body = body;
            return this;
        }

        public Email build() {
            return new Email(to, subject, body);
        }
    }
}

优点

• 简洁性 ：代码直观且易于理解。
• 可读性 ：通过方法链清晰地表达构建过程。

4. 使用工厂模式

工厂模式是一种通过工厂类来构建对象的设计模式。它适用于需要多种构建逻辑或参数化的场景。

public class Pizza {
    private String name;
    private String dough;
    private String sauce;

    public static final class PizzaFactory {
        private String name;
        private String dough;
        private String sauce;

        public PizzaFactory name(String name) {
            this.name = name;
            return this;
        }

        public PizzaFactory dough(String dough) {
            this.dough = dough;
            return this;
        }

        public PizzaFactory sauce(String sauce) {
            this.sauce = sauce;
            return this;
        }

        public Pizza create() {
            return new Pizza(name, dough, sauce);
        }
    }
}

// 使用工厂模式构建对象：
Pizza pizza = new Pizza.PizzaFactory()
    .name("Margherita")
    .dough("Extra Thin")
    .sauce("Tomato")
    .create();

优点

• 灵活性 ：可以支持多种构建方式。
• 可扩展性 ：适合需要动态配置的场景。

总结

选择哪种方式取决于具体的使用场景：

1. 简单对象 ：直接使用构造函数或 Lombok 的 @Builder。
2. 复杂对象 ：使用传统的 Builder 模式或工厂模式。

无论选择哪种方式，目标都是让代码更简洁、更易维护，并且符合项目的整体架构和设计原则。