Java责任链模式

2017-07-30 本文已影响116人今晚打肉山

概述

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

从击鼓传花谈起

击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒。
比如说，贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者，他们组成一个环链。击鼓者将花传给贾母，开始传花游戏。花由贾母传给贾赦，由贾赦传给贾政，由贾政传给贾宝玉，又贾宝玉传给贾环，由贾环传回给贾母，如此往复，如下图所示。当鼓声停止时，手中有花的人就得执行酒令。

击鼓传花便是责任链模式的应用。责任链可能是一条直线、一个环链或者一个树结构的一部分。

责任链模式的结构

下面使用了一个责任链模式的最简单的实现。

责任链模式涉及到的角色如下所示：
　　●　　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。
　　●　　具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

源代码

/**
 * 抽象处理者(Handler)角色
 */
public abstract class Handler {

    /**
     * 持有后继的责任对象
     */
    private Handler successor;

    public Handler getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    /**
     * 示意处理请求的方法，虽然这个示意方法是没有传入参数的
     * 但实际是可以传入参数的，根据具体需要来选择是否传递参数
     */
    public abstract void handleRequest();
}

/**
 * 具体的处理者
 */
public class ConcreteHandler1 extends Handler {

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

}

/**
 * 具体的处理者
 */
public class ConcreteHandler2 extends Handler {

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

}

/**
 * 客户端
 */
public class Client {

    public static void main(String[] args) {

        //创建具体的处理者对象
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();

        //将handler2指定为1的下一级
        handler1.setSuccessor(handler2);

        handler1.handleRequest();
    }

}

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

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

使用场景

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

申请聚餐费用的大致流程一般是：由申请人先填写申请单，然后交给领导审批，如果申请批准下来，领导会通知申请人审批通过，然后申请人去财务领取费用，如果没有批准下来，领导会通知申请人审批未通过，此事也就此作罢。
不同级别的领导，对于审批的额度是不一样的，比如，项目经理只能审批500元以内的申请；部门经理能审批1000元以内的申请；而总经理可以审核任意额度的申请。

也就是说，当某人提出聚餐费用申请的请求后，该请求会经由项目经理、部门经理、总经理之中的某一位领导来进行相应的处理，但是提出申请的人并不知道最终会由谁来处理他的请求，一般申请人是把自己的申请提交给项目经理，或许最后是由总经理来处理他的请求。
　　
　　可以使用责任链模式来实现上述功能：当某人提出聚餐费用申请的请求后，该请求会在 **项目经理—〉部门经理—〉总经理 **这样一条领导处理链上进行传递，发出请求的人并不知道谁会来处理他的请求，每个领导会根据自己的职责范围，来判断是处理请求还是把请求交给更高级别的领导，只要有领导处理了，传递就结束了。
　　
需要把每位领导的处理独立出来，实现成单独的职责处理对象，然后为它们提供一个公共的、抽象的父职责对象，这样就可以在客户端来动态地组合职责链，实现不同的功能要求了。

/**
 * 抽象的处理类
 */
public abstract class Handler {

    private Handler successor;

    /**
     * 处理金额审批的方法
     * @param money
     */
    public abstract void handleFeeRequest(double money);

    public Handler getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
}

/**
 * 具体的处理类，项目经理
 */
public class ProjectManager extends Handler {
    @Override
    public void handleFeeRequest(double money) {
        if(money > 400){
            System.out.println("金额超过400，项目经理转交请求到下一级");
            if(getSuccessor() != null){
                getSuccessor().handleFeeRequest(money);
            }
        }else{
            System.out.println("金额未超过400，项目经理同意审批");
        }
    }
}

/**
 * 具体的处理类，部门经理
 */
public class DeptManager extends Handler {
    @Override
    public void handleFeeRequest(double money) {
        if(money > 1000){
            System.out.println("金额超过1000，部门经理转交请求到下一级");
            if(getSuccessor() != null){
                getSuccessor().handleFeeRequest(money);
            }
        }else{
            System.out.println("金额未超过1000，部门经理同意审批");
        }
    }
}

/**
 * 具体的处理类，公司经理
 */
public class CompanyManager extends Handler {
    @Override
    public void handleFeeRequest(double money) {
        System.out.println("公司老总处理");
    }
}


/**
 * 客户端
 */
public class Client {

    public static void main(String[] args) {
        Handler project = new ProjectManager();
        Handler dept = new DeptManager();
        Handler company = new CompanyManager();

        project.setSuccessor(dept);
        dept.setSuccessor(company);

        //最先由项目经理审批
        project.handleFeeRequest(100);
        System.out.println("--------------------");
        project.handleFeeRequest(500);
        System.out.println("--------------------");
        project.handleFeeRequest(2000);
        System.out.println("--------------------");
    }

}

纯的与不纯的责任链模式

一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个：一是承担责任，而是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又把责任向下传的情况。

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

纯的责任链模式的实际例子很难找到，一般看到的例子均是不纯的责任链模式的实现。有些人认为不纯的责任链根本不是责任链模式，这也许是有道理的。但是在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。

职责链灵活在哪

改变内部的传递规则
在内部，项目经理完全可以跳过人事部到那一关直接找到总经理。
每个人都可以去动态地指定他的继任者。
可以从职责链任何一关开始。
如果项目经理不在，可以直接去找部门经理，责任链还会继续，没有影响。
用与不用的区别
不用职责链的结构，我们需要和公司中的每一个层级都发生耦合关系。
如果反映在代码上即使我们需要在一个类中去写上很多丑陋的if….else语句。
如果用了职责链，相当于我们面对的是一个黑箱，我们只需要认识其中的一个部门，然后让黑箱内部去负责传递就好了