管道设计模式的实现

Question

这是关于管道实施的设计问题。以下是我的幼稚实现。

管道中各个步骤/阶段的接口：

public interface Step<T, U> {
    public U execute(T input);
}

管道中的步骤/阶段的具体实现：

public class StepOne implements Step<Integer, Integer> {
    @Override
    public Integer execute(Integer input) {
        return input + 100;
    }
}

public class StepTwo implements Step<Integer, Integer> {
    @Override
    public Integer execute(Integer input) {
        return input + 500;
    }
}

public class StepThree implements Step<Integer, String> {
    @Override
    public String execute(Integer input) {
        return "The final amount is " + input;
    }
}

管道类将保存/注册管道中的步骤，并一个接一个地执行它们：

public class Pipeline {
    private List<Step> pipelineSteps = new ArrayList<>();
    private Object firstStepInput = 100;

    public void addStep(Step step) {
        pipelineSteps.add(step);
    }

    public void execute() {
        for (Step step : pipelineSteps) {
            Object out = step.execute(firstStepInput);
            firstStepInput = out;
        }
   }
}

Diver程序执行管道：

public class Main {
    public static void main(String[] args) {
        Pipeline pipeline = new Pipeline();
        pipeline.addStep(new StepOne());
        pipeline.addStep(new StepTwo());
        pipeline.addStep(new StepThree());

        pipeline.execute();
    } 
}

但是，您可以看到，幼稚的实现有很多限制。

主要要求之一是，由于要求每个步骤的输出可以是任何类型，因此朴素的实现不是类型安全的（Pipeline类中的execute方法）。如果我碰巧错误地连接了管道中的步骤，则该应用程序将失败。

谁能通过添加已编码的内容来帮助我设计解决方案，或者将我指向已经存在的模式来解决此问题？

Answer 1

我会专注于

如果我碰巧错误地连接了管道中的步骤，则该应用程序将失败。

是的，这是一个问题。StepThree是这里的陌生人。我认为没有一种简单的模式可能会有所帮助，但我确实认为它必须是策略和构建器模式的组合。例如：

Pipeline<Integer,Integer> intPipe = new Pipeline<>();
intPipe = intPipe.add(new StepOne()); // increment 100
intPipe = intPipe.add(new StepTwo()); // increment 500
Pipeline<String, Integer> strPipe = intPipe.add(new StepThree()); // convert

管道是这样的：

public static class Pipeline<IN, OUT> {
   //...
   public<A> Pipeline<OUT,A> add(Step<IN,A> step) {
     pipelineSteps.add(step);
     return (Pipeline<OUT,A>)this;
   }
}

使用快速生成器语法可以正常工作：

Pipeline<String, Integer> pipe = new Pipeline<Integer, Integer>()
    .add(new StepOne()).add(new StepTwo()).add(new StepThree());

这应该起作用，因为泛型不是字节码的一部分。