责任链模式

iOS中的事件响应链  就是 责任链的 一个典型案例。  

职责链模式(Chain of Responsibility)：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

1）在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。

2）请求在这条链上传递，直到链上的某一个对象处理此请求为止。

3）发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

4.适用性

在以下条件下使用Responsibility 链：

• 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

• 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

•可动态指定一组对象处理请求。

5.结构

        

一个典型的对象结构可能如下图所示：

6. 模式的组成

抽象处理者角色(Handler:Approver):定义一个处理请求的接口，和一个后继连接(可选)

具体处理者角色(ConcreteHandler:President):处理它所负责的请求，可以访问后继者，如果可以处理请求则处理，否则将该请求转给他的后继者。

客户类(Client):向一个链上的具体处理者ConcreteHandler对象提交请求。

7. 效果

Responsibility 链有下列优点和缺点( l i a b i l i t i e s ) :

职责链模式的优点：

1 ) 降低耦合度 ：该模式使得一个对象无需知道是其他哪一个对象处理其请求。对象仅需知道该请求会被“正确”地处理。接收者和发送者都没有对方的明确的信息，且链中的对象不需知道链的结构。

2) 职责链可简化对象的相互连接 :    结果是，职责链可简化对象的相互连接。它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。

3) 增强了给对象指派职责( R e s p o n s i b i l i t y )的灵活性 ：当在对象中分派职责时，职责链给你更多的灵活性。你可以通过在运行时刻对该链进行动态的增加或修改来增加或改变处理一个请求的那些职责。你可以将这种机制与静态的特例化处理对象的继承机制结合起来使用。

4)增加新的请求处理类很方便

职责链模式的缺点:

1) • 不能保证请求一定被接收。既然一个请求没有明确的接收者，那么就不能保证它一定会被处理 —该请求可能一直到链的末端都得不到处理。一个请求也可能因该链没有被正确配置而得不到处理。

2) • 系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。

8. 纯与不纯的职责链模式

纯的职责链模式：一个具体处理者角色处理只能对请求作出两种行为中的一个：一个是自己处理（承担责任），另一个是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又将责任向下传的情况。请求在责任链中必须被处理，不能出现无果而终的结局。

反之就是不纯的职责链模式。  

在一个纯的职责链模式里面，一个请求必须被某一个处理者对象所接收；在一个不纯的职责链模式里面，一个请求可以最终不被任何接收端对象所接收。

源代码

　　抽象处理者角色

public abstract class Handler {        /**     * 持有后继的责任对象     */    protected Handler successor;    /**     * 示意处理请求的方法，虽然这个示意方法是没有传入参数的     * 但实际是可以传入参数的，根据具体需要来选择是否传递参数     */    public abstract void handleRequest();    /**     * 取值方法     */    public Handler getSuccessor() {        return successor;    }    /**     * 赋值方法，设置后继的责任对象     */    public void setSuccessor(Handler successor) {        this.successor = successor;    }    }

　　具体处理者角色

public class ConcreteHandler extends Handler {    /**     * 处理方法，调用此方法处理请求     */    @Override    public void handleRequest() {        /**         * 判断是否有后继的责任对象         * 如果有，就转发请求给后继的责任对象         * 如果没有，则处理请求         */        if(getSuccessor() != null)        {                        System.out.println("放过请求");            getSuccessor().handleRequest();                    }else        {                        System.out.println("处理请求");        }    }}

　　客户端类

