开发中常见的场景

• Java中,异常机制就是一种责任链模式.一个try可以对应多个catch,当第一个catch不匹配类型,则自动跳到第二个catch

• Javascript语言中,实践的冒泡和捕获机制.Java语言中,事件的处理采用观察者模式

• Servlet开发中,过滤器的链式处理

• Struts2中,拦截器的调用也是典型的责任链模式

定义

将能够处理同一类请求的对象连成一条链,所提交的请求沿着链传递,链上的对象逐个判断是否有能力处理该请求,如果能则处理,不能则传递给链上的下一个对象

场景

• 打牌时,轮流出牌

• 接力赛跑

• 大学中,奖学金审批

• 公司中,公文审批

场景

• 公司里面,报销单据需要经过流程

  • 申请人填单申请,申请给经理

  • 小于1000,经理审查

  • 超过1000,交给总经理审批

  • 总经理审批通过

• 公司里面,请假条的审批过程

  • 如果请假天数小于3天,主任审批

  • 如果请假天数大于等于3天,小于10天,经理审批

  • 如果大于等于10天,小于30天,总经理审批

  • 如果大于等于30天,提示拒绝

/**
 * 封装请假的基本信息
 * @author Matrix42
 *
 */
public class LeaveRequest {
    private String empName;
    private int leaveDay;
    private String reason;

    public LeaveRequest(String empName, int leaveDay, String reason) {
        super();
        this.empName = empName;
        this.leaveDay = leaveDay;
        this.reason = reason;
    }

    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public int getLeaveDay() {
        return leaveDay;
    }
    public void setLeaveDay(int leaveDay) {
        this.leaveDay = leaveDay;
    }
    public String getReason() {
        return reason;
    }
    public void setReason(String reason) {
        this.reason = reason;
    }

}

public abstract class Leader {
    protected String name;
    protected Leader nextLeader;//责任链的后继对象

    public Leader(String name) {
        super();
        this.name = name;
    }
    //设定责任链上的后继对象
    public void setNextLeader(Leader nextLeader) {
        this.nextLeader = nextLeader;
    }

    /**
     * 处理请求的核心业务方法
     * @param request
     */
    public abstract void handleRequest(LeaveRequest request);
}

public class Director extends Leader {

    public Director(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if(request.getLeaveDay()<3){
            System.out.println("员工:"+request.getEmpName()+"请假,天数:"+request.getLeaveDay()+",理由:"+request.getReason());
            System.out.println("主任"+this.name+"审批通过!");
        }else {
            if(this.nextLeader!=null){
                this.nextLeader.handleRequest(request);
            }
        }
    }

}

/**
 * 经理
 * @author Matrix42
 *
 */
public class Manager extends Leader{

    public Manager(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if(request.getLeaveDay()<10){
            System.out.println("员工:"+request.getEmpName()+"请假,天数:"+request.getLeaveDay()+",理由:"+request.getReason());
            System.out.println("经理"+this.name+"审批通过!");
        }else {
            if(this.nextLeader!=null){
                this.nextLeader.handleRequest(request);
            }
        }
    }
}

public class GeneralManager extends Leader{

    public GeneralManager(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if(request.getLeaveDay()<30){
            System.out.println("员工:"+request.getEmpName()+"请假,天数:"+request.getLeaveDay()+",理由:"+request.getReason());
            System.out.println("总经理"+this.name+"审批通过!");
        }else {
            System.out.println("莫非"+request.getEmpName()+"想辞职!");
        }
    }
}

public class Client {

    public static void main(String[] args) {
        Leader a = new Director("张三");
        Leader b = new Manager("李四");
        Leader c = new GeneralManager("王五");

        //组织责任链对象关系
        a.setNextLeader(b);
        b.setNextLeader(c);

        //开始请假操作
        LeaveRequest request1 = new LeaveRequest("TOM", 10, "回英国探亲");
        a.handleRequest(request1);
    }

}

添加新的处理对象

由于责任链的创建完全在客户端,因此新增的具体处理者对原有类库没有任何影响,只需添加新的类,然后在客户端调用时添加即可,符合开闭原则

非链表方式实现职责链

通过集合,数组生成职责链更加实用!实际上,很多项目中,每个具体的Handler并不是有开发团队定义的,而是项目上线后有外部单位追加的,所以使用链表的方式定义COR链就很困难