责任链模式

责任链模式顾名思义就是一个链式的处理结构（如下图），请求只管丢给一个处理者，无需关心最终是被谁处理的，或者是否可以被处理（可能存在请求不被处理的情况）。责任链模式让多个处理者都有机会接收到该请求，如果处理者成功处理，就结束；不处理的话，就交由下一个处理者处理。
图片说明

下面我们通过一个实际的场景来介绍什么是责任链模式。

大家在找工作的时候，最关心的就是自己的薪资，但是薪资一般都需要审批。对于一些薪资低的HR就可以直接审批，高一些薪资的需要主管审批，再高的就需要老板审批。结合该场景，我们介绍一下什么是责任链模式。

1. 低于10000，HR审批
2. 高于10000，低于50000，主管审批
3. 高于50000，老板审批

首先，我们先把HR、主管、老板这三类角色对应的代码写好。

public interface IProcessor {
    /**
     * 返回null，说明需要交给下一个Processor处理
     * 返回true:说明处理成功
     * 返回false:说明处理shib
     */
    Boolean process(int salary);
}

public class HRProcessor implements IProcessor {
    @Override
    public Boolean process(int salary) {
        if (salary < 10000) {
            boolean pass = salary < 5000;
            System.out.println(pass ? "HR审批通过" : "HR审批拒绝");
            return pass;
        }

        // HR无权审批，交给下一位审批
        System.out.println("HR无权审批，交给下一位处理者");
        return null;
    }
}

public class DirectorProcessor implements IProcessor {
    @Override
    public Boolean process(int salary) {
        if (salary < 50000) {
            boolean pass = salary < 35000;
            System.out.println(pass ? "主管审批通过" : "主管审批拒绝");
            return pass;
        }

        // 主管无权审批，交给下一位审批
        System.out.println("主管无权审批，交给下一位处理者");
        return null;
    }
}

public class BossProcessor implements IProcessor {
    @Override
    public Boolean process(int salary) {
        System.out.println("主管审批通过");
        return true;
    }
}

角色组织好了之后，我们需要构建出责任链。

public class ProcessorChain {
    private List<IProcessor> processorList = new ArrayList<>();

    public ProcessorChain addProcessor(IProcessor processor) {
        processorList.add(processor);
        return this;
    }

    public boolean process(int salary) {
        for (IProcessor processor : processorList) {
            Boolean result = processor.process(salary);
            // 如果处理了就结束，否则就继续找下一个处理者
            if (result != null) {
                return result;
            }
        }
        throw new RuntimeException("没有处理者处理该请求");
    }
}

构建好了链式结构，我们就可以在客户端进行调用了。

public class Client {
    public static void main(String[] args) {
        ProcessorChain chain = new ProcessorChain()
                .addProcessor(new HRProcessor())
                .addProcessor(new DirectorProcessor())
                .addProcessor(new BossProcessor());

        chain.process(8000);
        System.out.println("---------------------");
        chain.process(23000);
        System.out.println("---------------------");
        chain.process(70000);
    }
}

// 输出内容如下
HR审批拒绝
---------------------
HR无权审批，交给下一位处理者
主管审批通过
---------------------
HR无权审批，交给下一位处理者
主管无权审批，交给下一位处理者
主管审批通过

通过上面的代码可以看到，客户端其实只管把请求交出去就好，无需关心到底被谁处理。使得请求发送者和处理者进行解耦。