责任链模式(Chain of Responsibility Pattern)

      在彼此不了解的情况下，让多于一个对象处理请求，传递请求给责任链直到它被最终被处理完成，称这种模式为责任链模式。责任链模式是属于行为设计模式的类别之一，经典的UML类图如下所示：

   


     使用场景和优势：

 一个请求需要被不少于一个对象处理。
 不清楚到底哪个对象会处理请求，可能有多于一个对象制动化地处理它。减少耦合度。
 弹性地操作请求。
      Java Servlet 过滤框架(filter framework) 就是一个责任链设计模式。注意到chain.doFilter()是一个能够被调用去生成滚动链的方法。如果此类丢弃了它，整个链会停止或者阻塞。
      Java异常处理是另一个责任链模式的例子。当错误发生，一个异常会需找一个处理类。如果没有发现处理类，草类的异常会被调用。否则，这个处理类会操作这个对象。
       下面我们编写一个程序来阐明这个设计模式。当某个公司购买某件商品时，需要根据金额的大小而发给最终的领导进行审批。审批流程如下：

Manager -> Directory -> VicePresident -> President

       定义一个抽象类PurchasePower.

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);
}

      购买请求类。

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;
}
}

      定义责任链的处理流。

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!");
}
}

   
        测试类ChainOfResponsibility。

public class ChainOfResponsibility {

public static void main(String []args){
System.out.println("--------Chain of responsibility pattern-----------------------");
ManagerPPower manager = new ManagerPPower();
DirectorPPower dir = new DirectorPPower();
VicePresidentPPower vice = new VicePresidentPPower();
PresidentPPower pre = new PresidentPPower();
manager.setSuccessor(dir);
dir.setSuccessor(vice);
vice.setSuccessor(pre);
double d = 34000;     // get the different result according to the expenditure.
manager.processRequest(new PurchaseRequest(0, d, "General"));
}
}

      测试结果：

--------Chain of responsibility pattern-----------------------
Your request for $34000.0 needs a board meeting!