Implement a workchain with templatemethod pattern?

Question

I have a hierarchy of worker classes, all of which do some kind of processing to a workpiece. The idea is, that each worker does some pre processing, pushes the workpiece to the subclass and then does some postprocessing:

public void process(Workpiece wp) {
   doPreprocessing(wp);
   sub.process(wp); // this obviously doesn't work
   doPostProcessing(wp);
}

Right now I'm solving this by declaring new abstract methods:

public final void process(Workpiece wp) {
   doPreprocessing(wp);
   subProcess(wp); // this obviously doesn't work
   doPostProcessing(wp);
}

protected abstract void subProcess(Workpiece wp);

which has the obvious disadvantage that for each hierarchy-level, there is an additional, new method.

I would like to guarantee, that all pre- and post-process methods are executed even with new, user-implemented workers, which are not under my control.

How would you do that?

I don't think I follow: What is the problem with your current solution? — amit, Mar 08 '12 at 11:31
The worker chain is quite long, four framework-workers and below them an arbitrary number of user-defined workers. So I have process, subprocess, subsubprocess, subsubsubprocess... I don't think that that is a simple or elegant solution. — Jonathan, Mar 08 '12 at 12:02

score 2 · Accepted Answer · answered Mar 08 '12 at 12:09

Following the template method pattern, you would do this by designing you class such that the doPreProcessing and doPostProcessing methods are overridden in subclasses. I'm guessing you don't want to do this, because you can't be sure the subclasses will call super, and thus you can't "guarantee that all pre- and post-process methods are executed even with new, user-implemented workers."

Instead of using inheritance, you could try a design that chains worker objects together, like this:

public abstract class Worker {
    private Worker next;

    protected Worker(Worker next) {
        this.next = next;
    }

    public void process(Workpiece wp) {
        preProcess(wp);

        if (next != null)
            next.process(wp);

        postProcess(wp);
    }

    public abstract void preProcess(Workpiece wp);
    public abstract void postProcess(Workpiece wp);
}

Your classes, and user-implemented classes, instead of extending the "next" worker, create the "next" worker in their constructors:

public class MyWorker extends Worker {

    public MyWorker() {
        super(new MyOtherWorker());
    }

    public abstract void preProcess(Workpiece wp) {
        // code
    }

    public abstract void postProcess(Workpiece wp) {
        // code
    }
}

I will make process final but apart from that, you are my hero! — Jonathan, Mar 08 '12 at 12:23

Implement a workchain with templatemethod pattern?

1 Answers1