【设计模式】责任链模式-号称倒数第二难的设计模式终于搞明白了

引入

汽车生产过程中，必然要对汽车的各个部件，比如发动机、变速箱、车身等等进行严格的质量检查，对不合格的部件进行过滤。

过滤检查汽车部件

一般情况下，我们这样写就能实现了：

public class Client {
    public static void main(String[] args) {
        Client client = new Client();

        Request req = new Request();
        req.setReqMsg("检查发动机，变速箱，车身有没有问题");
        if (req.getReqMsg().contains("车身")) {
            client.doCheckCarbody();
        }
        if (req.getReqMsg().contains("发动机")) {
            client.doCheckEngine();
        }
        if (req.getReqMsg().contains("变速箱")) {
            client.doCheckGearbox();
        }
        if (req.getReqMsg().contains("xxx")) {
            // do something
        }
    }

    public void doCheckEngine () {
        System.out.println("------检查了发动机------");
    }

    public void doCheckCarbody () {
        System.out.println("------检查了车身-------");
    }

    public void doCheckGearbox () {
        System.out.println("------检查了变速箱-----");
    }
}

class Request {
    private String reqMsg;

    public String getReqMsg() {
        return reqMsg;
    }

    public void setReqMsg(String reqMsg) {
        this.reqMsg = reqMsg;
    }
}

but，看到

if (req.getReqMsg().contains("xxx")) {
    // do something
}

这个了吗？这意味着检查的东西增多，if语句也就变多了（好熟悉的代码，哈哈）

如何干掉臃肿的if，优雅的执行汽车部件检查？

针对上面的代码，如果哪天哪个部件获得免检了，不需要检查了，还得去掉某一个if分支，这时候你就恨不得把所有代码都重构了。。。

面向对象有一个词叫封装变化，也就是说哪部分要变化，就封装哪部分，我们可以对处理汽车部件的部分进行封装。

代码如下：

public class Client {
    public static void main(String[] args) {
        Request req = new Request();
        req.setReqMsg("检查发动机，变速箱，车身有没有问题");

        List<Filter> filters = new ArrayList<>();
        filters.add(new CarbodyFilter());
        filters.add(new GearboxFilter());
        filters.add(new EngineFilter());

        for (Filter f : filters) {
            f.doFilter(req);
        }
    }
}

class Request {
    private String reqMsg;

    public String getReqMsg() {
        return reqMsg;
    }

    public void setReqMsg(String reqMsg) {
        this.reqMsg = reqMsg;
    }
}

interface Filter {
    boolean doFilter(Request request);
}

class EngineFilter implements Filter {
    @Override
    public boolean doFilter(Request request) {
        if (request.getReqMsg().contains("发动机")) {
            System.out.println("------检查了发动机------");
        }
        return true;
    }
}

class GearboxFilter implements Filter {
    @Override
    public boolean doFilter(Request request) {
        if (request.getReqMsg().contains("变速箱")) {
            System.out.println("------检查了变速箱------");
        }
        return true;
    }
}

class CarbodyFilter implements Filter {
    @Override
    public boolean doFilter(Request request) {
        if (request.getReqMsg().contains("车身")) {
            System.out.println("------检查了车身------");
        }
        return true;
    }
}

这样一来，如果要对哪个部件进行检查，只需要向

List<Filter> filters = new ArrayList<>();

filters里添加Filter就行了，这个代码是不是稍微有那么点意思了？

没有最优雅，只有更优雅

上个版本的代码，仍需要在Client里面的List<Filter>里添加需要执行的Filter，还是差点意思。

我们来看一下上面描述的场景：

是不是每个Filter各司其职，只要把每个Filter串起来让他们内部去执行就好了！

那我们来写一个FilterChain来把他们串起来：

class FilterChain implements Filter {
    List<Filter> filters = new ArrayList<>();

    //比较骚的写法，这样可以链式调用
    public FilterChain add(Filter filter) {
        filters.add(filter);
        return this;
    }
    //一般写法
//    public void add(Filter filter) {
//        filters.add(filter);
//    }

