JAVA设计模式之责任链模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述责任链（Chain of Responsibility）模式的：

责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

责任链模式涉及到的角色如下所示：

1. 抽象处理者(Handler)角色：定义一个处理请求的抽象类。如果需要，可以定义一个方法以设定和返回对下家的引用。
2. 具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

举一个简单的例子，部门办活动需要报销。报销处职员可以处理单次500元以下的业务，超过500需要和处长联系。而处长只能处理单次1000元一下的业务，再高就只能找老大报了。但是老大目前只能处理单次1500元以下的业务，再高目前只能拒绝报销了。
这个例子的具体实现为：

抽象类Handler

    public abstract class Handler {
        protected Handler nextHandler = null;
     
        public Handler getNextHandler() {
            return nextHandler;
        }
     
        public void setNextHandler(Handler nextHandler) {
            this.nextHandler = nextHandler;
        }
         
        public abstract String dispose(String user , double fee);
    }

职员类：

    public class StaffMember extends Handler {
        @Override
        public String dispose(String user, double fee) {
            if(fee < 500){
                System.out.println("职员 给了 "+user+" "+fee+"元");
            }else if (super.getNextHandler() == null){
                System.out.println("谁都处理不了 "+user+" 要 "+fee+"元的事情");
            }else {
                super.getNextHandler().dispose(user,fee);
            }
            return null;
        }
    }

处长类：

    public class SectionChief extends Handler {
        @Override
        public String dispose(String user, double fee) {
            if(fee < 1000){
                System.out.println("小主管 给了 "+user+" "+fee+"元");
            }else if (super.getNextHandler() == null){
                System.out.println("谁都处理不了 "+user+" 要 "+fee+"元的事情");
            }else {
                super.getNextHandler().dispose(user,fee);
            }
            return null;
        }
    }

老大类：

    public class Director extends Handler {
        @Override
        public String dispose(String user, double fee) {
            if(fee < 5000){
                System.out.println("老大 给了 "+user+" "+fee+"元");
            }else if (super.getNextHandler() == null){
                System.out.println("谁都处理不了 "+user+" 要 "+fee+"元的事情");
            }else {
                super.getNextHandler().dispose(user,fee);
            }
            return null;
        }
    }

Main方法：

    public class Main {
        public static void main(String[] args){
            StaffMember staffMember = new StaffMember();
            SectionChief sectionChief = new SectionChief();
            Director director = new Director();
     
            //set Handler
            staffMember.setNextHandler(sectionChief);
            sectionChief.setNextHandler(director);
     
            staffMember.dispose("小王",400);
            staffMember.dispose("小混混",800);
            staffMember.dispose("老李",1200);
     
            staffMember.dispose("小明",10000);
        }
    }

最后的结果就是：

纯责任链模式和不纯的责任链模式
如果一个类要么承担责任处理请求要么将请求踢给下一个皮球，则被称为纯责任链模式。
如果一个类承担了一部分责任，还将请求踢给下一个皮球，则被称为不纯的责任链模式。

一般来说，日常开发中不纯的责任链模式用的比较多一点。

参考：
java责任链模式