Last modified on 22 May 2013, at 05:58

Chain of responsibility

Proxy Computer Science Design Patterns
Chain of responsibility
Command

Various examples of the Chain of responsibility pattern.

Implementation in Java

The following Java code illustrates the pattern with the example of a logging class. Each logging handler decides if any action is to be taken at this log level and then passes the message on to the next logging handler. Note that this example should not be seen as a recommendation on how to write logging classes.

Also, note that in a 'pure' implementation of the chain of responsibility pattern, a logger would not pass responsibility further down the chain after handling a message. In this example, a message will be passed down the chain whether it is handled or not.

abstract class Logger {
 
    public static int ERR = 3;
    public static int NOTICE = 5;
    public static int DEBUG = 7;
    protected int mask;
 
    // The next element in the chain of responsibility
    protected Logger next;
 
    public Logger setNext(Logger l) {
        next = l;
        return l;
    }
 
    public void message(String msg, int priority) {
        if (priority <= mask) {
            writeMessage(msg);
        }
        if (next != null) {
            next.message(msg, priority);
        }
    }
 
    abstract protected void writeMessage(String msg);
 
}
class StdoutLogger extends Logger {
 
    public StdoutLogger(int mask) {
        this.mask = mask;
    }
 
    protected void writeMessage(String msg) {
        System.out.println("Writing to stdout: " + msg);
    }
 
}
class EmailLogger extends Logger {
 
    public EmailLogger(int mask) {
        this.mask = mask;
    }
 
    protected void writeMessage(String msg) {
        System.out.println("Sending via email: " + msg);
    }
 
}
class StderrLogger extends Logger {
 
    public StderrLogger(int mask) {
        this.mask = mask;
    }
 
    protected void writeMessage(String msg) {
        System.err.println("Sending to stderr: " + msg);
    }
 
}
public class ChainOfResponsibilityExample {
 
    public static void main(String[] args) {
        // Build the chain of responsibility
        Logger l,l1;
        l1 = l = new StdoutLogger(Logger.DEBUG);
        l1 = l1.setNext(new EmailLogger(Logger.NOTICE));
        l1 = l1.setNext(new StderrLogger(Logger.ERR));
 
        // Handled by StdoutLogger
        l.message("Entering function y.", Logger.DEBUG);
 
        // Handled by StdoutLogger and EmailLogger
        l.message("Step1 completed.", Logger.NOTICE);
 
        // Handled by all three loggers
        l.message("An error has occurred.", Logger.ERR);
    }
 
}

The output is:

  Writing to stdout:   Entering function y.
  Writing to stdout:   Step1 completed.
  Sending via e-mail:  Step1 completed.
  Writing to stdout:   An error has occurred.
  Sending via e-mail:  An error has occurred.
  Writing to stderr:   An error has occurred.

Below is another example of this pattern in Java. In this example we have different roles, each having a fix purchase power limit and a successor. Every time a user in a role receives a purchase request, when it's over his limit, he just passes that request to his successor.

The PurchasePower abstract class with the abstract method processRequest.

abstract class PurchasePower {
 
    protected final double base = 500;
    protected PurchasePower successor;
 
    public void setSuccessor(PurchasePower successor) {
        this.successor = successor;
    }
 
    abstract public void processRequest(PurchaseRequest request);
 
}

Four implementations of the abstract class above: Manager, Director, Vice President, President

class ManagerPPower extends PurchasePower {
 
    private final double ALLOWABLE = 10 * base;
 
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount() < ALLOWABLE) {
            System.out.println("Manager will approve $"+ request.getAmount());
        }
        else if(successor != null) {
            successor.processRequest(request);
        }
    }
 
}
class DirectorPPower extends PurchasePower {
 
    private final double ALLOWABLE = 20 * base;
 
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount() < ALLOWABLE) {
            System.out.println("Director will approve $"+ request.getAmount());
        }
        else if(successor != null) {
            successor.processRequest(request);
        }
    }
 
}
class VicePresidentPPower extends PurchasePower {
 
    private final double ALLOWABLE = 40 * base;
 
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount() < ALLOWABLE) {
            System.out.println("Vice President will approve $" + request.getAmount());
        }
        else if(successor != null) {
            successor.processRequest(request);
        }
    }
}
class PresidentPPower extends PurchasePower {
 
    private final double ALLOWABLE = 60 * base;
 
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount() < ALLOWABLE) {
            System.out.println("President will approve $" + request.getAmount());
        }
        else {
            System.out.println( "Your request for $" + request.getAmount() + " needs a board meeting!");
        }
    }
 
}

