Java设计模式：责任链

责任链模式（Chain of Responsibility）的目标是使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

我们是自2013年创立以来的成都网站建设公司,提供网站建设,电商网站设计开发,外贸网站制作,响应式网页设计,重庆小程序开发、等服务。为客户创造有价值的品牌营销体验，让互联网提升企业的竞争力！

在处理用户的请求时可能要根据不同的情况对请求添加不同的处理逻辑，在这时候就可以利用责任链进行设计。当需要添加一个处理逻辑时可以很方便的添加一个处理的节点。

现在我们的需求是处理用户的请求，将用户提交的字符串信息进行层层处理，同时在处理完成之后返回结果时，也要对返回的字符串进行层层处理，而处理返回的情况时其处理的顺序和先前是正好相反的顺序。

首先建立用户的请求和接收对象Request和Response：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public class Request {  
    4.   
  
  
  4.     String requestStr;  
    5.   
  
  
  5.  
    6.   
  
  
  6.     public String getRequestStr() {  
    7.   
  
  
  7.         return requestStr;  
    8.   
  
  
  8.     }  
    9.   
  
  
  9.  
    10.   
  
  
  10.     public void setRequestStr(String requestStr) {  
    11.   
  
  
  11.         this.requestStr = requestStr;  
    12.   
  
  
  12.     }  
    13.   
  
  
  13.  
    14.   
  
  
  14. }  
    15.  
 
 
 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public class Response {  
    4.   
  
  
  4.     String responseStr;  
    5.   
  
  
  5.  
    6.   
  
  
  6.     public String getResponseStr() {  
    7.   
  
  
  7.         return responseStr;  
    8.   
  
  
  8.     }  
    9.   
  
  
  9.  
    10.   
  
  
  10.     public void setResponseStr(String responseStr) {  
    11.   
  
  
  11.         this.responseStr = responseStr;  
    12.   
  
  
  12.     }  
    13.   
  
  
  13.  
    14.   
  
  
  14. }  
    15.

我们将处理用户信息的逻辑抽象成为一个个的过滤器，进一步抽象出过滤器接口Filter：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public interface Filter {  
    4.   
  
  
  4.     public void doFilter(Request request, Response response,FilterChain chain);  
    5.   
  
  
  5.  
    6.   
  
  
  6. }  
    7.

注意在Filte接口中doFilter方法参数中有FilterChain的一个变量，我们再建立FilterChain类：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. import java.util.ArrayList;  
    4.   
  
  
  4. import java.util.List;  
    5.   
  
  
  5.  
    6.   
  
  
  6. public class FilterChain implements Filter {  
    7.   
  
  
  7.     List filters = new ArrayList();  
    8.   
  
  
  8.     int index = 0;  
    9.   
  
  
  9.  
    10.   
  
  
  10.     public FilterChain addFilter(Filter f) {  
    11.   
  
  
  11.         this.filters.add(f);  
    12.   
  
  
  12.         return this;  
    13.   
  
  
  13.     }  
    14.   
  
  
  14.  
    15.   
  
  
  15.     @Override 
    16.   
  
  
  16.     public void doFilter(Request request, Response response, FilterChain chain) {  
    17.   
  
  
  17.         if (index == filters.size())  
    18.   
  
  
  18.             return;  
    19.   
  
  
  19.         Filter f = filters.get(index);  
    20.   
  
  
  20.         index++;  
    21.   
  
  
  21.         f.doFilter(request, response, chain);  
    22.   
  
  
  22.     }  
    23.   
  
  
  23. }  
    24.

在FilterChain中继承了Filter接口，从而实现了doFilter方法，在FilterChain中又有一个index变量，该变量是用来标记当前访问的是哪一个过滤器，这些过滤器是存放在ArrayList中的，这样用户在使用的时候就可以实现自己的过滤器，编写自己的处理逻辑，从而将自己的过滤器添加到ArrayList中，再调用FilterChain的doFilter方法遍历整个责任链。

下面我们编写三个过滤器：

HTMLFilter类：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. /**  
    4.   
  
  
  4.  * 过滤HTML中的脚本元素  
    5.   
  
  
  5.  * @author lcq  
    6.   
  
  
  6.  *  
    7.   
  
  
  7.  */ 
    8.   
  
  
  8. public class HTMLFilter implements Filter {  
    9.   
  
  
  9.  
    10.   
  
  
  10.     @Override 
    11.   
  
  
  11.     public void doFilter(Request request, Response response,FilterChain chain) {  
    12.   
  
  
  12.         request.requestStr = request.getRequestStr().replace("<", "[")  
    13.   
  
  
  13.                 .replace(">", "] --------HTMLFilter");  
    14.   
  
  
  14.         chain.doFilter(request, response, chain);  
    15.   
  
  
  15.         response.responseStr += "--------HTMLFilter";  
    16.   
  
  
  16.           
    17.   
  
  
  17.     }  
    18.   
  
  
  18.  
    19.   
  
  
  19. }  
    20.

SesitiveFilter类：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public class SesitiveFilter implements Filter {  
    4.   
  
  
  4.  
    5.   
  
  
  5.     @Override 
    6.   
  
  
  6.     public void doFilter(Request request, Response response, FilterChain chain) {  
    7.   
  
  
  7.         request.requestStr = request.getRequestStr().replace("敏感", "  ")  
    8.   
  
  
  8.                 .replace("猫猫", "haha------SesitiveFilter");  
    9.   
  
  
  9.         chain.doFilter(request, response, chain);  
    10.   
  
  
  10.         response.responseStr += "------SesitiveFilter";  
    11.   
  
  
  11.  
    12.   
  
  
  12.     }  
    13.   
  
  
  13.  
    14.   
  
  
  14. }  
    15.

FaceFilter类：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public class FaceFilter implements Filter {  
    4.   
  
  
  4.  
    5.   
  
  
  5.     @Override 
    6.   
  
  
  6.     public void doFilter(Request request, Response response, FilterChain chain) {  
    7.   
  
  
  7.         request.requestStr = request.getRequestStr().replace(":)",  
    8.   
  
  
  8.                 "^V^-------FaceFilter");  
    9.   
  
  
  9.         chain.doFilter(request, response, chain);  
    10.   
  
  
  10.         response.responseStr += "-------FaceFilter";  
    11.   
  
  
  11.  
    12.   
  
  
  12.     }  
    13.   
  
  
  13.  
    14.   
  
  
  14. }  
    15.

***编写测试类：

 
 
 
    
  
  
  
  1. package com.lcq.filter;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public class Main {  
    4.   
  
  
  4.     public static void main(String[] args) {  
    5.   
  
  
  5.         String message = "敏感词汇，重庆，