java - 如何在 Java 8 中实现构建器模式？

Question

在 Java 8 之前实现构建器模式有很多乏味、几乎重复的代码；构建器本身通常是样板代码。一些 duplicate code detectors几乎将 Java 8 之前的构建器的每个方法都视为所有其他方法的副本。

考虑以下 Java 8 之前的构建器模式:

public class Person {

    private String name;
    private int age;

    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 class PersonBuilder {
    
    private static class PersonState {
        public String name;
        public int age;
    }
    
    private PersonState  state = new PersonState();
    
    public PersonBuilder withName(String name) {
        state.name = name;
        return this;
    }
    
    public PersonBuilder withAge(int age) {
        state.age = age;
        return this;
    }
    
    public Person build() {
        Person person = new Person();
        person.setAge(state.age);
        person.setName(state.name);
        state = new PersonState();
        return person;
    }
}

如何使用 Java 8 实现构建器模式？

Answer 1

GenericBuilder

构建可变对象(不可变对象(immutable对象)将在后面讨论)的想法是对应该构建的实例的 setter 使用方法引用。这将我们引向一个通用构建器，它能够使用默认构造器构建每个 POJO - 一个构建器来统治它们;-)

实现是这样的:

public class GenericBuilder<T> {

    private final Supplier<T> instantiator;

    private List<Consumer<T>> instanceModifiers = new ArrayList<>();

    public GenericBuilder(Supplier<T> instantiator) {
        this.instantiator = instantiator;
    }

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

    public <U> GenericBuilder<T> with(BiConsumer<T, U> consumer, U value) {
        Consumer<T> c = instance -> consumer.accept(instance, value);
        instanceModifiers.add(c);
        return this;
    }

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

构建器由创建新实例的供应商构成，然后通过 with 方法指定的修改来修改这些实例。

GenericBuilder 将用于 Person，如下所示:

Person value = GenericBuilder.of(Person::new)
            .with(Person::setName, "Otto").with(Person::setAge, 5).build();

属性和进一步的用法

但是还有更多关于该构建器的发现。

例如，上面的实现清除了修饰符。这可以移动到它自己的方法中。因此，构建器将在修改之间保持其状态，并且很容易创建多个相等的实例。或者，根据 instanceModifier 的性质，不同对象的列表。例如，instanceModifier 可以从递增的计数器中读取其值。

继续这个想法，我们可以实现一个 fork 方法，该方法将返回调用它的 GenericBuilder 实例的新克隆。这很容易实现，因为构建器的状态只是 instantiator 和 instanceModifiers 列表。从那时起，两个构建器都可以用其他一些 instanceModifiers 进行更改。它们将共享相同的基础，并在构建的实例上设置一些额外的状态。

最后一点我认为在企业应用程序中需要大量实体进行单元测试甚至集成测试时特别有用。实体没有上帝对象，而是 builder 。

GenericBuilder 也可以替代需要不同的测试值工厂。在我当前的项目中，有许多工厂用于创建测试实例。代码与不同的测试场景紧密耦合，很难提取测试工厂的一部分以便在稍微不同的场景中在另一个测试工厂中重用。使用 GenericBuilder，重用它变得更加容易，因为只有一个特定的 instanceModifiers 列表。

为了验证创建的实例是否有效，GenericBuilder 可以使用一组谓词进行初始化，这些谓词在所有 instanceModifiers< 之后在 build 方法中进行验证 正在运行。

public T build() {
    T value = instantiator.get();
    instanceModifiers.forEach(modifier -> modifier.accept(value));
    verifyPredicates(value);
    instanceModifiers.clear();
    return value;
}

private void verifyPredicates(T value) {
    List<Predicate<T>> violated = predicates.stream()
            .filter(e -> !e.test(value)).collect(Collectors.toList());
    if (!violated.isEmpty()) {
        throw new IllegalStateException(value.toString()
                + " violates predicates " + violated);
    }
}

不可变对象(immutable对象)创建

要使用上述方案创建不可变对象(immutable对象)，将不可变对象(immutable对象)的状态提取为可变对象，并使用实例化器和构建器对可变状态对象进行操作。然后，添加一个函数，该函数将为可变状态创建一个新的不可变实例。但是，这要求不可变对象(immutable对象)要么像这样封装其状态，要么以这种方式更改它(基本上将参数对象模式应用于其构造函数)。

这在某种程度上不同于 pre-java-8 时代使用的构建器。在那里，构建器本身就是最后创建一个新实例的可变对象。现在，我们将构建器保存在可变对象中的状态与构建器功能本身分开。

本质上
停止编写样板构建器模式并使用 GenericBuilder 提高工作效率。