Java Chain of Responsibility

Chain of Responsibility design pattern implemented in Java.

This design pattern makes it easy to process some data (perform some operations on it) in specified order.

Without this pattern, this could have been written like this:

Data data = new Data(5, 2);

Processor processor1 = new Add5ToAProcessor();
Processor processor2 = new IfAGreaterThanBAdd5ToBProcessor();
Processor processor3 = new Add8ToBProcessor();

processor1.process(data);
processor2.process(data);
processor3.process(data);

//data was processed

With pattern it can be done like this:

Data data = new Data(5, 2);

Processor processor = new Add5ToAProcessor(new IfAGreaterThanBAdd5ToBProcessor(new Add8ToBProcessor(null)));
processor.process(data);

//data was processed

Of course you can add as many processors as you want, and all you have to do is call processor.process(data) only once.

It is also worth noting, that this pattern works really well with Template Method pattern, as shown in Processor.process(Data) and Processor.logic() in example below.

Main.java

package chain;

// ? 2019 TheFlyingKeyboard and released under MIT License
// theflyingkeyboard.net
public class Main {
    public static void main(String[] args) {
        Data data = new Data(5, 2);

        Processor processor = new Add5ToAProcessor(new IfAGreaterThanBAdd5ToBProcessor(new Add8ToBProcessor(null)));
        processor.process(data);

        System.out.println(data);
    }
}

After running the output should be:

Adding 5 to A
Adding 5 to B
Adding 8 to B
Data{a=10.0, b=15.0}

Data.java

package chain;

// ? 2019 TheFlyingKeyboard and released under MIT License
// theflyingkeyboard.net
public class Data {
    private double a;
    private double b;

    public Data(double a, double b) {
        this.a = a;
        this.b = b;
    }

    public void addToA(double value){
        a += value;
    }

    public void addToB(double value){
        b += value;
    }

    public boolean isAGreaterThanB(){
        return a > b;
    }

    @Override
    public String toString() {
        return "Data{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }
}

Processor.java

package chain;

// ? 2019 TheFlyingKeyboard and released under MIT License
// theflyingkeyboard.net
public abstract class Processor {
    protected Processor nextProcessor;

    public Processor(Processor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    public void process(Data data){
        logic(data);

        if(nextProcessor != null){
            nextProcessor.process(data);
        }
    }

    public abstract void logic(Data data);
}

Add5ToAProcessor.java

package chain;

// ? 2019 TheFlyingKeyboard and released under MIT License
// theflyingkeyboard.net
public class Add5ToAProcessor extends Processor {

    public Add5ToAProcessor(Processor nextProcessor) {
        super(nextProcessor);
    }

    @Override
    public void logic(Data data) {
        System.out.println("Adding 5 to A");
        data.addToA(5);
    }
}

Add8ToBProcessor.java

package chain;

// ? 2019 TheFlyingKeyboard and released under MIT License
// theflyingkeyboard.net
public class Add8ToBProcessor extends Processor {
    public Add8ToBProcessor(Processor nextProcessor) {
        super(nextProcessor);
    }

    @Override
    public void logic(Data data) {
        System.out.println("Adding 8 to B");
        data.addToB(8);
    }
}

IfAGreaterThanBAdd5ToBProcessor.java

package chain;

// ? 2019 TheFlyingKeyboard and released under MIT License
// theflyingkeyboard.net
public class IfAGreaterThanBAdd5ToBProcessor extends Processor {

    public IfAGreaterThanBAdd5ToBProcessor(Processor nextProcessor) {
        super(nextProcessor);
    }

    @Override
    public void logic(Data data) {
        if(data.isAGreaterThanB()){
            System.out.println("Adding 5 to B");
            data.addToB(5);
        }
    }
}