结合具有不同参数或不同参数数量的消费者

Question

假设我们的方法接收输入字符串并返回一些列表输出。此输出是一些生成器的结果，其中一些依赖于输入，而另一些则不依赖于输入——它们只是添加预定义的值。 我想像一些函数接口（例如消费者）的列表一样实现这些生成器，然后将它们组合成一个消费者并将其应用于输入字符串。

所以，我将能够轻松独立地更换小型发电机。但问题是，并不是我所有的生成器都需要 input String 作为参数，我只是将这个参数传递给那里，原因只有一个 - 能够将这些消费者与其他消费者结合起来。

public class ConsumersTest {

private static <T, U> BiConsumer<T, U> combine(List<BiConsumer<T, U>> consumers) {
    return consumers.stream().reduce((arg1, arg2) -> {}, BiConsumer::andThen);
}

List<String> generate(String input) {
    ArrayList<String> output = new ArrayList<>();
    combine(getGenerators()).accept(input, output);
    return output;
}

private List<BiConsumer<String, List<String>>> getGenerators() {
    return Arrays.asList(
            this::addFirstDependent,
            this::addSecondIndependent
    );
}

private void addFirstDependent(String input, List<String> output) {
    if (input.contains("some string")) {
        output.add("First-Dependent");
    }
}

private void addSecondIndependent(String input, List<String> output) {
    output.add("Predefined Output");
}}

是否可以将不同的消费者组合在一个保护伞下并将它们应用到一个地方？或者这是一个坏主意，而不是做这些事情的正确方法？

Answer 1

在模块化软件和适配器中具有通用接口以使特定实现适合，这并不是一种不寻常的模式。例如

public class ConsumersTest {

    List<String> generate(String input) {
        ArrayList<String> output = new ArrayList<>();
        generators.accept(input, output);
        return output;
    }

    private static <T, U> BiConsumer<T, U> ignoreFirstArg(Consumer<U> consumer) {
        return (t, u) -> consumer.accept(u);
    }

    private final BiConsumer<String, List<String>> generators =
        Stream.<BiConsumer<String, List<String>>>of(
                this::addFirstDependent,
                ignoreFirstArg(this::addSecondIndependent)
        ).reduce(BiConsumer::andThen).orElse((arg1, arg2) -> {});

    private void addFirstDependent(String input, List<String> output) {
        if (input.contains("some string")) {
            output.add("First-Dependent");
        }
    }

    private void addSecondIndependent(List<String> output) {
        output.add("Predefined Output");
    }
}

所以ignoreFirstArg 是没有第一个参数的方法的通用适配器。可以有任意数量的适配器方法。但请注意，如果适配器非常具体，因此只使用一次，也可以在组合代码中编写 lambda 表达式而不是方法引用。请注意，我更改了该代码，以便不会为每个 generate(String input) 调用重复评估，否则，当您不重用组合函数时，将它们组合起来是没有意义的，因为您也可以使用

List<String> generate(String input) {
    ArrayList<String> output = new ArrayList<>();
    Stream.<BiConsumer<String, List<String>>>of(
            this::addFirstDependent,
            ignoreFirstArg(this::addSecondIndependent)
    ).forEach(g -> g.accept(input, output));
    return output;
}

甚至更简单

List<String> generate(String input) {
    ArrayList<String> output = new ArrayList<>();

    this.addFirstDependent(input, output);
    this.addSecondIndependent(output);

    return output;
}

这并不比功能代码更难维护，但每个生成器都由一行组成。