[Java知识库]设计模式之责任链模式

概述

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

介绍

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

主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

何时使用：在处理消息的时候以过滤很多道。

如何解决：拦截的类都实现统一接口。

关键代码：Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

应用实例： 1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

注意事项：在 JAVA WEB 中遇到很多应用。

责任链模式的构成

抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
信息类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
责任链模式的本质是解耦请求与处理，让请求在处理链中能进行传递与被处理；理解责任链模式应当理解其模式，而不是其具体实现。责任链模式的独到之处是将其节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动起来。

此处来写一个责任链模式的基本实现，包含一个信息类，然后对信息类中的信息通过责任链模式依次进行过滤。

1.首先创建一个信息类

class Msg {
    String msg;

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "Msg{" +
                "msg='" + msg + '\'' +
                '}';
    }
}

2.然后创建一个抽象处理者角色。

interface Filter {
    boolean doFilter(Msg m);
}

3.创建具体处理者角色（此处包含四个角色）

class HTMLFilter implements Filter {
    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replaceAll("<", "[");
        r = r.replaceAll(">", "]");
        m.setMsg(r);
        return true;
    }
}

class SensitiveFilter implements Filter {
    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replaceAll("996", "955");
        m.setMsg(r);
        return false;
    }
}

class FaceFilter implements Filter {
    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replace(":)", "^V^");
        m.setMsg(r);
        return true;
    }
}

class URLFilter implements Filter {
    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replace("blog.csdn.net/lsdstone", "https://blog.csdn.net/lsdstone");
        m.setMsg(r);
        return true;
    }
}

4.再创建一个责任链类，通过add方法将一个个的具体处理角色连接起来，再通过doFilter方法来让请求流动起来。

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

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

    public boolean doFilter(Msg m) {
        for(Filter f : filters) {
            if(!f.doFilter(m)) return false;
        }

        return true;
    }
}

5.现在各个链条都创建好了，那么接下来就创建一个Msg类，并创建责任链条，将信息类中的数据传入进链条。

public class Main {
    public static void main(String[] args) {
        Msg msg = new Msg();
        msg.setMsg("大家好:)，<script>，欢迎访问blog.csdn.net/lsdstone，大家都是996</script> ");

        FilterChain fc = new FilterChain();
        fc.add(new HTMLFilter())
                .add(new SensitiveFilter());

        FilterChain fc2 = new FilterChain();
        fc2.add(new FaceFilter()).add(new URLFilter());

        fc.add(fc2);//此处用到java向上转型的特性，可以将不同的链条串起来

        fc.doFilter(msg);
        System.out.println(msg);

    }
}

运行结果如下图所示，由于SensitiveFilter的返回值设置为false，所以后续的FaceFilter以及URLFilter并没有过滤掉，责任链直接返回了。

下面将SensitiveFilter的返回值改为true结果如下所示。

进阶：模拟Servlet的Filter

说明：
在Filter中传入三个参数，分别是request，response，和ChainFilter，来实现request访问顺序为 （责任链1）->（责任链2）->（责任链3）
response的返回顺序为 （责任链3）->（责任链2）->（责任链1）
此处用到了简单的递归调用：
代码如下：

public class Servlet_Main {
    public static void main(String[] args) {
        Request request = new Request();
        request.str = "大家好:)，<script>，欢迎访问blog.csdn.net/lsdstone，大家都是996</script> ";
        Response response = new Response();
        response.str = "response";

        FilterChain chain = new FilterChain();
        chain.add(new HTMLFilter()).add(new SensitiveFilter());
        chain.doFilter(request, response);
        System.out.println(request.str);
        System.out.println(response.str);

    }
}

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

class HTMLFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        request.str = request.str.replaceAll("<", "[").replaceAll(">", "]") + "HTMLFilter()";
        chain.doFilter(request, response);
        response.str += "--HTMLFilter()";

    }
}

class Request {
    String str;
}

class Response {
    String str;
}

class SensitiveFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        request.str = request.str.replaceAll("996", "955") + " SensitiveFilter()";
        chain.doFilter(request, response);
        response.str += "--SensitiveFilter()";

    }
}


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

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

    public void doFilter(Request request, Response response) {
        if(index == filters.size()) return;
        Filter f = filters.get(index);//此处向上转型
        index ++;

        f.doFilter(request, response, this);
    }
}

运行结果如下所示：

说明：
首先进入main函数创建request和response对象，此处用String来模拟的，然后将责任链串联起来，
再调用FilterChain的dofilter方法此时index为0，执行index++，index在下一次操作的时候值变为2，再进入到第一个HTMLFilter的dofFilter方法，，在request执行完毕后,又通过参数chain继续 调用FilterChain的doFilter方法，此时index=1，再执行index++，下一次index值变为2，然后调用SensitiveFilter的doFilter方法，在request执行完毕后，又会通过chain去调用FilterChain的doFilter方法，但是由于此时责任链条已经走完了，所以反回到SensitiveFilter的response方法，当SensitiveFilter的response方法执行完毕之后，又返回到HTMLFilter的response方法，此时响应完毕，整个request和response1的流程执行完毕。