Java 建造者Builder

实体类：

public class Student {

    private String name ;

    private int age ;

    private Boolean gender;

    private String address;

    private BigDecimal money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Boolean getGender() {
        return gender;
    }

    public void setGender(Boolean gender) {
        this.gender = gender;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public BigDecimal getMoney() {
        return money;
    }

    public void setMoney(BigDecimal money) {
        this.money = money;
    }
}

 

普通创建对象的方式：如果字段过多，写着麻烦，代码也不美观

public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("Lucy");
        stu.setAge(18);
        stu.setGender(false);
        stu.setAddress("北京大道16号");
        stu.setMoney(new BigDecimal(1000));
    }

 

 

 使用Java 建造者Builder，适用于所有类，不需要改造原来类，不需要引入lombok依赖也可以实现创建对象时链式操作。

 

public class Builder<T> {

    private final Supplier<T> instantiator;
    private List<Consumer<T>> setterList = new ArrayList<>();

    private Builder(Supplier<T> instantiator) {
        this.instantiator = instantiator;
    }

    public static <T> Builder<T> of(Supplier<T> instantiator) {
        return new BuilderEntity<>(instantiator);
    }

    public <P> Builder<T> with(IOneParamSetter<T, P> setter, P p) {
        Consumer<T> c = instance -> setter.accept(instance, p);
        setterList.add(c);
        return this;
    }

    public <P0, P1> Builder<T> with(ITwoParamSetter<T, P0, P1> setter, P0 p0, P1 p1) {
        Consumer<T> c = instance -> setter.accept(instance, p0, p1);
        setterList.add(c);
        return this;
    }

    public T build() {
        T value = instantiator.get();
        setterList.forEach(setter -> setter.accept(value));
        setterList.clear();
        return value;
    }

    @FunctionalInterface
    public interface IOneParamSetter<T, P> {
        void accept(T t, P p);
    }

    @FunctionalInterface
    public interface ITwoParamSetter<T, P0, P1> {
        void accept(T t, P0 p0, P1 p1);
    }

}

使用示例：

public static void main(String[] args) {
        Student stu = 
            Builder.of(Student::new)
            .with(Student::setAddress,"北京大道16号")
            .with(Student::setAge,18)
            .with(Student::setGender,false)
            .with(Student::setMoney,new BigDecimal(100))
            .with(Student::setName,"Lucy")
            .build();
    }