The pattern chains the receiving objects together, and then passes any request messages from object to object until it reaches an object capable of handling the message. The number and type of handler objects isn't known a priori, they can be configured dynamically. The chaining mechanism uses recursive composition to allow an unlimited number of handlers to be linked.
Chain of Responsibility simplifies object interconnections. Instead of senders and receivers maintaining references to all candidate receivers, each sender keeps a single reference to the head of the chain, and each receiver keeps a single reference to its immediate successor in the chain.
Make sure there exists a "safety net" to "catch" any requests which go unhandled.
Do not use Chain of Responsibility when each request is only handled by one handler, or, when the client object knows which service object should handle the request.
Multiple handlers could contribute to the handling of each request. The request can be passed down the entire length of the chain, with the last link being careful not to delegate to a "null next".
| Before | After | |
|---|---|---|
// Before - the client is responsible for stepping
// through the "list" of Handler objects, and deter-
// mining when the request has been handled.
//
// After - the client submits each request to the
// "chain" abstraction and is decoupled from all sub-
// sequent processing.
class Handler {
private static java.util.Random s_rn =
new java.util.Random();
private static int s_next = 1;
private int m_id = s_next++;
public boolean handle( int num ) {
if (s_rn.nextInt(4) != 0) {
System.out.print( m_id + "-busy " );
return false;
}
System.out.println( m_id + "-handled-" + num );
return true;
} }
public class ChainDemo {
public static void main( String[] args ) {
Handler[] nodes = { new Handler(), new Handler(),
new Handler(), new Handler() };
for (int i=1, j; i < 10; i++) {
j = 0;
while ( ! nodes[j].handle( i ))
j = (j+1) % nodes.length;
} } }
// 1-busy 2-busy 3-busy 4-busy 1-busy 2-handled-1
// 1-busy 2-busy 3-handled-2
// 1-busy 2-busy 3-busy 4-handled-3
// 1-busy 2-busy 3-busy 4-busy 1-busy 2-busy
// 3-handled-4
// 1-busy 2-busy 3-handled-5
// 1-handled-6
// 1-busy 2-handled-7
// 1-busy 2-busy 3-busy 4-busy 1-busy 2-busy
// 3-busy 4-handled-8
// 1-busy 2-handled-9
|
class Handler {
private static java.util.Random s_rn =
new java.util.Random();
private static int s_next = 1;
private int m_id = s_next++;
private Handler m_next;
public void add( Handler next ) {
if (m_next == null)
m_next = next;
else
m_next.add( next );
}
public void wrap_around( Handler root ) {
if (m_next == null)
m_next = root;
else
m_next.wrap_around( root );
}
public void handle( int num ) {
if (s_rn.nextInt(4) != 0) {
System.out.print( m_id + "-busy " );
m_next.handle( num );
} else
System.out.println( m_id + "-handled-" + num );
} }
public class ChainDemo {
public static void main( String[] args ) {
Handler chain_root = new Handler();
chain_root.add( new Handler() );
chain_root.add( new Handler() );
chain_root.add( new Handler() );
chain_root.wrap_around( chain );
for (int i=1; i < 10; i++)
chain_root.handle( i );
} }
// 1-busy 2-busy 3-handled-1
// 1-busy 2-busy 3-busy 4-busy 1-handled-2
// 1-busy 2-busy 3-busy 4-busy 1-busy 2-busy
// 3-busy 4-busy 1-handled-3
// 1-busy 2-handled-4
// 1-busy 2-busy 3-busy 4-handled-5
// 1-busy 2-busy 3-busy 4-busy 1-busy 2-handled-6
// 1-busy 2-handled-7
// 1-handled-8
// 1-busy 2-busy 3-handled-9
|
Chain of Responsibility can use Command to represent requests as objects. [GoF, p349]
Chain of Responsibility is often applied in conjunction with Composite. There, a component's parent can act as its successor. [GoF, p232]