The PurchaseRequest class with its Getter methods which keeps the request data in this example.

class PurchaseRequest {
 
    private int number;
    private double amount;
    private String purpose;
 
    public PurchaseRequest(int number, double amount, String purpose) {
        this.number = number;
        this.amount = amount;
        this.purpose = purpose;
    }
 
    public double getAmount() {
        return amount;
    }
    public void setAmount(double amt)  {
        amount = amt;
    }
 
    public String getPurpose() {
        return purpose;
    }
    public void setPurpose(String reason) {
        purpose = reason;
    }
 
    public int getNumber(){
        return number;
    }
    public void setNumber(int num) {
        number = num;
    }  
 
}

And here a usage example, the successors are set like this: Manager -> Director -> Vice President -> President

class CheckAuthority {
 
    public static void main(String[] args) {
        ManagerPPower manager = new ManagerPPower();
        DirectorPPower director = new DirectorPPower();
        VicePresidentPPower vp = new VicePresidentPPower();
        PresidentPPower president = new PresidentPPower();
        manager.setSuccessor(director);
        director.setSuccessor(vp);
        vp.setSuccessor(president);
 
        //enter ctrl+c to kill.
        try{
            while (true) {
                System.out.println("Enter the amount to check who should approve your expenditure.");
                System.out.print(">");
                double d = Double.parseDouble(new BufferedReader(new InputStreamReader(System.in)).readLine());
                manager.processRequest(new PurchaseRequest(0, d, "General"));
           }
        }
        catch(Exception e){
            System.exit(1);
        }  
    }
 
}
Implementation in Python
class Car:
    def __init__(self):
        self.name = None
        self.km = 11100
        self.fuel = 5
        self.oil = 5
 
def handle_fuel(car):
    if car.fuel < 10:
        print "added fuel"
        car.fuel = 100
 
def handle_km(car):
    if car.km > 10000:
        print "made a car test."
        car.km = 0
 
def handle_oil(car):
    if car.oil < 10:
        print "Added oil"
        car.oil = 100
 
class Garage:
    def __init__(self):
        self.handlers = []
 
    def add_handler(self, handler):
        self.handlers.append(handler)
 
    def handle_car(self, car):
        for handler in self.handlers:
            handler(car)
 
if __name__ == '__main__':
    handlers = [handle_fuel, handle_km, handle_oil]
    garage = Garage()
 
    for handle in handlers:
        garage.add_handler(handle)
    garage.handle_car(Car())
Implementation in Racket
#lang racket
 
