设计模式之责任链模式-单一职责的完美诠释（chain of responsibility）

问题

责任链模式的引入需要从外观模式和代理模式引入，我们因为不希望顾客不停的和不同部门和人员打交道，设置了接待经理，由接待经理统一负责。又因为接待经理可能会过于繁忙，所以给他请了秘书，代理其工作，减少无谓的交互。即便这样，接待经理仍然忙不过来，就思考给他减负。那么想到的就是其实对于组装电脑的流程是固定的，无需接待经理在中间和各个部门交互，可以固定收银人员收银后交给组装人员组装，组装人员组装后，交给打包人员打包，打包人员打包之后交给接待经理，由接待经理交给顾客。这就是责任链模式

简介

责任链模式的思想几乎遍布在计算机的世界中。计算机网络中的七层模型，每一层都只处理当前层的协议和报文。spring中的拦截器，过滤器也是责任链的思想，我一次接触责任链模式是在学习OkHttp的源码时。有五个拦截器，每个拦截器负责处理不同的功能，并依次传递。我也会用OkHttp中的模式来解决我现在的问题

实现

先设置责任链处理

public class Chain {

    List<Interceptor> interceptors;

    public Request input;
    public Response response;
    public int index;

    public void setInterceptors(List<Interceptor> interceptors) {
        this.interceptors = interceptors;
    }

    Response proceed(Request input, int index) {
        this.input = input;
        this.index = index;

        if (index >= interceptors.size()) {
            System.out.println("done");
            return null;
        }
        response =  interceptors.get(index).intercept(this);
        return response;
    }
}

设置拦截器和拦截器管理类

public interface Interceptor {

    Response intercept(Chain chain);
   
}

public class InterceptorManager {

    private List<Interceptor> interceptors = new ArrayList<>();


    public void addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
    }

    public List<Interceptor> getInterceptors() {
        return interceptors;
    }

}

设置责任链中的输入和输出

public class Request {

    public String request;

    public Computer computer;
}

public class Response {

    public String response;

    public Computer computer;
}

设置具体的拦截器

public class Salesman implements Interceptor {
    @Override
    public Response intercept(Chain chain) {
        System.out.println("salesman get the demand " + chain.input.request + " and get the computer part");
        Request request = new Request();
        request.request = "collect money";
        return chain.proceed(request, chain.index + 1);
    }
}

public class Cashier implements Interceptor {

    @Override
    public Response intercept(Chain chain) {
        System.out.println("Cashier get the request " + chain.input.request);
        Request request = new Request();
        request.request = "pack";
        return chain.proceed(request, chain.index + 1);
    }
}

public class Packer implements Interceptor {
    @Override
    public Response intercept(Chain chain) {
        System.out.println("Packer get the message " + chain.input.request);
        Request request = new Request();
        request.request = "give computer to custom";
        request.computer = new Computer("samsung screen", "intel cpu", "luoji keyboard",
                "common disk", "common engine", "8g cache");
        return chain.proceed(request, chain.index + 1);
    }
}

接待经理作为责任链中的一环，同时也负责责任链的发起

public class Manager implements Interceptor {


    public Computer execute(String demand) {
        Salesman salesman = new Salesman();
        Cashier cashier = new Cashier();
        Packer packer = new Packer();
        Manager manager = new Manager();
        InterceptorManager interceptorManager = new InterceptorManager();
        interceptorManager.addInterceptor(salesman);
        interceptorManager.addInterceptor(cashier);
        interceptorManager.addInterceptor(packer);
        interceptorManager.addInterceptor(manager);

        Chain  chain = new Chain();
        chain.setInterceptors(interceptorManager.getInterceptors());
        Request request = new Request();
        request.request = demand;
        Response response = chain.proceed(request, 0);
        return response.computer;
    }

    @Override
    public Response intercept(Chain chain) {
        System.out.println("manager get the computer " + chain.input.request);
        Response response = new Response();
        response.response = "computer is OK";
        response.computer = chain.input.computer;
        return response;
    }
}

顾客

public class Custom {
    
    Computer buyComputer() {
        Manager manager = new Manager();
        return manager.execute("buy computer");
    }
}

执行代码

    public static void main(String[] args) {
        Custom custom = new Custom();
        Computer computer = custom.buyComputer();
        computer.toString();
    }

执行结果

salesman get the demand buy computer and get the computer part
Cashier get the request collect money
Packer get the message pack
manager get the computer give computer to custom
computer is combined by : ---intel cpu--8g cache---common disk----common engine----luoji keyboard----samsung screen

总结

从实现代码上来看，就能比较清晰的了解责任链模式的优势：单一职责：每一层拦截器只处理自己负责的事；开闭原则：无需修改现有代码，便可以动态添加和删除拦截器；可以动态调整拦截器的顺序；解耦，上层的输出转为下层的输入，直到最后获得结果。其应用场景也比较广泛，基本在大多数分层的结构中，都可以使用责任链模式。例如：军队中，上级命令一层一层向下传递或者士兵侦查的消息一层一层往上传递。再比如：spring中的拦截器，可以动态添加拦截器。