Home » Java » Core Java » Chain of Responsibility Pattern in Java

About Cagdas Basaraner

Cagdas Basaraner
Cagdas Basaraner is a software engineer graduated from Hacettepe University Computer Engineering department (Turkey), having 5 years professional experience. He is working on JEE web technologies, and also a former developer of information systems using Microsoft technologies and Command & Control (C4I) systems with Java technologies.

Chain of Responsibility Pattern in Java

Chain of Responsibility design pattern is needed when a few processors should exist for performing an operation and a particular order should be defined for those processors. Also the changeability of the order of processors on runtime are important.UML represantation of the pattern is as below:

Handler defines the general structure of processor objects. ‘HandleRequest’ here is the abstract processor method. Handler also has a reference of its own type, which represents the next handler. For this a public ‘setNextHandler’ method should be defined and exactly the handler is an abstract class. ConcreteHandler define different representations of processors. At last, Client is responsible with creating required handlers (processors) and define a chain order between them.
Generally two diffent implementation may exist for this pattern. Difference is related with the ‘location of the chain routing business logic’. Chain routing business logic may be either in Handler abstract class or ConcreteHandler classes, or both of them. Sample of first two approaches will be given below:

1. ‘Handler’ has chain routing business logic:

public abstract class Processor {
    protected Processor next;
    protected int threshold;
    public void setNextProcessor(Processor p) {
        next = p;
    }
    public void process(String data, int value) {
        if (value <= threshold) {
            process(data);
        }
        if (next != null) {
            next.message(data, threshold);
        }
    }
    abstract protected void processData(String data);
}
public class ProcessorA extends Processor {

    public ProcessorA (int threshold) {
        this.threshold = threshold;
    }
    protected void processData(String data) {
        System.out.println("Processing with A: " + data);
    }
}
public class ProcessorB extends Processor {

    public ProcessorB (int threshold) {
        this.threshold = threshold;
    }
    protected void writeMessage(String data) {
        System.err.println("Processing with B: " + data);
    }
}
public class Client {
    public static void main(String[] args) {
        Processor p, p1, p2;
        p1 = p = new ProcessorA(2);
        p2 = new ProcessorB(1);
        p1.setNextProcessor(p2);
        // Handled by ProcessorA
        p.process("data1", 2);
        // Handled by ProcessorA and ProcessorB
        p.process("data2", 1);
    }
}

2. ‘ConcreteHandler’s have chain routing business logic:

public abstract class Processor {
    protected Processor next;
    protected int threshold;
    public void setNextProcessor(Processor p) {
        next = p;
    }
    abstract protected void processData(String data);
}
public class ProcessorA extends Processor {

    public ProcessorA (int threshold) {
        this.threshold = threshold;
    }
    protected void processData(String data, int value) {
        System.out.println("Processing with A: " + data);
        if (value >= threshold && next != null) {
            next.processData(data, value);
        }
    }
}
public class ProcessorB extends Processor {

    public ProcessorB (int threshold) {
        this.threshold = threshold;
    }
    protected void processData(String data, int value) {
        System.out.println("Processing with B: " + data);
        if (value >= threshold && next != null) {
            next.processData(data, value);
        }
    }
}
public class Client {
    public static void main(String[] args) {
        Processor p, p1, p2;
        p1 = p = new ProcessorA(2);
        p2 = new ProcessorB(1);
        p1.setNextProcessor(p2);
        // Handled by ProcessorA
        p.processData("data1", 1);
        // Handled by ProcessorA and ProcessorB
        p.processData("data2", 2);
    }
}

Reference: 2 Implementations of “Chain of Responsibility” Pattern with Java from our JCG partner Cagdas Basaraner at the CodeBuild blog.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

 

One comment

  1. The code has many problems, a call to message(..) in Processer exists, however, the method is not defined in the code. I think the coder meant to call process(..) instead.

Leave a Reply

Your email address will not be published. Required fields are marked *

*


3 × = nine

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Do you want to know how to develop your skillset and become a ...

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!
Get ready to Rock!
To download the books, please verify your email address by following the instructions found on the email we just sent you.

THANK YOU!

Close