risposta-alla-domanda-sullo-sviluppo-web-bd.com

Implementazione del modello di progettazione della pipeline

Questa è una domanda di progettazione riguardante l'implementazione di una pipeline. Quanto segue è la mia ingenua implementazione.

Interfaccia per singole fasi/fasi nella pipeline:

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

Implementazioni concrete di passaggi/fasi nella pipeline:

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

La classe pipeline terrà/registrerà i passaggi nella pipeline e li eseguirà uno dopo l'altro:

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

Programma Diver per eseguire la pipeline:

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

Tuttavia, come puoi vedere, l'implementazione ingenua ha molte limitazioni. 

Uno dei principali è che, poiché il requisito è che l'output di ogni passaggio possa essere di qualsiasi tipo, l'implementazione ingenua non è sicura dal tipo (il metodo di esecuzione nella classe Pipeline). Se mi capita di collegare i passaggi nella pipeline in modo errato, l'app non funzionerà.

Qualcuno può aiutarmi a progettare la soluzione aggiungendo a ciò che ho codificato o indicarmi un modello già esistente per risolvere questo problema?

16

Mi concentrerei su

Se mi capita di collegare i passaggi nella pipeline in modo errato, l'app non funzionerà.

Sì, questo è un problema. StepThree è lo straniero qui. Non credo che uno schema semplice possa essere d'aiuto, penso che debba essere una combinazione di strategia e schema di costruzione. Per esempio:

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

Whereat Pipeline è così:

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

Usando la sintassi del builder veloce questo potrebbe funzionare:

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

Questo dovrebbe funzionare poiché i generici non fanno parte del bytecode.

8
Peter Rader

perché hai bisogno di una classe aggiuntiva Pipeline? Penso che tu possa rimuovere l'uomo medio. questo renderà la tua API semplice, ad esempio:

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;

puoi implementare il tuo modello di pipeline semplicemente in Java-8 come di seguito:

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

nella precedente versione di Java è possibile invece utilizzare una classe astratta:

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;
    }
}
10
holi-java

Il tuo approccio è abbastanza buono. Tuttavia, codificherei la classe Pipeline in questo modo:

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

In questo modo, tutta la conoscenza specifica del passaggio è incapsulata nella classe Pipeline.

In questo caso, il metodo execute può eseguire un ciclo. Tuttavia, la classe execute può eseguire i passaggi uno per uno, se necessario.

5
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