1、架构

Spring Security中认证、授权等功能都是基于过滤器实现的。

在一个web项目中，请求从客户端发起(例如浏览器)，然后穿过层层Filter，最终来到Servlet上，被Servlet处理。
上图中的Filter我们称之为Web Filter，Spring Security中的Filter我们称之为Security Filter，关系图如下：

可以看到，Spring Security Filter0…n 并不是直接嵌入到 Web Filter 中的，而是通过FilterChainProxy来统一管理 Spring Security Filter0…n，FilterChainProxy本身则通过 Spring 提供的DelegatingFilterProxy代理过滤器嵌入到 Web Filter 之中。
FilterChainProxy可以存在多个过滤器链，如下图：

可以看到，当请求到达FilterChainProxy之后，FilterChainProxy会根据请求的路径，将请求转发到不同的SecurityFilterChain上面去，不同的SecurityFilterChain包含了不同的过滤器，也就是不同的请求会经过不同的过滤器。
🤔其中 Spring Security 给我们提供了哪些过滤器呢？默认情况下那些过滤器会被加载呢？

2、源码分析

先把FilterChainProxy源码亮出来，我们一部分一部分来，先从它声明的全局属性上开始：

private final static String FILTER_APPLIED = FilterChainProxy.class.getName().concat(
  ".APPLIED");
private List<SecurityFilterChain> filterChains;
private FilterChainValidator filterChainValidator = new NullFilterChainValidator();

• FILTER_APPLIED 变量是一个标记，用来标记过滤器是否已经执行过了。
• filterChains 是过滤器链集合，其中的泛型是过滤器链，而不是一个个过滤器，配置的多个过滤器链就保存在 filterChains 变量中。
• filterChainValidator 是 FilterChainProxy配置完成后的校验方法，默认使用的 NullFilterChainValidator 实际上对应了一个空方法，也就是不做任何校验。

接下来我们看一个过滤器中最重要的doFilter方法：

@Override
public void doFilter(ServletRequest request, ServletResponse response,
  FilterChain chain) throws IOException, ServletException {
 boolean clearContext = request.getAttribute(FILTER_APPLIED) == null;
 if (clearContext) {
  try {
   request.setAttribute(FILTER_APPLIED, Boolean.TRUE);
   doFilterInternal(request, response, chain);
  }
  finally {
   SecurityContextHolder.clearContext();
   request.removeAttribute(FILTER_APPLIED);
  }
 }
 else {
  doFilterInternal(request, response, chain);
 }
}

在doFilter方法中，正常来说，clearContext 参数每次都应该为 true，于是每次都先给 request 标记上 FILTER_APPLIED 属性，然后执行doFilterInternal方法去走过滤器，执行完毕后，最后在 finally 代码块中清除SecurityContextHolder中保存的用户信息，同时移除 request 中的标记。
按着这个顺序，我们来看看doFilterInternal方法：

private void doFilterInternal(ServletRequest request, ServletResponse response,
  FilterChain chain) throws IOException, ServletException {
 FirewalledRequest fwRequest = firewall
   .getFirewalledRequest((HttpServletRequest) request);
 HttpServletResponse fwResponse = firewall
   .getFirewalledResponse((HttpServletResponse) response);
 List<Filter> filters = getFilters(fwRequest);
 if (filters == null || filters.size() == 0) {
  if (logger.isDebugEnabled()) {
   logger.debug(UrlUtils.buildRequestUrl(fwRequest)
     + (filters == null ? " has no matching filters"
       : " has an empty filter list"));
  }
  fwRequest.reset();
  chain.doFilter(fwRequest, fwResponse);
  return;
 }
 VirtualFilterChain vfc = new VirtualFilterChain(fwRequest, chain, filters);
 vfc.doFilter(fwRequest, fwResponse);
}
private List<Filter> getFilters(HttpServletRequest request) {
 for (SecurityFilterChain chain : filterChains) {
  if (chain.matches(request)) {
   return chain.getFilters();
  }
 }
 return null;
}

doFilterInternal方法就比较重要了！

1. 首先将请求封装成一个FirewalledRequest对象，在这个封装的过程中，也会判断请求是否合法。
2. 对响应进行封装。
3. 调用getFilters()方法找到过滤器链。该方法就是根据当前的请求，从 filterChains 中找到对应的过滤器链，然后由该过滤器链去处理请求。
4. 如果找出来的 filters 为 null，或者集合中没有元素，那就是说明当前请求不需要经过过滤器。直接执行chain.doFilter，这个时候就又回到原生过滤器中去了。那么什么时候会发生这种情况呢？那就是针对项目中的静态资源，如果我们配置了资源放行，如web.ignoring().antMatchers("/hello")，那么当你请求 /hello 接口时就会走到这里来，也就是说不经过 Spring Security Filters。
5. 如果查询到的 filters 是有值的，那么这个 filters 集合中存放的就是我们要经过的过滤器链了。此时它会构造出一个虚拟的过滤器链VirtualFilterChain出来，并执行其中的doFilter方法。

那么接下来我们就来看看VirtualFilterChain：

private static class VirtualFilterChain implements FilterChain {
 private final FilterChain originalChain;
 private final List<Filter> additionalFilters;
 private final FirewalledRequest firewalledRequest;
 private final int size;
 private int currentPosition = 0;
 private VirtualFilterChain(FirewalledRequest firewalledRequest,
   FilterChain chain, List<Filter> additionalFilters) {
  this.originalChain = chain;
  this.additionalFilters = additionalFilters;
  this.size = additionalFilters.size();
  this.firewalledRequest = firewalledRequest;
 }
 @Override
 public void doFilter(ServletRequest request, ServletResponse response)
   throws IOException, ServletException {
  if (currentPosition == size) {
   if (logger.isDebugEnabled()) {
    logger.debug(UrlUtils.buildRequestUrl(firewalledRequest)
      + " reached end of additional filter chain; proceeding with original chain");
   }
   // Deactivate path stripping as we exit the security filter chain
   this.firewalledRequest.reset();
   originalChain.doFilter(request, response);
  }
  else {
   currentPosition++;
   Filter nextFilter = additionalFilters.get(currentPosition - 1);
   if (logger.isDebugEnabled()) {
    logger.debug(UrlUtils.buildRequestUrl(firewalledRequest)
      + " at position " + currentPosition + " of " + size
      + " in additional filter chain; firing Filter: '"
      + nextFilter.getClass().getSimpleName() + "'");
   }
   nextFilter.doFilter(request, response, this);
  }
 }
}

1. VirtualFilterChain类中首先声明了5个全局属性，originalChain 表示原生的过滤器链，也就是 Web Filter；additionalFilters 表示 Spring Security 中的过滤器链；firewalledRequest 表示当前请求；size 表示 Spring Security 中的过滤器链中过滤器的个数；currentPosition 则是过滤器链遍历时候的下标。
2. doFilter方法就是 Spring Security 中过滤器挨个执行的过程，如果currentPosition == size，表示过滤器链已经执行完毕，此时通过调用originalChain.doFilter进入到原生过滤器链方法中，同时退出了 Spring Security 过滤器链。否则就从 additionalFilters 取出 Spring Security 过滤器链中的一个个过滤器，挨个调用 doFilter 方法。