15、设计模式之责任链模式

定义

又名职责链模式，简单来说就是将请求一级一级下发，直到请求被处理。

结构

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

案例

需要一个请假流程控制系统。请假一天以内只需要小组长同意即可；请假1到3天还需要部门经理同意；请假3到7天还需要总经理同意

请假条

package com.hupp.responsibility;

/**
 * 请假条
 */
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;
    }
}

抽象处理者

package com.hupp.responsibility;

/**
 * 抽象处理者
 */
public abstract class Handler {
    
    
    protected final static int NUM_ONE=1;
    protected final static int NUM_THREE=3;
    protected final static int NUM_SEVEN=7;

    //该领导处理权限（能够批准的天数）
    private int numStart;
    private int numEnd;

    //上级领导
    private Handler nextHandler;

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

    public Handler(int numStart, int numEnd) {
    
    
        this.numStart = numStart;
        this.numEnd = numEnd;
    }

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

    //各级领导处理请求的方法
    protected abstract void handlerLeave(LeaveRequest leave);

    //提交请假条
    public final void submit(LeaveRequest leave){
    
    
        this.handlerLeave(leave);
        if(this.nextHandler!=null && leave.getNum()>this.numEnd){
    
    
            //提交给上级领导审批
            this.nextHandler.submit(leave);
        }
        else
        {
    
    
            System.out.println("处理完毕");
        }
    }
}

小组长

package com.hupp.responsibility;

/**
 * 小组长
 */
public class GroupLeader extends Handler {
    
    
    public GroupLeader() {
    
    
        super(0, NUM_ONE);
    }

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

部门经理

package com.hupp.responsibility;

/**
 * 部门经理
 */
public class Manager extends Handler{
    
    
    public Manager() {
    
    
        super(NUM_ONE, NUM_THREE);
    }

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

总经理

package com.hupp.responsibility;

public class GeneralManager extends Handler {
    
    
    public GeneralManager() {
    
    
        super(NUM_THREE, NUM_SEVEN);
    }

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

客户端

package com.hupp.responsibility;

public class Client {
    
    
    public static void main(String[] args) {
    
    
        //创建请假条
        LeaveRequest leave = new LeaveRequest("小明", 7, "结婚去了");

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

        //设置上级领导
        groupLeader.setNextHandler(manager);
        manager.setNextHandler(generalManager);

        //提交请假条
        groupLeader.submit(leave);
    }
}

优缺点

• 优点

1. 降低了系统的耦合度，降低请求发送者和接收者的耦合度
2. 增强系统的可扩展性，满足开闭原则。
3. 责任分组处理

• 缺点

1. 不能保证每个请求一定被处理。请求可能传到最后一个接收者也没被处理。
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能可能会受一定的影响
3. 增加了客户端的复杂性。可能会导致职责链的错误设置而导致系统出错，如可能会导致循环调用。