Внедрение схемы проектирования трубопровода

Это вопрос дизайна, связанный с реализацией Pipeline. Ниже приведена моя наивная реализация.

Интерфейс для отдельных шагов/этапов в конвейере:

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

Однако, как вы видите, наивная реализация имеет множество ограничений.

Один из основных заключается в том, что, поскольку требование состоит в том, что вывод каждого шага может быть любого типа, наивная реализация не безопасна для типов (метод execute в классе Pipeline). Если произойдет неправильное подключение шагов в конвейере, приложение не будет выполнено.

Может ли кто-нибудь помочь мне разработать решение, добавив к тому, что я закодировал, или указать мне на уже существующий шаблон, чтобы решить эту проблему?

Ответы

Ответ 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;
   }
}

Использование синтаксиса fast-builder может работать:

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

Это должно работать, поскольку generics не являются частью байт-кода.

Ответ 2

Ваш подход очень хорош. Однако я бы закодировал класс 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 может выполнять цикл. Однако класс выполнения может выполнять шаги один за другим, если это необходимо.

Ответ 3

зачем вам нужен дополнительный класс 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;
    }
}

Ответ 5

Открытый класс 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());

}