管道可以处理任何类型的输入和输出。
不可变管道
让我们创建一个不可变的管道的例子。从管道接口开始:
public interface Pipe {
OUT process(IN input);
}
这是一个非常简单的接口,只有一个方法,它接受输入并产生输出。接口是参数化的,我们可以在其中提供任何实现。
现在,让我们创建一个管道类:
public class Pipeline {
private Collection> pipes;
private Pipeline(Pipe pipe) {
pipes = Collections.singletonList(pipe);
}
private Pipeline(Collection> pipes) {
this.pipes = new ArrayList<>(pipes);
}
public static Pipeline of(Pipe pipe) {
return new Pipeline<>(pipe);
}
public Pipeline withNextPipe(Pipe pipe) {
final ArrayList> newPipes = new ArrayList<>(pipes);
newPipes.add(pipe);
return new Pipeline<>(newPipes);
}
public OUT process(IN input) {
Object output = input;
for (final Pipe pipe : pipes) {
output = pipe.process(output);
}
return (OUT) output;
}
}
因为我们需要一个类型安全级别,并且不允许使管道失效,所以在添加新管道时,将产生一个新的独立管道。
简单管道
我们可以稍微简化上面的例子,并完全去掉Pipeline类:
public interface Pipe {
OUT process(IN input);
default Pipe add(Pipe pipe) {
return input -> pipe.process(process(input));
}
}
与以前使用管道的实现相比,此解决方案非常简单和灵活。
改进
我们可以用现有的Function接口替代它:
public interface Function {
//...
R apply(T t);
//...
}
此外,Function接口包含两个有用的方法,其中一个是andThen:
default Function andThen(Function super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
我们可以使用它来代替以前的add方法。此外,Function接口提供了一种在管道开始时添加函数的方法:
default Function compose(Function super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
通过使用Function,我们可以创建非常灵活和易于使用的管道:
@Test
void whenCombiningThreeFunctions_andInitializingPipeline_thenResultIsCorrect() {
Function square = s -> s * s;
Function half = s -> s / 2;
Function toString = Object::toString;
Function pipeline = square.andThen(half)
.andThen(toString);
String result = pipeline.apply(5);
String expected = "12";
assertEquals(expected, result);
}
我们可以使用BiFunctions扩展管道:
@Test
void whenCombiningFunctionAndBiFunctions_andInitializingPipeline_thenResultIsCorrect() {
BiFunction add = Integer::sum;
BiFunction mul = (a, b) -> a * b;
Function toString = Object::toString;
BiFunction pipeline = add.andThen(a -> mul.apply(a, 2))
.andThen(toString);
String result = pipeline.apply(1, 2);
String expected = "6";
assertEquals(expected, result);
}
因为andThen方法采用Function,所以我们必须将mul BiFunction转换为一个Function。
结论
Pipeline模式适用于流式递归传递输入和处理后的输出,对于比较简单的场景,使用Java函数接口是挺不错的选项。