builder如何构建java

使用Builder模式构建Java对象

Builder模式是一种创建型设计模式，用于构建复杂对象。它通过分离对象的构建过程和表示，使得相同的构建过程可以创建不同的表示。

定义Builder类

创建一个静态内部类作为Builder，包含与外部类相同的字段。为每个字段提供设置方法，并返回Builder实例以实现链式调用。

public class User {
    private final String firstName;
    private final String lastName;
    private final int age;
    private final String phone;
    private final String address;

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    public static class UserBuilder {
        private String firstName;
        private String lastName;
        private int age;
        private String phone;
        private String address;

        public UserBuilder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public UserBuilder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }

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

        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }

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

        public User build() {
            return new User(this);
        }
    }
}

使用Builder创建对象

通过链式调用Builder的方法设置属性，最后调用build()方法创建对象实例。

User user = new User.UserBuilder()
    .firstName("John")
    .lastName("Doe")
    .age(30)
    .phone("1234567")
    .address("123 Main St")
    .build();

验证构建参数

可以在build()方法中添加参数验证逻辑，确保构建的对象满足特定条件。

public User build() {
    if (firstName == null || lastName == null) {
        throw new IllegalStateException("First and last name are required");
    }
    if (age < 0) {
        throw new IllegalStateException("Age cannot be negative");
    }
    return new User(this);
}

使用Lombok简化Builder

如果使用Lombok库，可以通过注解自动生成Builder模式代码。

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private final String firstName;
    private final String lastName;
    private final int age;
    private final String phone;
    private final String address;
}

使用Lombok生成的Builder：

User user = User.builder()
    .firstName("John")
    .lastName("Doe")
    .age(30)
    .phone("1234567")
    .address("123 Main St")
    .build();

不可变对象与Builder

Builder模式特别适合创建不可变对象，因为所有字段都可以在构造函数中一次性设置，并且声明为final。

public class ImmutableUser {
    private final String name;
    private final String email;

    private ImmutableUser(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
    }

    public static class Builder {
        private String name;
        private String email;

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

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

        public ImmutableUser build() {
            return new ImmutableUser(this);
        }
    }
}