; Define an automobile structure
(struct auto (fuel km oil) #:mutable #:transparent)
 
; Create an instance of an automobile
(define the-auto (auto 5 1500 7))
 
; Define handlers
 
(define (handle-fuel auto)
  (when (< (auto-fuel auto) 10)
    (begin (set-auto-fuel! auto 10)
           (printf "set fuel\n"))))
 
(define (handle-km auto)
  (when (> (auto-km auto) 10000)
    (begin (set-auto-km! auto 0)
           (printf "made a car test\n"))))
 
(define (handle-oil auto)
  (when (< (auto-oil auto) 10)
    (begin (set-auto-oil! auto (+ (auto-oil auto) 5))
           (printf "added oil\n"))))
 
; Apply each handler to the auto
(define (handle-auto handlers auto)
  (unless (null? handlers)
    (begin ((car handlers) auto)
           (handle-auto (cdr handlers) auto))))
 
(display the-auto)
(newline)
 
; Handle the auto
(handle-auto (list handle-fuel handle-km handle-oil) the-auto)
 
(display the-auto)
(newline)
Implementation in Perl

Java example about purchase power of various roles, using perl 5.10 and Moose.

use feature ':5.10';
 
package PurchasePower;
use Moose;
 
has successor => ( is => "rw", isa => "PurchasePower" );
 
sub processRequest {
    my ( $self, $req ) = @_;
    if ( $req->amount < $self->allowable ) {
        printf "%s will approve \$%.2f\n", $self->title, $req->amount;
    }
    elsif ( $self->successor ) {
        $self->successor->processRequest($req);
    }
    else {
        $self->no_match( $req );
    }
}
 
package ManagerPPower;
use Moose; extends "PurchasePower";
sub allowable {5000}
sub title     {"manager"}
 
package DirectorPPower;
use Moose; extends "PurchasePower";
sub allowable {10000}
sub title     {"director"}
 
package VicePresidentPPower;
use Moose; extends "PurchasePower";
sub allowable {20000}
sub title     {"vice-president"}
 
package PresidentPPower;
use Moose; extends "PurchasePower";
sub allowable {30000}
sub title     {"president"}
 
sub no_match {
    my ( $self, $req ) = @_;
    printf "your request for \$%.2f will need a board meeting\n", $req->amount;
}
 
package PurchaseRequest;
use Moose;
 
has number  => ( is => "rw", isa => "Int" );
has amount  => ( is => "rw", isa => "Num" );
has purpose => ( is => "rw", isa => "Str" );
 
package main;
 
my $manager   = new ManagerPPower;
my $director  = new DirectorPPower;
my $vp        = new VicePresidentPPower;
my $president = new PresidentPPower;
 
$manager->successor($director);
$director->successor($vp);
$vp->successor($president);
 
print "Enter the amount to check who should approve your expenditure.\n>";
my $amount = readline;
$manager->processRequest(
    PurchaseRequest->new(
        number  => 0,
        amount  => $amount,
        purpose => "General"
    )
);

Perl example using perl 5.10 and Moose.

use feature ':5.10';
 
package Car;
use Moose;
 
has name => ( is => "rw", default => undef );
has km   => ( is => "rw", default => 11100 );
has fuel => ( is => "rw", default => 5 );
has oil  => ( is => "rw", default => 5 );
 
sub handle_fuel {
    my $self = shift;
    if ( $self->fuel < 10 ) {
        say "added fuel";
        $self->fuel(100);
    }
}
 
sub handle_km {
    my $self = shift;
    if ( $self->km > 10000 ) {
        say "made a car test";
        $self->km(0);
    }
}
 
sub handle_oil {
    my $self = shift;
    if ( $self->oil < 10 ) {
        say "added oil";
        $self->oil(100);
    }
}
 
package Garage;
use Moose;
 
has handler => (
    is      => "ro",
    isa     => "ArrayRef[Str]",
    traits  => ['Array'],
    handles => { add_handler => "push", handlers => "elements" },
    default => sub { [] }
);
 
sub handle_car {
    my ($self, $car) = @_;
    $car->$_ for $self->handlers
}
 
package main;
 
my @handlers = qw( handle_fuel handle_km handle_oil );
my $garage   = Garage->new;
$garage->add_handler($_) for @handlers;
$garage->handle_car( Car->new );
Implementation in C#
using System;
 
  class MainApp
  {
    static void Main()
    {
      // Setup Chain of Responsibility
      Handler h1 = new ConcreteHandler1();
      Handler h2 = new ConcreteHandler2();
      Handler h3 = new ConcreteHandler3();
      h1.SetSuccessor(h2);
      h2.SetSuccessor(h3);
 
      // Generate and process request
      int[] requests = {2, 5, 14, 22, 18, 3, 27, 20};
 
      foreach (int request in requests)
      {
        h1.HandleRequest(request);
      }
 
      // Wait for user
      Console.Read();
    }
  }
 
  // "Handler"
  abstract class Handler
  {
    protected Handler successor;
 
    public void SetSuccessor(Handler successor)
    {
      this.successor = successor;
    }
 
    public abstract void HandleRequest(int request);
  }
 
  // "ConcreteHandler1"
  class ConcreteHandler1 : Handler
  {
    public override void HandleRequest(int request)
    {
      if (request >= 0 && request < 10)
      {
        Console.WriteLine("{0} handled request {1}",
          this.GetType().Name, request);
      }
      else if (successor != null)
      {
        successor.HandleRequest(request);
      }
    }
  }
 
  // "ConcreteHandler2"
  class ConcreteHandler2 : Handler
  {
    public override void HandleRequest(int request)
    {
      if (request >= 10 && request < 20)
      {
        Console.WriteLine("{0} handled request {1}",
          this.GetType().Name, request);
      }
      else if (successor != null)
      {
        successor.HandleRequest(request);
      }
    }
  }
 
  // "ConcreteHandler3"
  class ConcreteHandler3 : Handler
  {
    public override void HandleRequest(int request)
    {
      if (request >= 20 && request < 30)
      {
        Console.WriteLine("{0} handled request {1}",
          this.GetType().Name, request);
      }
      else if (successor != null)
      {
        successor.HandleRequest(request);
      }
    }
  }


Clipboard

To do:
Add more illustrations.


Proxy Computer Science Design Patterns
Chain of responsibility
Command


You have questions about this page?
Ask it here:


Create a new page on this book: