实现FilterChain - 码友园地

上一节我们实现了ServletContext，并且能够管理所有的Servlet组件。本节我们继续增加对Filter组件的支持。

Filter是Servlet规范中的一个重要组件，它的作用是在HTTP请求到达Servlet之前进行预处理。它可以被一个或多个Filter按照一定的顺序组成一个处理链（FilterChain），用来处理一些公共逻辑，比如打印日志、登录检查等。

Filter还可以有针对性地拦截或者放行HTTP请求，本质上一个FilterChain就是一个责任链模式。在Servlet容器中，处理流程如下：

 ┌─────────────────┐
 │ ServletContext │
 │ ┌ ─ ─ ─ ─ ─ ─ ┐ │
 │  FilterChain  │
 │ │ ┌─────────┐ │ │
──┼──▶│ Filter │  │
 │ │ └─────────┘ │ │
 │    │    │
 │ │   ▼   │ │
 │  ┌─────────┐  │
 │ │ │ Filter │ │ │
 │  └─────────┘  │
 │ │   │   │ │
 │    ▼    │
 │ │ ┌─────────┐ │ │
 │  │ Filter │  │
 │ │ └─────────┘ │ │
 │ ─ ─ ─ ┬ ─ ─ ─ │
 │    ▼    │
 │  ┌─────────┐  │
 │  │ Servlet │  │
 │  └─────────┘  │
 └─────────────────┘

这里有几点需要注意：

最终处理请求的Servlet是根据请求路径选择的；
Filter链上的Filter是根据请求路径匹配的，可能匹配0个或多个Filter；
匹配的Filter将组成FilterChain进行调用。

下面，我们首先将Filter纳入ServletContext中管理。和ServletMapping类似，先定义FilterMapping，它包含一个Filter实例，以及将映射路径编译为正则表达式：

public class FilterMapping {
  final Pattern pattern; // 编译后的正则表达式
  final Filter filter;

  public FilterMapping(String urlPattern, Filter filter) {
    this.pattern = buildPattern(urlPattern); // 编译为正则表达式
    this.filter = filter;
  }
}

接着，根据Servlet规范，我们需要提供addFilter()动态添加一个Filter，并且返回FilterRegistration.Dynamic，所以需要在ServletContext中实现相关方法：

public class ServletContextImpl implements ServletContext {
  Map<String, FilterRegistrationImpl> filterRegistrations = new HashMap<>();
  Map<String, Filter> nameToFilters = new HashMap<>();
  List<FilterMapping> filterMappings = new ArrayList<>();

  // 根据Class Name添加Filter:
  @Override
  public FilterRegistration.Dynamic addFilter(String name, String className) {
    return addFilter(name, Class.forName(className));
  }

  // 根据Class添加Filter:
  @Override
  public FilterRegistration.Dynamic addFilter(String name, Class<? extends Filter> clazz) {
    return addFilter(name, clazz.newInstance());
  }

  // 根据Filter实例添加Filter:
  @Override
  public FilterRegistration.Dynamic addFilter(String name, Filter filter) {
    var registration = new FilterRegistrationImpl(this, name, filter);
    this.filterRegistrations.put(name, registration);
    return registration;
  }
  ...
}

再添加一个initFilters()方法用于向容器添加Filter：

public class ServletContextImpl implements ServletContext {
  ...
  public void initFilters(List<Class<?>> filterClasses) {
    for (Class<?> c : filterClasses) {
      // 获取@WebFilter注解:
      WebFilter wf = c.getAnnotation(WebFilter.class);
      // 添加Filter:
      FilterRegistration.Dynamic registration = this.addFilter(AnnoUtils.getFilterName(clazz), clazz);
      // 添加URL映射:
      registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, AnnoUtils.getFilterUrlPatterns(clazz));
      // 设置初始化参数:
      registration.setInitParameters(AnnoUtils.getFilterInitParams(clazz));
    }
    for (String name : this.filterRegistrations.keySet()) {
      // 依次处理每个FilterRegistration.Dynamic:
      var registration = this.filterRegistrations.get(name);
      // 调用Filter.init()方法:
      registration.filter.init(registration.getFilterConfig());
      this.nameToFilters.put(name, registration.filter);
      // 将Filter定义的每个URL映射编译为正则表达式:
      for (String urlPattern : registration.getUrlPatternMappings()) {
        this.filterMappings.add(new FilterMapping(urlPattern, registration.filter));
      }
    }
  }
  ...
}

