1.什么是Filter Pattern？
Filter Pattern 也可以叫Intercepting Filter Pattern（拦截过滤器模式），这个范式可以让你在执行原有逻辑（核心逻辑）之前和之后额外执行一系列逻辑，像这样：
2.这个范式能给我们的代码带来什么好处？
Filter Pattern最广为人知的应用莫过于web应用中的servlet filter的，通过filter我们可以实现鉴权逻辑（哪些请求可以被执行下去，哪些不可以），access日志输出（对每个请求都输出日志参数）等。这些filter可以让系统在不修改核心业务逻辑的基础上，按照一定顺序添加切面功能，也就是Aspect Oriented Programming，实现功能的解耦合。
3.如何设计一个Filter Pattern？
首先任何设计模式都离不开应用场景，这里我们我们假定一个典型的http请求响应的逻辑：
public class HttpServlet implements Servlet{
@Override
public Response service(Request request){
Response response = new Response();
response.setData( "RESPONSE OF " + request.getData());
return response;
}
}
此时想在这个service逻辑上层添加print request的逻辑，以及modify request的逻辑，粗放的写法象这样：
public class HttpServlet implements Servlet{
@Override
public Response service(Request request){
System.out.println(request.getData());
request.setData("modify " + request.getData());
Response response = new Response();
response.setData( "RESPONSE OF " + request.getData());
return response;
}
}
这样当然能实现功能，但是代码的可维护性，可读性都会变得很差；于是把print 和 modify功能单独抽取出来like this；
public class HttpServlet implements Servlet{
/**
* 执行filterList，并执行service
* @param request
* @return
*/
public Response doFilter(Request request) {
List<SimpleFilter> simpleFilterList = buildFilterList();
for (SimpleFilter simpleFilter : simpleFilterList) {
simpleFilter.doBefore(request);
}
Response response = this.service(request);
for (SimpleFilter simpleFilter : simpleFilterList) {
simpleFilter.doAfter(response);
}
return response;
}
/**
* 构建Filter List
*/
private List<SimpleFilter> buildFilterList() {
List<SimpleFilter> filterList = new ArrayList<>();
SimpleFilter printFilter = new SimpleFilter() {
@Override
public void doBefore(Request request) {
System.out.println(request);
}
@Override
public void doAfter(Response response) {
//do noting
}
};
SimpleFilter modifyFilter = new SimpleFilter() {
@Override
public void doBefore(Request request) {
request.setData("modify " + request.getData());
}
@Override
public void doAfter(Response response) {
//do noting
}
};
filterList.add(printFilter);
filterList.add(modifyFilter);
return filterList;
}
@Override
public Response service(Request request){
Response response = new Response();
response.setData( "RESPONSE OF " + request.getData());
return response;
}
public interface SimpleFilter {
void doBefore(Request request);
void doAfter(Response response);
}
}
这里实现的逻辑和HandlerInterceptor的思想很像，有兴趣的话可以看看org.springframework.web.servlet.HandlerInterceptor相关的实现，都是在核心代码的前后循环调用interceptor的函数；
但是这里有一个问题，当前版本的代码，SimpleFilter的doBefore方法无法控制流程是否往下走，无法实现类似流控，鉴权相关的功能；当然硬要在此基础上去改也能改出来，只不过不是很优雅，下面尝试另一个东西FilterChain：
4.FilterChain
FilterChain顾名思义，肯定包含一个Filter List并且是用过addFilter方法构建的， 有一个返回参数为Response的doFilter方法，看来是核心入口；看看它的实现类：
public interface FilterChain {
Response doFilter(Request request);
void addFilter(Filter filter);
}
public class ApplicationFilterChain implements FilterChain {
private List<Filter> filters;
//当前执行待执行filter的位置
private int position;
private Servlet servlet;
public ApplicationFilterChain() {
filters = new LinkedList<>();
position = 0;
servlet = new HttpServlet();
}
@Override
public Response doFilter(Request request) {
Filter currentFilter;
if (position < filters.size()){
currentFilter = filters.get(position);
position ++;
//顺序执行filter list
return currentFilter.doFilter(this, request);
}else {
//执行真正的service方法
return servlet.service(request);
}
}
@Override
public void addFilter(Filter filter) {
this.filters.add(filter);
}
}
ApplicationFilterChain 的代码总体符合猜想，但是多了servlet，position属性，position用来定位执行filter的执行位置，servlet放的是核心业务逻辑；
但是doFilter又是串起所有filter和servlet的呢？看一下新的Filter接口参数，以及实现类：
public interface Filter {
Response doFilter(FilterChain filterChain, Request request);
}
public class PrintFilter implements Filter {
@Override
public Response doFilter(FilterChain filterChain, Request request) {
//do my filter
System.out.println("realFilter.doFilter: " + request.getData());
return filterChain.doFilter(request);
}
}
public class ModifyFilter implements Filter {
@Override
public Response doFilter(FilterChain filterChain, Request request) {
request.setData("modified " + request.getData());
return filterChain.doFilter(request);
}
}
doFilter签名是FilterChain和Request，这里的FilterChain的用法是filterChain.doFilter(request)，是用来串起所有filter list；
所以最后的代码执行时序是这样的（算是套了两个函数的递归调用）
filterChain.doFilter -> filter.doFilter -> filterChain.doFilter -> filter.doFilter -> filterChain.doFilter -> servlet.service
Main方法如下：
public class Main {
public static void main(String[] args) {
FilterChain filterChain = buildFilterChain();
Response response = filterChain.doFilter(new Request("request"));
System.out.println(response.getData());
}
/**
* 构建filterChain
* @return
*/
private static FilterChain buildFilterChain() {
FilterChain filterChain = new ApplicationFilterChain();
//修改请求数据filter
Filter modifyDataFilter = new ModifyFilter();
//打印请求数据filter
PrintFilter printFilter = new PrintFilter();
filterChain.addFilter(modifyDataFilter);
filterChain.addFilter(printFilter);
return filterChain;
}
}
debug的线程栈如下图
在这个范式里面主要是FilterChain和Filter两个类的doFilter方法实现逻辑的串联，FilterChain控制每次执行第几个Filter，而Filter执行filter逻辑，并调用FilterChain去执行下一个Filter，如果这个Filter没有调用FilterChain而是直接return了，那么链路就会从当前Filter返回回去。
