行为型模式-责任链模式

（1）概述

为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连城一条链；当有请求发生时，可将请求沿着这条链传递，只到有对象处理它为止

（2）结构

• 抽象处理者角色：定义处理请求的接口，包含抽象处理方法和一个后继链接
• 具体处理者角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理则处理，否则将该请求转发给后继者
• 客户类角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节及请求传递的过程

（3）案例

以请假为例

抽象处理者角色

public abstract class Handler {

    protected final static int ONE = 1;

    protected final static int THREE = 3;

    protected final static int SEVEN = 7;

    //不同角色可以处理的请假天数区间
    private int startNum;
    private int endNum;

    //声明后继者（该案例中的上级领导）
    private Handler nextHandler;

    public Handler(int startNum) {
        this.startNum = startNum;
    }

    public Handler(int startNum, int endNum) {
        this.startNum = startNum;
        this.endNum = endNum;
    }

    /**
     * 设置上级领导对象
     *
     * @param nextHandler
     */
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    /**
     * 各级领导处理请假条的方法
     *
     * @param leave
     */
    protected abstract void handlerLeave(LeaveRequest leave);

    /**
     * 提交请假申请
     *
     * @param leave
     */
    public final void submit(LeaveRequest leave) {
        //当前领导审批
        this.handlerLeave(leave);

        //上级领导审批
        if (this.nextHandler != null && leave.getNum() > this.endNum) {
            this.nextHandler.handlerLeave(leave);
        } else {
            System.out.println("流程结束");
        }
    }
}

具体处理者角色

public class GroupLeader extends Handler {

    public GroupLeader() {
        super(0, Handler.ONE);
    }

    @Override
    protected void handlerLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "由于" + leave.getContent() + "，请假：" + leave.getNum() + "天");
        System.out.println("组长审批意见：同意");
    }
}

public class Manager extends Handler {

    public Manager() {
        super(Handler.ONE, Handler.THREE);
    }

    @Override
    protected void handlerLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "由于" + leave.getContent() + "，请假：" + leave.getNum() + "天");
        System.out.println("部门经理意见：同意");
    }
}

public class GeneralManager extends Handler {

    public GeneralManager() {
        super(Handler.THREE, Handler.SEVEN);
    }

    @Override
    protected void handlerLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "由于" + leave.getContent() + "，请假：" + leave.getNum() + "天");
        System.out.println("总经理审批意见：同意");
    }
}

客户类角色

public class LeaveRequest {

    //请假人
    private String name;

    //请假天数
    private int num;

    //请假事由
    private String content;

    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }

    public String getName() {
        return name;
    }

    public int getNum() {
        return num;
    }

    public String getContent() {
        return content;
    }
}

Client

public class Client {
    public static void main(String[] args) {
        //创建请假条
        LeaveRequest leaveRequest = new LeaveRequest("孙笑川", 2, "感冒");

        //各级领导对象
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();

        //设置处理者链
        groupLeader.setNextHandler(manager);
        manager.setNextHandler(generalManager);

        //发起请假申请
        groupLeader.submit(leaveRequest);
    }
}

（4）优缺点

• 降低了请求发送者和接收者的耦合度
• 可根据需求添加新的处理类，复合开闭原则
• 增强了给对象指派职责的灵活性，当工作流程发生变化时，可以动态的改变链内的成员或成员之间的顺序，也可以动态的新增/删除责任
• 简化了对象之间的连接，一个对象只需保持一个指向其后继者的引用，不需要保持其他所有处理者的引用，对客户端来说避免了众多的 if...else 语句
• 职责明确，每个类只需关心自己的职责内容，不能处理的传递给下一个对象，复合类的单一职责原则
• 不能保证每一个请求一定被处理，由于一个请求没有明确的接收者，所以不能暴政它一定被处理，该请求可能一直传递到链的末端也得不到处理
• 较长的责任链可能涉及的多个处理对象，对性能有一定的影响
• 责任链建立的合理性需要靠客户端来保证，增加了客户端的复杂性，可能会由于责任链的设置错误而导致系统出错（如循环调用等）