这样，我们就完成了对Filter组件的管理。

下一步，是改造process()方法，把原来直接把请求扔给Servlet处理，改成先匹配Filter，处理后再扔给最终的Servlet：

public class ServletContextImpl implements ServletContext {
  ...
  public void process(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    // 获取请求路径:
    String path = request.getRequestURI();
    // 查找Servlet:
    Servlet servlet = null;
    for (ServletMapping mapping : this.servletMappings) {
      if (mapping.matches(path)) {
        servlet = mapping.servlet;
        break;
      }
    }
    if (servlet == null) {
      // 404错误:
      PrintWriter pw = response.getWriter();
      pw.write("<h1>404 Not Found</h1><p>No mapping for URL: " + path + "</p>");
      pw.close();
      return;
    }
    // 查找Filter:
    List<Filter> enabledFilters = new ArrayList<>();
    for (FilterMapping mapping : this.filterMappings) {
      if (mapping.matches(path)) {
        enabledFilters.add(mapping.filter);
      }
    }
    Filter[] filters = enabledFilters.toArray(Filter[]::new);
    // 构造FilterChain实例:
    FilterChain chain = new FilterChainImpl(filters, servlet);
    // 由FilterChain处理:
    chain.doFilter(request, response);
  }
  ...
}

注意上述FilterChain不仅包含一个Filter[]数组，还包含一个Servlet，这样我们调用chain.doFilter()时，在FilterChain中最后一个处理请求的就是Servlet，这样设计可以简化我们实现FilterChain的代码：

public class FilterChainImpl implements FilterChain {
  final Filter[] filters;
  final Servlet servlet;
  final int total; // Filter总数量
  int index = 0; // 下一个要处理的Filter[index]

  public FilterChainImpl(Filter[] filters, Servlet servlet) {
    this.filters = filters;
    this.servlet = servlet;
    this.total = filters.length;
  }

  @Override
  public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
    if (index < total) {
      int current = index;
      index++;
      // 调用下一个Filter处理:
      filters[current].doFilter(request, response, this);
    } else {
      // 调用Servlet处理:
      servlet.service(request, response);
    }
  }
}

注意FilterChain是一个递归调用，因为在执行Filter.doFilter()时，需要把FilterChain自身传进去，在执行Filter.doFilter()之前，就要把index调整到正确的值。

我们编写两个测试用的Filter：

LogFilter：匹配/*，打印请求方法、路径等信息；
HelloFilter：匹配/hello，根据请求参数决定放行还是返回403错误。

在初始化ServletContextImpl时将Filter加进去，先测试http://localhost:8080/：

观察后台输出，LogFilter应该起作用：

16:48:00.304 [HTTP-Dispatcher] INFO c.i.j.engine.filter.LogFilter -- GET: /

再测试http://localhost:8080/hello?name=Bob：

观察后台输出，HelloFilter和LogFilter应该起作用：

16:49:31.409 [HTTP-Dispatcher] INFO c.i.j.engine.filter.HelloFilter -- Check parameter name = Bob
16:49:31.409 [HTTP-Dispatcher] INFO c.i.j.engine.filter.LogFilter -- GET: /hello

最后测试http://localhost:8080/hello?name=Jim：

可以看到，HelloFilter拦截了请求，返回403错误，最终的HelloServlet并没有处理该请求。

现在，我们就成功地在ServletContext中实现了对Filter的管理，以及根据每个请求，构造对应的FilterChain来处理请求。目前还有几个小问题：

一是和Servlet一样，Filter本身应该是Web App开发人员实现，而不是由服务器实现。我们在在服务器中写死了两个Filter，这个问题后续解决；

二是Servlet规范并没有规定多个Filter应该如何排序，我们在实现时也没有对Filter进行排序。如果要按固定顺序给Filter排序，从Servlet规范来说怎么排序都可以，通常是按@WebFilter定义的filterName进行排序，Spring Boot提供的一个FilterRegistrationBean允许开发人员自己定义Filter的顺序。

参考源码

可以从GitHub或Gitee下载源码。

GitHub

小结

实现FilterChain时，要首先在ServletContext内完成所有Filter的初始化和映射，然后，根据请求路径匹配所有合适的Filter和唯一的Servlet，构造FilterChain并处理请求。

转载