Design Patterns - SPLessons

Chain Of Responsibility Pattern

Chapter 26

SPLessons 5 Steps, 3 Clicks
5 Steps - 3 Clicks

Chain Of Responsibility Pattern

Chain Of Responsibility Pattern

shape Description

Chain Of Responsibilities Pattern is a Behavioral Pattern mainly used to decouple the requests. The request from the client is passed through a set of objects that decide whether to send the request to the next object or not.

Each object contains the reference of another object. If a object cannot process the request, then it is transferred to the next object and forms a chain structure. An object oriented link is formed in the pattern.

shape Advantages

  • Loose coupling can be done easily.
  • Chain of responsibilities pattern can be used as command.
  • The handler object is not revealed.
  • The request is handled automatically.
  • Each object in the chain will have its own implementation.

shape Conceptual
figure

shape Examples

Following is an example for Chain Of Responsibility Pattern, Create an interface Chain

 public interface Chain
{
public abstract void setNext(Chain nextInChain);
public abstract void process(Number request);
} 

Creating a class Value which will request the object.

public class Value
{
private int value;
public Number(int value)//reads the value
{
this.value = value;
}
public int getValue()//returns the value
{
return value;
}
}

Chain Of Responsibility Pattern – In chain series, this class is a link. Creating a class NegativeValue to implement the interface Chain

public class NegativeValue implements Chain
 {
	private Chain nextInChain;

	public void setNext(Chain c) // overrides the interface method
{
		nextInChain = c;
	}
	public void process(Value request)//overrides the interface method 
{
		if (request.getValues() < 0)
 {
			System.out.println("NegativeValue : " + request.getValue());
		} 
else 
{
			nextInChain.process(request);
		}
	}
}

Chain Of Responsibility Pattern – Creating a class ZeroValue to implement the interface Chain and this class acts as another link in the chain.

public class ZeroValue implements Chain 
{
 private Chain nextInChain;
 public void setNext(Chain c)//overrides the interface method
 {
 nextInChain = c;
 }
 public void process(Value request)//overrides the interface method
 {
 if (request.getValue() == 0) {
 System.out.println("ZeroValue : " + request.getValue());
 } 
else 
{
 nextInChain.process(request);
 }
 }
}

Creating a class PositiveProcessor to implement the interface Chain and this class acts as another link to the chain.

public class PositiveProcessor implements Chain 
{
	private Chain nextInChain;

	public void setNext(Chain c)//overrides the interface method
 {
		nextInChain = c;
	}
	public void process(Number request)//overrides the interface method
{
		if (request.getNumber() > 0) 
{
			System.out.println("PositiveProcessor : " + request.getNumber());
		}
 else {
			nextInChain.process(request);
		}
	}
}

Chain Of Responsibility Pattern – Creating a main class Chain and configuration of chain is done.

public class ChainTest 
{
	public static void main(String[] args) 
{
		//configure Chain of Responsibility
		Chain c1 = new NegativeValue();
		Chain c2 = new ZeroValue();
		Chain c3 = new PositiveValue();
		c1.setNext(c2);
		c2.setNext(c3);

		//calling chain of responsibility
		c1.process(new Value(90));
		c1.process(new Value(-40));
		c1.process(new Value(0));
		c1.process(new Value(1000));
	}
}

shape Output

The result will be as follows.

PositiveValue : 90
NegativeValue : -40
ZeroValue : 0
PositiveValue : 1000

Summary

shape Key Points

  • Decoupling of requests can be done easily.
  • Using Chain of responsibilities, request can be passed between the objects easily.
  • User will not know which process is processing the request.