JAVA23种设计模式之责任链模式

1. 责任链模式
   是一种对象的行为模式，在责任链模式中，很多对象由每一个对象对其下家的引用而连接起来形成一条链，请求在这个链上传递，直到链上的某一个对象决定处理该请求为止。换句话说，就是一个请求发送过来，先有A进行判断自己能否处理，如果能够处理就直接处理掉，不能的话就传递给到B，B也做和A同样的操作，直到有一个将这个请求处理掉为止。
2. 责任链模式示意图
   
3. 责任链模式中的角色

• 抽象处理者角色： 处理请求的接口，通常是一个JAVA抽象类或者是接口，一般会包含一个handleRequest()的抽象方法。
• 具体处理角色： 实现或者继承抽象处理角色。并且重新handleRequest()方法，来判断是直接处理掉请求还是发送给到一下个具体处理角色。

4. 示例代码：
   场景：某公司对于订单按照金额大小可以申请不同的折扣，但是不同金额所需要折扣的审批级别不同，分别为直接上级、经理、副总监、总监审批，具体金额见代码。

• 抽象处理者角色：

public abstract class AbsHandle {
     String leader;
    AbsHandle nextHandler;
    public AbsHandle(String leader) {
        this.leader = leader;
    }
    abstract void handleRequest(Request request);
    public AbsHandle getNextHandler() {
        return nextHandler;
    }
    public void setNextHandler(AbsHandle nextHandler) {
        this.nextHandler = nextHandler;
    }
}

• 具体处理角色：
  直接上级角色：

public class SuperiorHandle extends AbsHandle {
    public SuperiorHandle(String leader) {
        super(leader +" ----superior");
    }
    @Override
    void handleRequest(Request request) {
        float price = request.getOrderPrice();
        if (price <= 10000){
            System.out.println("金额10000以内，由直接上级审批！直接上级为："+this.leader);
        }else{
            getNextHandler().handleRequest(request);
        }
    }
}

经理审批角色：

public class ManagerHandle  extends AbsHandle{
    public ManagerHandle(String leader) {
        super(leader + "Manager");
    }
    @Override
    void handleRequest(Request request) {
        float price = request.getOrderPrice();
        if (price > 10000  && price<=50000){
            System.out.println("金额10000以上50000以内，由经理审批！经理为："+this.leader);
        }else{
            getNextHandler().handleRequest(request);
        }
    }
}

副总监审批角色：

public class DeputyDirectorHandle extends AbsHandle {
    public DeputyDirectorHandle(String leader) {
        super(leader+"-----DeputyDirector");
    }
    @Override
    void handleRequest(Request request) {
        float price = request.getOrderPrice();
        if (price > 50000  && price<=100000){
            System.out.println("金额50000以上100000以内，由副总监审批！副总监为："+this.leader);
        }else{
            getNextHandler().handleRequest(request);
        }
    }
}

总监审批角色：

public class DirectorHandle extends AbsHandle {
    public DirectorHandle(String leader) {
        super(leader+"----------------Director");
    }
    @Override
    void handleRequest(Request request) {
        float price = request.getOrderPrice();
        if (price > 100000  ){
            System.out.println("金额100000以上，由总监审批！总监为："+this.leader);
        }else{
            getNextHandler().handleRequest(request);
        }
    }
}

具体请求：

public class Request {
    private String customer;
    private float orderPrice;
    public Request(String customer, float orderPrice) {
        this.customer = customer;
        this.orderPrice = orderPrice;
    }
    public String getCustomer() {
        return customer;
    }
    public void setCustomer(String customer) {
        this.customer = customer;
    }
    public float getOrderPrice() {
        return orderPrice;
    }
    public void setOrderPrice(float orderPrice) {
        this.orderPrice = orderPrice;
    }
}

测试主函数：

public class Main {
    public static void main(String[] args) {
        Request request = new Request("中国联通",5000);
        Request request1 = new Request("中国移动",50000);
        Request request2 = new Request("sap",80000);
        Request request3 = new Request("weaver",150000);
        AbsHandle superiorHandle = new SuperiorHandle("Tom");
        AbsHandle managerHandle = new ManagerHandle("Jack");
        AbsHandle deputyDirectorHandle = new DeputyDirectorHandle("Mike");
        AbsHandle directorHandle = new DirectorHandle("Tony");
        //关联层级，形成链
        superiorHandle.setNextHandler(managerHandle);
        managerHandle.setNextHandler(deputyDirectorHandle);
        deputyDirectorHandle.setNextHandler(directorHandle);
        superiorHandle.handleRequest(request3);
        superiorHandle.handleRequest(request2);
        managerHandle.handleRequest(request1);
        superiorHandle.handleRequest(request);
    }
}

5. 责任链模式的优缺点
   优点：
   降低了耦合度，将请求者和发送者解耦合；简化具体的责任对象，各个对象只需要处理自身需要处理的内容，不需要考虑其他部分；责任对象便于扩展和删除。
   缺点：
   很多情况下责任链模式会占用一定的内存；无法保证请求一定被执行。这种模式下，排查错误比较麻烦，可能需要对每个对象进行排查。