设计模式——责任链（chain of responsibiltiy）

责任链模式在面向对象程式设计里是一种软件设计模式，它包含了一些命令对象和一系列的处理对象。

每一个处理对象决定它能处理哪些命令对象，它也知道如何将它不能处理的命令对象传递给该链中的下一个处理对象。也就是说责任链决定了任务的处理上方和下方。

该模式还描述了往该处理链的末尾添加新的处理对象的方法。<wiki>

1：建立一个filte接口，用来处理客户度发送给服务器端，以及服务器端返回给客户端的消息。

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

2：可以模拟客户端，以及服务器端处理消息的类。

 1 package com.hone.design;
 2 //模拟request
 3 public class Request {
 4     String requestStr;
 5
 6     public String getRequestStr() {
 7         return requestStr;
 8     }
 9     public void setRequestStr(String requestStr) {
10         this.requestStr = requestStr;
11     }
12 }

 1 package com.hone.design;
 2 //模拟response类
 3 public class Response {
 4     String responseStr;
 5
 6     public String getResponseStr() {
 7         return responseStr;
 8     }
 9     public void setResponseStr(String responseStr) {
10         this.responseStr = responseStr;
11     }
12 }

3：我们假设这样一个项目，准备做一个小型的论坛性质的，那么可以用filter对消息进行处理，防止一些敏感的词汇，和一些不恰当的字符。

那么我们肯定要定义filter。

package com.hone.design;
//定义一个filter，用来过滤一些包含了html标签的消息。
public class HTMLFilter implements Filter{
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        //process the html tag <>
                request.requestStr = request.requestStr.replace(‘<‘, ‘[‘)
                           .replace(‘>‘, ‘]‘) + "---HTMLFilter()";
                chain.doFilter(request, response, chain);
                response.responseStr += "---HTMLFilter()";
    }
}

 1 package com.hone.design;
 2
 3 public class SensitiveFilter implements Filter {
 4 //定义一个filter用来过滤一些政治敏感的词汇
 6     @Override
 7     public void doFilter(Request request, Response response, FilterChain chain) {
 8         request.requestStr=request.requestStr.replace("胡锦*涛", "likeqiang")
 9                             +"----SensitiveFilter";
10         chain.doFilter(request, response, chain);
11         response.responseStr +="----SensitiveFilter";
12     }
13 }

4：我们的想法是这样的，用户现在客户端发送一个消息，在client——sever的过程中，先经过HTMLfilter过滤器，在经过SensitiveFilter过滤器到达服务器端。

等待sever处理之后在经过SensitiveFilter——HTMLfilter反馈给client。整过过程的难点是：怎么处理好过滤器之间的处理关系，让filter经过类似于栈的方式来处理消息。

可以考虑用一个FilterChain，用过链的方式来处理filter之间的关系

 1 package com.hone.design;
 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;　　//用来处理filter之间的关系用的
 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()) return ;
18
19         Filter f = filters.get(index);
20         index ++;
21         f.doFilter(request, response, chain);
22     }
23 }

5：用main方法来处理消息。

 1 package com.hone.design;
 2
 3
 4 public class MainTest {
 5     public static void main(String[] args) {
 6         String msg="hello, <你好>，<我不是影帝>就是这么简单，温家宝，就是这么简单的事情";
 7         Request request=new Request();
 8         request.setRequestStr(msg);
 9         Response response=new Response();
10         response.setResponseStr("response");
11         FilterChain fc=new FilterChain();
12         fc.addFilter(new HTMLFilter())
13        　　 .addFilter(new SensitiveFilter());
15         fc.doFilter(request, response, fc);
16         System.out.println(request.getRequestStr());
17         System.out.println(response.getResponseStr());
18     }
20 }

整个消息的处理过程都强调filter 的先后处理顺序。