责任链模式

简单介绍一下什么是责任链模式？

如果您了解Servlet规范的话，一定会知道Filter；如果您使用过Struts2的话，一定清楚无处不在的interceptor。责任链模式顾名思义，对一个请求设计出一个链状的处理流程，处于链条上的每个类都可以处理这个请求，或者放弃对请求的处理然后交给链条上的下一个类。

如果你没有学过Filter或者interceptor，没关系，给出Filter的原理图你就会发现其实它们很简单

原理图：下面是没有使用Filter的web应用



下面是使用了Filter的web应用



当客户端发出Web资源的请求时，Web服务器根据应用程序配置文件设置过滤规则进行检查，若客户请求满足过滤规则，则对客户请求/响应进行拦截，对请求头和请求数据检查或改动，并以此通过过滤器链，最后把请求/响应交给请求的Web资源处理。请求信息在过滤器链中可以被修改，也可以根据时间让请求不发往资源处理器，并直接向客户机发回一个响应。当资源处理器完成了对资源的处理后，响应信息将逐级逆向返回。同样在这个过程中，用户可以修改响应信息，从而完成一定的任务。

实例：来源于马士兵老师的视频，这个实例简单地模拟了Servlet的Filter功能

案例1：实现了将Msg由客户端向服务器端的过滤，如下图清晰地解析了程序的执行过程



Main类：调用MsgProcessor类的process()方法完成对客户端信息的过滤处理

public class Main {

public static void main(String[] args) {
String msg = "大家好:)，<script>，敏感，被就业，网络授课没感觉，因为看不见大家伙儿";
MsgProcessor mp = new MsgProcessor();
mp.setMsg(msg);
FilterChain fc = new FilterChain();
fc.addFilter(new HTMLFilter())
.addFilter(new SesitiveFilter())
;
FilterChain fc2 = new FilterChain();
fc2.addFilter(new FaceFilter());

fc.addFilter(fc2);
mp.setFc(fc);
String result = mp.process();
System.out.println(result);
}

}

MsgProcessor类：中间类，实际上是调用FilterChain的doFilter()方法

public class MsgProcessor {
private String msg;

//Filter[] filters = {new HTMLFilter(), new SesitiveFilter(), new FaceFilter()};
FilterChain fc;

public FilterChain getFc() {
return fc;
}

public void setFc(FilterChain fc) {
this.fc = fc;
}

public String getMsg() {
return msg;
}

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

public String process() {

return fc.doFilter(msg);

}
}

定义接口类Filter

public interface Filter {
String doFilter(String str);
}

3个具体实现上面接口的类

SesitiveFilter类

public class SesitiveFilter implements Filter {

@Override
public String doFilter(String str) {
//process the sensitive words
String r = str.replace("被就业", "就业")
.replace("敏感", "");

return r;
}

}

FaceFilter类

public class FaceFilter implements Filter {

@Override
public String doFilter(String str) {
return str.replace(":)", "^V^");
}

}

HTMLFilter类

public class HTMLFilter implements Filter {

@Override
public String doFilter(String str) {
//process the html tag <>
String r = str.replace('<', '[')
.replace('>', ']');
return r;
}

}

FilterChain类：完成对Filter类的批量处理

import java.util.ArrayList;
import java.util.List;

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

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

public String doFilter(String str) {
String r = str;
for(Filter f: filters) {
r = f.doFilter(r);
}
return r;
}
}

上面的案例只能实现单一方向的过滤，而实际上，在web应用中，客户端和服务器端的响应通常是这样的：

同一个Filter既对客户端发往服务器端的消息进行过滤处理，又对服务器端发往客户端的消息进行过滤处理。

案例2：如下图清晰地解析了程序的执行过程



A B C

现在就真正在模拟Servlet的Filter功能或Struts的Intecerpter功能了，这里我们用Request对象封装客户端的请求信息，用Response对象封装服务器端反馈回来的信息。

因为Filter是在FilterChain中，信息的过滤处理类似于栈的结构，比如在客户端往服务器端处理的过程中，是排在前面A的Filter先处理，排在后面的c后处理；而在服务器端往客户端处理过程中，是排在后面的C先处理，排在前面的A后处理,怎么处理呢？

可以这样考虑：将FilterChain的引用传递给Filter,因为FilterChain中包含了排列好了的Filter,若是信息被过滤器A执行处理，将获得FilterChain对象，信息将会按照FilterChain中的Filter的顺序执行下去

Request对象：封装客户端发送的信息

public class Request {
String requestStr;

public String getRequestStr() {
return requestStr;
}

public void setRequestStr(String requestStr) {
this.requestStr = requestStr;
}
}

Response对象：封装服务器端反馈的信息

public class Response {
String responseStr;

public String getResponseStr() {
return responseStr;
}

public void setResponseStr(String responseStr) {
this.responseStr = responseStr;
}

}

接口类： Filter

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

实现上述接口的两个类：

SesstiveFilter:处理敏感信息

public class SesitiveFilter implements Filter {

@Override
public void doFilter(Request request, Response response, FilterChain chain) {
request.requestStr = request.requestStr.replace("被就业", "就业")
.replace("敏感", "") + "---SesitiveFilter()";
chain.doFilter(request, response, chain);
response.responseStr += "---SesitiveFilter()";
}

}

HTMLFilter：处理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()";
}

}

FilterChain：下面的着红色的代码解决了Response对象逆向被Filter处理

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

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

@Override
public void doFilter(Request request, Response response, FilterChain chain) {
if(index == filters.size()) return ;

Filter f = filters.get(index);
index ++;
f.doFilter(request, response, chain);
}
}

测试代码：

public class Main {

/**
* 模拟Servlet中Request和Response的调用过程
*/
public static void main(String[] args) {
String msg = "大家好:)，<script>，敏感，被就业，网络授课没感觉，因为看不见大家伙儿";
Request request = new Request();
request.setRequestStr(msg);
Response response = new Response();
response.setResponseStr("response");
FilterChain fc = new FilterChain();
fc.addFilter(new HTMLFilter())
.addFilter(new SesitiveFilter())
;

fc.doFilter(request, response, fc);
System.out.println(request.getRequestStr());
System.out.println(response.getResponseStr());
}

}

下面是测试结果：

大家好:)，[script]，，就业，网络授课没感觉，因为看不见大家伙儿---HTMLFilter()---SesitiveFilter()
response---SesitiveFilter()---HTMLFilter()