设计模式 —— 责任链模式

概述
UML
实现
优缺点

概述：

责任链模式是 行为型 设计模式的一种。如其名一般，责任链模式使每个处理器依次连接在一起成为一条链，用户的请求任务顺着这条链传递，直到符合条件的处理器将其处理返回。

定义：避免请求者和发送者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止

适用场景：当同一种请求可能被不同对象处理时，使用责任链让请求传递，到达对应对象处理返回

UML：

Handler：处理器接口
- setNextHandler方法：允许设置责任链的下一位，参数为下一位，无返回
- handler方法：处理方法，责任链上的处理器都要符合处理方法（同一参数和返回，防止错误）
ConcreateHandler：处理器，实现处理器接口，有多少个处理器定义多少个类
- nextHandler方法：设置下一位处理器
- handler方法：处理请求

实现：

实现背景：员工A希望更新个人项目设备，向公司提出报销请求，数额为15w。每位领导权力不一样，能批付的金额也不一致，假设员工A的项目组长最大能批1w，部门经理批5w，总裁批20w。员工A会和项目组长沟通，但是15w金额超过项目组长的最大批付额，所以项目组长找到部门经理，有因为15w大于5W，部门经理找到总裁，总裁批准了，当然，如果大于20w就返回请求失败。

设计Handler接口（处理器接口）

public interface UseHandler {
    void setNextHandler(UseHandler nexthandler);
    boolean handle(int amount);
}

此处设计依据实际需要开发，返回boolean是因为我只需要直到amount值够不够就好

设计各处理器

// 项目组长
public class GroupLeader implements UseHandler {
    private UseHandler nextHandler;
    private int maxMoney = 10_000;
    
    public void setNextHandler(UseHandler nextHandler){
        this.nextHandler = nextHandler;
    }
    
    public boolean handler(int amount){
        if(amount < maxMoney){
            System.out.println("项目组长批准");
            return true;
        }
        System.out.println("超过我的限额，请求项目经理批准");
        return nextHandler.handler(amount);
    }
}

// 项目经理
public class Manager implements UseHandler {
    private UseHandler nextHandler;
    private int maxMoney = 50_000;
    
    public void setNextHandler(UseHandler nextHandler){
        this.nextHandler = nextHandler;
    }
    
    public boolean handler(int amount){
        if(amount < maxMoney){
            System.out.println("项目经理批准");
            return true;
        }
        System.out.println("超过我的限额，请求更高级批准");
        return nextHandler.handler(amount);
    }
}

// 总裁
public class Leader implements UseHandler {
    private UseHandler nextHandler;
    private int maxMoney = 200_000;
    
    public void setNextHandler(UseHandler nextHandler){
        this.nextHandler = nextHandler;
    }
    
    public boolean handler(int amount){
        if(amount < maxMoney){
            System.out.println("总裁批准");
            return true;
        }
        System.out.println("太贵了");
        return false;
    }
}

客户端连接各处理器，处理请求

public class processor {
    public void Use(){
        GroupLeader groupleader = new GroupLeader();
        Manager manager = new Manager();
        Leader leader = new Leader();
        
        leader.setNextHandler(manager);
        manager.setNextHander(groupleader);
        
        System.out.println("我这有20w需要报销");
        if(groupleader.handler(150_000)){
            System.out.println("谢谢领导");
        }else{
            System.out.println("无法报销，我知道了");
        }
    }
}

输出：

我这有20w需要报销

超过我的限额，请求项目经理批准

超过我的限额，请求更高级批准

总裁批准

谢谢领导

优缺点：

优点：命令发出者和执行者解耦，单条命令可以让多个处理器处理，针对不同问题能区别处理

缺点：需要管理的类增多了，如果处理不合理可能形成环导致请求无法完成