1. 职责链模式（称责任链模式）将请求的处理对象像一条长链一般组合起来，形成一条对象链。
    2. 请求并不知道具体执行请求的对象是哪一个，这样就实现了请求与处理对象之间的解耦。
    3. 生活中这种情况其实很常见，公司部门之中，政府部门之中都有体现，在公司部门中，
    4. 当你提交一份请求文件给你的直接上级时，你的直接上级可以处理这个文件，若他觉得自己不够资格，
    5. 会将文件传递为他的直接上级，这样文件请求在这条链中传递，直到被某位感觉自己足够资格处理文件
    6. 的人给处理掉为止，在政府部门也是如此。
    8. 职责链模式需要一个总接口，用来定义处理对象的公共部分（一般使用抽象类来定义），公共部分包括：
    9. 一个后继处理器，设置和获取后继处理器的方法，具体的请求处理方法
    10. （这个方法需要在每个具体处理对象中实现），这里定义为抽象方法。

    以公司部门为例来进行实例
    领导抽象类：Lingdao

    1. public abstract class Lingdao {
    2.     private Lingdao nextLingdao;
    3.     public Lingdao getNextLingdao() {
    4.         return nextLingdao;
    5.     }
    6.     public void setNextLingdao(Lingdao nextLingdao) {
    7.         this.nextLingdao = nextLingdao;
    8.     }
    9.     abstract void chuli(Files file);
    10. }

    领导实现类：Zongjingli、Fujingli、Bumenjingli

    1. /**
    2.  * 总经理
    3.  */
    4. public class Zongjingli extends Lingdao {
    5.     private final String name = "总经理";
    6.     private final int level = 0;//最大
    7.     @Override
    8.     public void chuli(Files file) {
    9.         if(this.level > file.getLevel()){
    10.             System.out.println(name + "未处理文件《" + file.getFileName() + "》");
    11.             getNextLingdao().chuli(file);
    12.         }else{
    13.             System.out.println(name + "处理了文件《" + file.getFileName() + "》");
    14.         }
    15.     }
    16. }
    18. /**
    19.  * 副经理
    20.  */
    21. public class Fujingli extends Lingdao {
    22.     private final String name = "副经理";
    23.     private final int level = 1;
    24.     @Override
    25.     public void chuli(Files file) {
    26.         if(this.level > file.getLevel()){
    27.             System.out.println(name + "未处理文件《" + file.getFileName() + "》");
    28.             getNextLingdao().chuli(file);
    29.         }else{
    30.             System.out.println(name + "处理了文件《" + file.getFileName() + "》");
    31.         }
    32.     }
    33. }
    35. /**
    36.  * 部门经理
    37.  */
    38. public class Bumenjingli extends Lingdao{
    39.     private final String name = "部门经理";
    40.     private final int level = 2;
    41.     @Override
    42.     public void chuli(Files file) {
    43.         if(this.level > file.getLevel()){
    44.             System.out.println(name + "未处理文件《" + file.getFileName() + "》");
    45.             getNextLingdao().chuli(file);
    46.         }else{
    47.             System.out.println(name + "处理了文件《" + file.getFileName() + "》");
    48.         }
    49.     }
    50. }

    文件类：Files

    1. public class Files {
    2.     private String fileName;
    3.     private int level;
    4.     public String getFileName() {
    5.         return fileName;
    6.     }
    7.     public void setFileName(String fileName) {
    8.         this.fileName = fileName;
    9.     }
    10.     public int getLevel() {
    11.         return level;
    12.     }
    13.     public void setLevel(int level) {
    14.         this.level = level;
    15.     }
    16. }

    测试类：Clienter

    1. public class Clienter {
    2.     public static void main(String[] args) {
    3.         //定义职责链
    4.         Lingdao zongjingli = new Zongjingli();
    5.         Lingdao fujingli = new Fujingli();
    6.         Lingdao bumenjingli = new Bumenjingli();
    7.         bumenjingli.setNextLingdao(fujingli);
    8.         fujingli.setNextLingdao(zongjingli);
    9.         //定义两份文件
    10.         Files f1 = new Files();
    11.         f1.setFileName("正确对待旱鸭子");
    12.         f1.setLevel(1);
    13.         Files f2 = new Files();
    14.         f2.setFileName("年会在那里举行");
    15.         f2.setLevel(0);
    16.         //提交文件
    17.         bumenjingli.chuli(f1);
    18.         bumenjingli.chuli(f2);
    19.     }
    20. }
    22. 执行结果：
    23. 部门经理未处理文件《正确对待旱鸭子》
    24. 副经理处理了文件《正确对待旱鸭子》
    25. 部门经理未处理文件《年会在那里举行》
    26. 副经理未处理文件《年会在那里举行》
    27. 总经理处理了文件《年会在那里举行》

    总结

    1. 实例清晰易懂，职责链的模式重在这个链的组成，如何组成链呢？
    2. 第一步需要在处理者对象类中定义后继处理者对象，将这部分代码抽象到抽象类中实现，降低了代码重复性。
    3. 第二步就是在处理者对象类中的处理方法中如果当前处理者对象无法处理，就将其传递到后继对象去处理。
    4. 第三步就是在测试类中将这些处理者类的实例串联成链。
    6. 其实这个模式有个缺陷，那就是虽然可以实现请求额度传递，但是也不保证在这里链中一定存在能处理请求的
    7. 处理这类，一旦不存在，那么这个请求将一直存在与链中，如果将链设置成环形，那么这个请求将会永远在环
    8. 形链中传递不休；还有一点就是由于请求的传递，请求无法立即精确的找到处理者，处理效率会降低。