责任链模式(Chain of Responsibility Pattern)

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

   

     使用场景和优势：

1.  一个请求需要被不少于一个对象处理。
2.  不清楚到底哪个对象会处理请求，可能有多于一个对象制动化地处理它。减少耦合度。
3.  弹性地操作请求。

      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!