继续整理记录这段时间来的收获，详细代码可在我的Gitee仓库SpringBoot克隆下载学习使用！

6.5 责任链模式

6.5.1 定义

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

6.5.2 结构

• 抽象处理者角色(Handler):定义处理接口，包括抽象处理方法和后继连接
• 具体处理者角色(Concrete Handler)：实现抽象处理者方法，判断能否处理本次请求，若可以处理则处理请求，否则将请求转给后继者
• 客户类角色：创建处理链，并向链头具体处理者对象提交请求，不关心处理细节和请求传递过程

6.5.3 案例(请假)

• 请假条类

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;  
    }  
}

• 抽象处理类

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, int numEnd) {  
        this.numStart = numStart;  
        this.numEnd = numEnd;  
    }  
    public Handler(int numStart) {  
        this.numStart = numStart;  
    }  
//    设置上级领导对象  
    public void setNextHandler(Handler nextHandler) {  
        this.nextHandler = nextHandler;  
    }  
//    各级领导处理请假条的方法  
    protected abstract void handlerLeave(LeaveRequest leaveRequest);  
//    提交请求  
    public final void submit(LeaveRequest leaveRequest)  
    {  
//        该领导进行审批  
        this.handlerLeave(leaveRequest);  
        if(this.nextHandler != null && leaveRequest.getNum() > this.numEnd)  
//            提交上级领导审批  
            this.nextHandler.submit(leaveRequest);  
        else System.out.println("流程结束!");  
    }  
}

• 组长类

public class GroupLeader extends Handler{  
    public GroupLeader(){  
        super(0,Handler.NUM_ONE);  
    }  
    protected void handlerLeave(LeaveRequest leaveRequest){  
        System.out.println(leaveRequest.getName() + "请假" + leaveRequest.getNum() + "天，" + leaveRequest.getContent() + "。");  
        System.out.println("组长同意审批：同意!");  
    }  
}

• 部门经理类

public class ManagerLeader extends Handler{  
    public ManagerLeader(){  
        super(Handler.NUM_ONE,Handler.NUM_THREE);  
    }  
    protected void handlerLeave(LeaveRequest leaveRequest){  
        System.out.println(leaveRequest.getName() + "请假" + leaveRequest.getNum() + "天，" + leaveRequest.getContent() + "。");  
        System.out.println("部门经理同意审批：同意!");  
    }  
}

• 总经理类

public class GeneralManagerLeader extends Handler{  
    public GeneralManagerLeader(){  
        super(Handler.NUM_THREE,Handler.NUM_SEVEN);  
    }  
    protected void handlerLeave(LeaveRequest leaveRequest){  
        System.out.println(leaveRequest.getName() + "请假" + leaveRequest.getNum() + "天，" + leaveRequest.getContent() + "。");  
        System.out.println("总经理同意审批：同意!");  
    }  
}

• 测试

    public static void main(String[] args) {  
//        创建请假条对象  
        LeaveRequest leaveRequest = new LeaveRequest("小明",3,"感冒");  
//        创建领导对象  
        GroupLeader groupLeader = new GroupLeader();  
        ManagerLeader managerLeader = new ManagerLeader();  
        GeneralManagerLeader generalManagerLeader = new GeneralManagerLeader();  
//        设置处理者链  
        groupLeader.setNextHandler(managerLeader);  
        managerLeader.setNextHandler(generalManagerLeader);  
//        提交请假申请  
        groupLeader.submit(leaveRequest);  
    }

• 结果
  
• 类图

6.5.4 优缺点

6.5.4.1 优点

• 降低了对象间耦合度，也降低了请求发送者和接收者的耦合度
• 增强了系统的可拓展性，可根据需要增加新的请求处理类，满足开闭原则
• 增强了给对象指派责任的灵活性，当工作流程发生变化，可以动态地改变链内成员或修改它们的次序，也可动态地修改新增或删除责任
• 责任链简化了对象间的连接，一个对象只需保持一个指向其后继者的引用，不需保持其它所有处理者的引用，这避免使用了较多的if-else语句判断
• 责任分担,每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，复合类的单一职责原则

6.5.4.2 缺点

• 不能保证每个请求一定做处理，由于一个请求没明确的接收者，所以不能保证一定被处理，该请求可能一直传到链的末端都得不到处理
• 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能可能受到一定影响
• 职责链建立的合理性要依靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用

6.5.5源码解析

FilterChain是职责链(过滤器)模式的典型应用，以下是Filter的模拟实现分析：

• 模拟web请求Request以及web响应Response

  public interface Request {  
}
public interface Response {  
}

• 模拟Web过滤器Filter

public interface Filter {  
    public void doFilter(Request request, Response response,FilterChain filterChain);  
}

• 模拟实现具体过滤器

public class FirstFilter implements Filter  
{  
    @Override  
    public void doFilter(Request request, Response response, FilterChain filterChain) {  
        System.out.println("过滤器1 前置处理");  
//        先执行所有request再倒叙执行所有response  
        filterChain.doFilter(request,response);  
        System.out.println("过滤器1 后置处理");  
    }  
}
public class SecondFilter implements Filter  
{  
    @Override  
    public void doFilter(Request request, Response response, FilterChain filterChain) {  
        System.out.println("过滤器2 前置处理");  
//        先执行所有request再倒叙执行所有response  
        filterChain.doFilter(request,response);  
        System.out.println("过滤器2 后置处理");  
    }  
}

• 模拟实现过滤器链FilterChain

public class FilterChain  
{  
    private List<Filter> filters = new ArrayList<>();  
    private int index = 0;  
//    链式调用  
    public FilterChain addFilter(Filter filter){  
        this.filters.add(filter);  
        return this;    }  
    public void doFilter(Request request, Response response)  
    {  
        if(index == filters.size()) return;  
        Filter filter = filters.get(index);  
        index ++;  
        filter.doFilter(request, response,this);  
    }  
}

• 测试

public static void main(String[] args) {  
    Request request = null;  
    Response response = null;  
    FilterChain chain = new FilterChain();  
    chain.addFilter(new FirstFilter()).addFilter(new SecondFilter());  
    chain.doFilter(request, response);  
}

• 结果
  
• 类图