web-dev-qa-db-ja.com

パイプライン設計パターンの実装

これは、パイプラインの実装に関する設計上の質問です。以下は私の素朴な実装です。

パイプラインの個々のステップ/ステージのインターフェース：

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;
        }
   }
}

パイプラインを実行するダイバープログラム：

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();
    } 
}

ただし、ご覧のとおり、単純な実装には多くの制限があります。

主要なものの1つは、各ステップの出力が任意のタイプであることが要件であるため、単純な実装はタイプセーフではないことです（Pipelineクラスのexecuteメソッド）。パイプラインのステップを誤って配線すると、アプリは失敗します。

誰も私がコーディングしたものに追加することでソリューションの設計を手伝ってくれますか、これを解決するために既存のパターンに私を向けることができますか？

javaoopdesign-patternsdesign-principles
25
Prashant Chauhan

に焦点を当てる

パイプラインのステップを誤って配線すると、アプリは失敗します。

はい、これは問題です。 StepThreeはここでは見知らぬ人です。 1つの単純なパターンが役立つとは思いません。戦略とビルダーパターンの組み合わせである必要があると思います。例：

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;
   }
}

Fast-builder-syntaxを使用すると、これが機能する場合があります。

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

ジェネリックはバイトコードの一部ではないため、これは機能するはずです。

11
Peter Rader

なぜ追加のPipelineクラスが必要なのですか？中間者を削除できると思います。これにより、APIがより簡単になります。例：

Step<Integer, String> source = Step.of(Object::toString);
Step<Integer, Integer> toHex = source.pipe(it -> Integer.parseInt(it, 16));

toHex.execute(11/*0x11*/);// return 17;

次のように、単純に Java-8 でパイプラインパターンを実装できます。

interface Step<I, O> {

    O execute(I value);

    default <R> Step<I, R> pipe(Step<O, R> source) {
        return value -> source.execute(execute(value));
    }

    static <I, O> Step<I, O> of(Step<I, O> source) {
        return source;
    }
}

以前のJavaバージョンでは、代わりに抽象クラスを使用できます。

abstract static class Step<I, O> {

    public abstract O execute(I value);

    public <R> Step<I, R> pipe(Step<O, R> source) {
        return new Step<I, R>() {
            @Override
            public R execute(I value) {
                return source.execute(Step.this.execute(value));
            }
        };
    }

    public static <I, O> Step<I, O> of(Step<I, O> source) {
        return source;
    }
}
16
holi-java

あなたのアプローチはかなり良いです。ただし、次のようにPipelineクラスをコーディングします。

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

    public Pipeline() {
        pipelineSteps.add(new StepOne());
        pipelineSteps.add(new StepTwo());
        pipelineSteps.add(new StepThree());
    }

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

    public String getResult() {
        return (String) firstStepInput;
    }
}

このようにして、特定のステップの知識はすべてPipelineクラスにカプセル化されます。

この場合、executeメソッドはループを実行できます。ただし、必要に応じて、実行クラスはステップを1つずつ実行できます。

5
Gilbert Le Blanc
public class Pipeline {

    private List<Step> pipelineSteps = new ArrayList<>();
    private Object firstStepInput = 100;

    public Pipeline() {
        pipelineSteps.add(new StepOne());
        pipelineSteps.add(new StepTwo());
        pipelineSteps.add(new StepThree());
}
0
murali

基本的には、 責任の設計パターン を使用できます

0
Vladimir Stazhilov