    @Override
    public boolean doFilter(Request request) {
        for (Filter f : filters) {
            //任何一环检查出了问题，均不往下检查
            if (!f.doFilter(request)) {
                return false;
            }
        }
        return true;
    }
}

这里提一下FilterChain中的add方法，先看一般写法：

public void add(Filter filter) {
    filters.add(filter);
}

然后调用就得这样来搞：

FilterChain chain = new FilterChain();
chain.add(new EngineFilter());
chain.add(new GearboxFilter());
chain.add(new CarbodyFilter());
chain.doFilter(req);

有一种比较骚的写法：

public FilterChain add(Filter filter) {
    filters.add(filter);
    return this;
}

调用：

FilterChain chain = new FilterChain();
chain.add(new EngineFilter())
        .add(new GearboxFilter())
        .add(new CarbodyFilter())
        .doFilter(req);

咦？我在xx源码见过这个写法！感觉瞬间提升了几个档次。

上面的FilterChain版本，其实就是**责任链模式**！！！

似曾相识的FilterChain

没错，如果你开发过Java Web程序，你一定见过这个东西。比如Servlet的Filter，Struts的Interceptor，Spring MVC的HandlerInterceptor。它们本质上都是过滤器或者叫拦截器。

我把刚才的场景稍微变化一下：

模拟了一下Filter和FilterChain：

public class Client {
    public static void main(String[] args) {
        Request request = new Request();
        request.reqMsg = "检查发动机，变速箱，车身有没有问题";
        Response response = new Response();
        response.respMsg = "-------response:";

        FilterChain chain = new FilterChain();
        chain.add(new EngineFilter()).add(new GearboxFilter()).add(new CarbodyFilter());
        chain.doFilter(request, response);

        System.out.println(response.respMsg);
    }
}

class Request {
    String reqMsg;
}

class Response {
    String respMsg;
}

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

class EngineFilter implements Filter {
    public void doFilter(Request request, Response response, FilterChain chain) {
        //先处理request请求
        if (request.reqMsg.contains("发动机")) {
            System.out.println("------EngineFilter 检查了发动机------");
        }
        //通过链条传递处理下一个request
        chain.doFilter(request, response);
        //处理response
        response.respMsg += "---执行了EngineFilter过滤器---";
    }
}

class GearboxFilter implements Filter {
    public void doFilter(Request request, Response response, FilterChain chain) {
        if (request.reqMsg.contains("变速箱")) {
            System.out.println("------GearboxFilter 检查了变速箱------");
        }
        //通过链条传递处理下一个request
        chain.doFilter(request, response);
        //处理response
        response.respMsg += "---执行了GearboxFilter过滤器---";
    }
}

class CarbodyFilter implements Filter {
    public void doFilter(Request request, Response response, FilterChain chain) {
        if (request.reqMsg.contains("车身")) {
            System.out.println("------CarbodyFilter 检查了车身------");
        }
        //通过链条传递处理下一个request
        chain.doFilter(request, response);
        //处理response
        response.respMsg += "---执行了CarbodyFilter过滤器---";
    }
}

class FilterChain {
    List<Filter> filters = new ArrayList<>();
    int filterIndex = 0;

    public FilterChain add(Filter filter) {
        filters.add(filter);
        return this;
    }

    public void doFilter(Request request, Response response) {
        //如果request链条执行完了，就不往下传递了
        if (filterIndex == filters.size()) {
            return;
        }
        Filter f = filters.get(filterIndex);
        filterIndex++;
        f.doFilter(request, response, this);
    }
}

捋一捋：

FilterChain里面定义了一个filterIndex来控制链条顺序执行，并且在每个filter的doFilter里

1. 先处理request
2. 调用chain.doFilter(request, response)传递链条
3. 处理response

看下执行结果：

这些框架的过滤器、拦截器使用的也是责任链模式。

小结

暗示自己：好好学习设计模式，我也能写出优秀的代码！！！

以上。