public class Client {    public static void main(String[] args) {        //组装责任链        Handler handler1 = new ConcreteHandler();        Handler handler2 = new ConcreteHandler();        handler1.setSuccessor(handler2);        //提交请求        handler1.handleRequest();    }}

　　可以看出，客户端创建了两个处理者对象，并指定第一个处理者对象的下家是第二个处理者对象，而第二个处理者对象没有下家。然后客户端将请求传递给第一个处理者对象。

　　由于本示例的传递逻辑非常简单：只要有下家，就传给下家处理；如果没有下家，就自行处理。因此，第一个处理者对象接到请求后，会将请求传递给第二个处理者对象。由于第二个处理者对象没有下家，于是自行处理请求。活动时序图如下所示。

使用场景

　　来考虑这样一个功能:申请聚餐费用的管理。

　　很多公司都是这样的福利，就是项目组或者是部门可以向公司申请一些聚餐费用，用于组织项目组成员或者是部门成员进行聚餐活动。

　　申请聚餐费用的大致流程一般是：由申请人先填写申请单，然后交给领导审批，如果申请批准下来，领导会通知申请人审批通过，然后申请人去财务领取费用，如果没有批准下来，领导会通知申请人审批未通过，此事也就此作罢。

　　不同级别的领导，对于审批的额度是不一样的，比如，项目经理只能审批500元以内的申请；部门经理能审批1000元以内的申请；而总经理可以审核任意额度的申请。

　　也就是说，当某人提出聚餐费用申请的请求后，该请求会经由项目经理、部门经理、总经理之中的某一位领导来进行相应的处理，但是提出申请的人并不知道最终会由谁来处理他的请求，一般申请人是把自己的申请提交给项目经理，或许最后是由总经理来处理他的请求。

　　

　　可以使用责任链模式来实现上述功能：当某人提出聚餐费用申请的请求后，该请求会在 项目经理—〉部门经理—〉总经理 这样一条领导处理链上进行传递，发出请求的人并不知道谁会来处理他的请求，每个领导会根据自己的职责范围，来判断是处理请求还是把请求交给更高级别的领导，只要有领导处理了，传递就结束了。

　　需要把每位领导的处理独立出来，实现成单独的职责处理对象，然后为它们提供一个公共的、抽象的父职责对象，这样就可以在客户端来动态地组合职责链，实现不同的功能要求了。

　　

源代码

这个不够精简，也找不到更好的了，凑活看吧

　　抽象处理者角色类

public abstract class Handler {        protected Handler successor = null;    public Handler getSuccessor() {        return successor;    }    public void setSuccessor(Handler successor) {        this.successor = successor;    }    /**     * 处理聚餐费用的申请     * @param user    申请人     * @param fee    申请的钱数     * @return        成功或失败的具体通知     */    public abstract String handleFeeRequest(String user , double fee);}

　　具体处理者角色

public class ProjectManager extends Handler {    @Override    public String handleFeeRequest(String user, double fee) {                String str = "";        //项目经理权限比较小，只能在500以内        if(fee < 500)        {            //为了测试，简单点，只同意张三的请求            if("张三".equals(user))            {                str = "成功：项目经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";                }else            {                //其他人一律不同意                str = "失败：项目经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";            }        }else        {            //超过500，继续传递给级别更高的人处理            if(getSuccessor() != null)            {                return getSuccessor().handleFeeRequest(user, fee);            }        }        return str;    }}

public class DeptManager extends Handler {    @Override    public String handleFeeRequest(String user, double fee) {                String str = "";        //部门经理的权限只能在1000以内        if(fee < 1000)        {            //为了测试，简单点，只同意张三的请求            if("张三".equals(user))            {                str = "成功：部门经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";                }else            {                //其他人一律不同意                str = "失败：部门经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";            }        }else        {            //超过1000，继续传递给级别更高的人处理            if(getSuccessor() != null)            {                return getSuccessor().handleFeeRequest(user, fee);            }        }        return str;    }}

public class GeneralManager extends Handler {    @Override    public String handleFeeRequest(String user, double fee) {                String str = "";        //总经理的权限很大，只要请求到了这里，他都可以处理        if(fee >= 1000)        {            //为了测试，简单点，只同意张三的请求            if("张三".equals(user))            {                str = "成功：总经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";                }else            {                //其他人一律不同意                str = "失败：总经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";            }        }else        {            //如果还有后继的处理对象，继续传递            if(getSuccessor() != null)            {                return getSuccessor().handleFeeRequest(user, fee);            }        }        return str;    }}

　　客户端类

public class Client {    public static void main(String[] args) {        //先要组装责任链        Handler h1 = new GeneralManager();        Handler h2 = new DeptManager();        Handler h3 = new ProjectManager();        h3.setSuccessor(h2);        h2.setSuccessor(h1);                //开始测试        String test1 = h3.handleFeeRequest("张三", 300);        System.out.println("test1 = " + test1);        String test2 = h3.handleFeeRequest("李四", 300);        System.out.println("test2 = " + test2);        System.out.println("---------------------------------------");                String test3 = h3.handleFeeRequest("张三", 700);        System.out.println("test3 = " + test3);        String test4 = h3.handleFeeRequest("李四", 700);        System.out.println("test4 = " + test4);        System.out.println("---------------------------------------");                String test5 = h3.handleFeeRequest("张三", 1500);        System.out.println("test5 = " + test5);        String test6 = h3.handleFeeRequest("李四", 1500);        System.out.println("test6 = " + test6);    }}