设计模式（十四）Chain of Responsibility模式

　　Chain of Responsibility模式就是当外部请求程序进行某个处理，但程序暂时无法直接决定由哪个对象负责处理时，就需要推卸责任。也就是说，当一个人被要求做什么事时，如果他可以做就自己做，如果不能做就转给下一个人，以此类推。

　　下面是示例程序的类图。

　　

　　下面是示例程序代码。

 package bigjunoba.bjtu.handler;

 public class Trouble {

     private int number;

     public Trouble(int number) {
         this.number = number;
     }

     public int getNumber() {
         return number;
     }

     public String toString() {
         return "[Trouble " + number + "]";
     }

 }

　　Trouble类是表示发生的问题的类，number作为问题编号，通过getNumber方法得到问题编号。

 package bigjunoba.bjtu.handler;

 public abstract class Support {

     private String name;
     private Support next;

     public Support(String name) {
         super();
         this.name = name;
     }

     public Support setNext(Support next) {
         this.next = next;
         return next;
     }

     public final void support(Trouble trouble) {
         if (resolve(trouble)) {
             done(trouble);
         } else if (next != null) {
             next.support(trouble);
         }else {
             fail(trouble);
         }
     }

     public String toString() {
         return "[" + name + "]";
     }

     protected abstract boolean resolve(Trouble trouble);

     protected void done(Trouble trouble) {
         System.out.println(trouble + " is resolved by " + this + "." );
     }

     protected void fail(Trouble trouble) {
         System.out.println(trouble + " cannot be resolved.");
     }

 }

　　Support类是用来解决问题的抽象类，它是职责链上的对象。next字段保存了要推卸给的对象，即Support类的实例，可以通过setNext方法设定该对象。resolve方法如果返回true，则表示问题已经被处理，如果返回false，则表示问题还没有被处理。support方法调用resolve方法，如果解决了问题，那么就调用done方法，如果否则将问题交给下一个对象，如果到最后一个对象仍然没有人处理，那么就调用fail方法。这里注意的是support方法调用抽象resolve方法，这属于Template Method模式。

 package bigjunoba.bjtu.concretehandler;

 import bigjunoba.bjtu.handler.Support;
 import bigjunoba.bjtu.handler.Trouble;

 public class NoSupport extends Support{

     public NoSupport(String name) {
         super(name);
     }

     @Override
     protected boolean resolve(Trouble trouble) {
         return false;
     }

 }

 package bigjunoba.bjtu.concretehandler;

 import bigjunoba.bjtu.handler.Support;
 import bigjunoba.bjtu.handler.Trouble;

 public class OddSupport extends Support {

     public OddSupport(String name) {
         super(name);
     }

     @Override
     protected boolean resolve(Trouble trouble) {
         if (trouble.getNumber() % 2 == 1) {
             return true;
         } else {
             return false;
         }
     }

 }

package bigjunoba.bjtu.concretehandler;

import bigjunoba.bjtu.handler.Support;
import bigjunoba.bjtu.handler.Trouble;

public class SpecilaSupport extends Support{

    private int number;

    public SpecilaSupport(String name, int number) {
        super(name);
        this.number = number;
    }

    @Override
    protected boolean resolve(Trouble trouble) {
        if (trouble.getNumber() == number) {
            return true;
        } else {
            return false;
        }
    }
}

 package bigjunoba.bjtu.concretehandler;

 import bigjunoba.bjtu.handler.Support;
 import bigjunoba.bjtu.handler.Trouble;

 public class LimitSupport extends Support{

     private int limit;

     public LimitSupport(String name, int limit) {
         super(name);
         this.limit = limit;
     }

     @Override
     protected boolean resolve(Trouble trouble) {
         if (trouble.getNumber() < limit) {
             return true;
         } else {
             return false;
         }
     }

 }

　　这四种类Support类的子类不难理解。NoSupport类永远不解决问题；LimitSupport类只解决编号小于limit值的问题；OddSupport类只解决奇数编号问题；SpecialSupport类只解决特定编号的问题。

 package bigjunoba.bjtu.test;

 import bigjunoba.bjtu.concretehandler.LimitSupport;
 import bigjunoba.bjtu.concretehandler.NoSupport;
 import bigjunoba.bjtu.concretehandler.OddSupport;
 import bigjunoba.bjtu.concretehandler.SpecilaSupport;
 import bigjunoba.bjtu.handler.Support;
 import bigjunoba.bjtu.handler.Trouble;

 public class Main {

     public static void main(String[] args) {
         Support lian1 = new NoSupport("LianOne");
         Support lian2 = new LimitSupport("LianTwo", 100);
         Support lian3 = new SpecilaSupport("LianThree", 429);
         Support lian4 = new LimitSupport("LianFour", 200);
         Support lian5 = new OddSupport("LianFive");
         Support lian6 = new LimitSupport("LianSix", 300);
         //形成职责链
         lian1.setNext(lian2).setNext(lian3).setNext(lian4).setNext(lian5).setNext(lian6);
         //制造各种问题
         for (int i = 0; i < 500; i += 33) {
             lian1.support(new Trouble(i));
         }
     }

 }

　　Main类首先生成了6个解决问题的实例，虽然都是Support类型的，但实际上由于Support类是抽象类，因此这些实例分别是四个不同的子类的实例。然后形成了职责链，接着制造问题进行处理。

[Trouble 0] is resolved by [LianTwo].
[Trouble 33] is resolved by [LianTwo].
[Trouble 66] is resolved by [LianTwo].
[Trouble 99] is resolved by [LianTwo].
[Trouble 132] is resolved by [LianFour].
[Trouble 165] is resolved by [LianFour].
[Trouble 198] is resolved by [LianFour].
[Trouble 231] is resolved by [LianFive].
[Trouble 264] is resolved by [LianSix].
[Trouble 297] is resolved by [LianFive].
[Trouble 330] cannot be resolved.
[Trouble 363] is resolved by [LianFive].
[Trouble 396] cannot be resolved.
[Trouble 429] is resolved by [LianThree].
[Trouble 462] cannot be resolved.
[Trouble 495] is resolved by [LianFive].

　　根据输出结果来举一个例子具体分析一下这个过程。假设问题编号是429，那么可以这样来分析，首先创建了一个Trouble实例，并且把问题编号number设置为429，然后这个429问题实例传递给support方法，并用lian1来调用这个方法。主要分析的是调用方法的过程：先调用NoSupport类的resolve方法，结果返回false，然后next字段保存的是lian2，不为空，因此要执行lian2的support方法...以此类推，最后发现lian1，2都解决不了，最后交给了3，3可以解决，程序结束。这里的思想是用到了递归。

　　有一个时序图也可以用来帮助理解。

　　下面是Chain of Responsibility模式的类图。

　　这里对类图不做过多解释，通过示例程序对这一模式理解应该很到位。