责任链模式（Chain of Responsibility）的目标是使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
在处理用户的请求时可能要根据不同的情况对请求添加不同的处理逻辑，在这时候就可以利用责任链进行设计。当需要添加一个处理逻辑时可以很方便的添加一个处理的节点。
现在我们的需求是处理用户的请求，将用户提交的字符串信息进行层层处理，同时在处理完成之后返回结果时，也要对返回的字符串进行层层处理，而处理返回的情况时其处理的顺序和先前是正好相反的顺序。
首先建立用户的请求和接收对象Request和Response：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. public class Request {
4. String requestStr;
5.
6. public String getRequestStr() {
7. return requestStr;
8. }
9.
10. public void setRequestStr(String requestStr) {
11. this.requestStr = requestStr;
12. }
13.
14. }
[java]view plaincopy
1. package com.lcq.filter;
2.
3. public class Response {
4. String responseStr;
5.
6. public String getResponseStr() {
7. return responseStr;
8. }
9.
10. public void setResponseStr(String responseStr) {
11. this.responseStr = responseStr;
12. }
13.
14. }
我们将处理用户信息的逻辑抽象成为一个个的过滤器，进一步抽象出过滤器接口Filter：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. public interface Filter {
4. public void doFilter(Request request, Response response,FilterChain chain);
5.
6. }
注意在Filte接口中doFilter方法参数中有FilterChain的一个变量，我们再建立FilterChain类：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. public class FilterChain implements Filter {
7. List<Filter> filters = new ArrayList<Filter>();
8. int index = 0;
9.
10. public FilterChain addFilter(Filter f) {
11. this.filters.add(f);
12. return this;
13. }
14.
15. @Override
16. public void doFilter(Request request, Response response, FilterChain chain) {
17. if (index == filters.size())
18. return;
19. Filter f = filters.get(index);
20. index++;
21. f.doFilter(request, response, chain);
22. }
23. }
在FilterChain中继承了Filter接口，从而实现了doFilter方法，在FilterChain中又有一个index变量，该变量是用来 标记当前访问的是哪一个过滤器，这些过滤器是存放在ArrayList中的，这样用户在使用的时候就可以实现自己的过滤器，编写自己的处理逻辑，从而将自 己的过滤器添加到ArrayList中，再调用FilterChain的doFilter方法遍历整个责任链。
下面我们编写三个过滤器：
HTMLFilter类：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. /**
4. * 过滤HTML中的脚本元素
5. * @author lcq
6. *
7. */
8. public class HTMLFilter implements Filter {
9.
10. @Override
11. public void doFilter(Request request, Response response,FilterChain chain) {
12. request.requestStr = request.getRequestStr().replace("<", "[")
13. .replace(">", "] --------HTMLFilter");
14. chain.doFilter(request, response, chain);
15. response.responseStr += "--------HTMLFilter";
16.
17. }
18.
19. }
SesitiveFilter类：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. public class SesitiveFilter implements Filter {
4.
5. @Override
6. public void doFilter(Request request, Response response, FilterChain chain) {
7. request.requestStr = request.getRequestStr().replace("敏感", " ")
8. .replace("猫猫", "haha------SesitiveFilter");
9. chain.doFilter(request, response, chain);
10. response.responseStr += "------SesitiveFilter";
11.
12. }
13.
14. }
FaceFilter类：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. public class FaceFilter implements Filter {
4.
5. @Override
6. public void doFilter(Request request, Response response, FilterChain chain) {
7. request.requestStr = request.getRequestStr().replace(":)",
8. "^V^-------FaceFilter");
9. chain.doFilter(request, response, chain);
10. response.responseStr += "-------FaceFilter";
11.
12. }
13.
14. }
最后编写测试类：
[java]view plaincopy
1. package com.lcq.filter;
2.
3. public class Main {
4. public static void main(String[] args) {
5. String message = "敏感词汇，重庆，<script> 躲猫猫 :)";
6. Request request = new Request();
7. request.setRequestStr(message);
8. Response response = new Response();
9. response.setResponseStr("response");
10. FilterChain fc = new FilterChain();
11. fc.addFilter(new HTMLFilter()).addFilter(new SesitiveFilter());
12.
13. FilterChain fc2 = new FilterChain();
14. fc2.addFilter(new FaceFilter());
15. fc.addFilter(fc2);
16. fc.doFilter(request, response,fc);
17. System.out.println("request = " + request.getRequestStr());
18. System.out.println("response = " + response.getResponseStr());
19. }
20.
21. }
在上面的实例中应该注意两个地方：
1.我们建立的FilterChain中继承了Filter接口，所以在测试类中就可以像使用其他的过滤器一样使用FilterChain，大大提高了灵活性；
2.对于实现责任链的访问处理顺序问题，该问题的解决使用的是递归的思想，从而使先调用的结点在处理返回结果时其调用过滤器的顺序是相反的。这种解决方案在Struts和其他框架中实现过滤器和拦截器使用的较为普遍，并且十分巧妙。
来源：https://www.cnblogs.com/yangkai-cn/archive/2012/12/07/4017334.html