Spring Security 6.x 过滤器链SecurityFilterChain是如何工作的

上一篇主要介绍了Spring Secuirty中的过滤器链SecurityFilterChain是如何配置的，那么在配置完成之后，SecurityFilterChain是如何在应用程序中调用各个Filter，从而起到安全防护的作用，本文主要围绕SecurityFilterChain的工作原理做详细的介绍。

一、Filter背景知识

因为Spring Security底层依赖Servlet的过滤器技术，所以先简单地回顾一下相关背景知识。
过滤器Filter是Servlet的标准组件，自Servlet 2.3版本引入，主要作用是在Servlet实例接受到请求之前，以及返回响应之后，这两个方向上进行动态拦截，这样就可以与Servlet主业务逻辑解耦，从而实现灵活性和可扩展性，利用这个特性可以实现很多功能，例如身份认证，统一编码，数据加密解密，审计日志等等。
Filter接口定义了3个方法：doFilter，init和destory，其中doFilter就是请求进入过滤器时需要执行的逻辑，伪代码实现如下

public class ExampleFilter implements Filter {
    …
    public void doFilter(ServletRequest request, ServletResponse response,
                            FilterChain chain) throws IOException, ServletException {
        doSomething();
        chain.doFilter(request,response);    
    }
    …
}

其中FilterChain中维护了一个所有已注册的过滤器数组，它组成了真正的“过滤器链”，下面是FilterChain的实现类ApplicationFilterChain的部分源码：当请求到达Servlet容器时，就会创建出一个FilterChain实例，然后调用FilterChain#doFilter方法，这时会从数组中取出下一个过滤器，并调用Filter#doFilter方法，在方法末尾又会将请求继续交由FilterChain处理，如此往复，从而实现职责链模式的调用方式。

private void internalDoFilter(ServletRequest request, ServletResponse response)
        throws IOException, ServletException {

    // Call the next filter if there is one
    if (pos < n) {
        ApplicationFilterConfig filterConfig = filters[pos++];
        try {
            Filter filter = filterConfig.getFilter();
            ...
            if (Globals.IS_SECURITY_ENABLED) {
               // ...
            } else {
                filter.doFilter(request, response, this);
            }
        } catch (...) {
          ...
        }
        return;
    }

    // We fell off the end of the chain -- call the servlet instance
    try {
        ...
        // Use potentially wrapped request from this point
        if ((request instanceof HttpServletRequest) && (response instanceof HttpServletResponse) &&
                Globals.IS_SECURITY_ENABLED) {
           ...
        } else {
            servlet.service(request, response);
        }
    } catch (...) {
       ...
    } finally {
       ...
    }
}

Filter实例可以在web.xml中注册，同时设置URL映射逻辑，当URL符合设置的规则时，便会进入该Filter，举个例子，在Spring Boot问世之前开发一个普通的Spring MVC应用时，经常会配置一个CharacterEncodingFilter，用于统一请求和响应的编码，以避免一些中文乱码的问题

<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern> <!-- 相当于拦截所有请求 -->
</filter-mapping>

二、SecurityFilterChain的必要性

再回到SecurityFilterChain，先来思考一个问题：基于上面所介绍的Filter，我们自然会想到，定义一系列与安全相关的Filter，例如我们在上一篇提到的那些包括认证，鉴权等在内的Filter，然后只要把他们一个个注册到FilterChain中，就可以实现各种安全特性，看起来也并不需要Spring Security提供的SecuriyFilterChain，也正因如此，初学者经常会有一个疑问，就是明明加一个Filter就可以解决的事，为什么搞得这么复杂？
那么SecurityFilterChain的必要性是什么？我们一层一层逐步说明这个问题：

1. 首先要解决的是如何在Filter中获取Spring容器中Bean对象，因为在Servlet容器中启动时，各个Filter的实例便会初始化并完成注册，此时Spring Bean对象还没有完成整个加载过程，不能直接注入，不过很容易想到，可以用一个“虚拟”的Filter在Servlet容器启动时先完成注册，然后在执行doFilter时，再获取对应的Spring Bean作为实际的Filter实例，执行具体的doFilter逻辑，这是一个典型的委派模式，Spring Security为此提供了一个名为DelegatingFilterProxy的类，下文再作详细介绍。
2. 解决了Spring Bean容器与Servlet Filter整合的问题之后，我们是否可以将每一个Filter都通过DelegatingFilterProxy的模式添加到FilterChain中？试想一下，如果每个Spring Security的Filter都分别创建一个独立的委派类，那么通过ApplicationContext查找bean的代码就会反复出现，这在很大程度上违背了依赖注入的原则，也极大了增加了维护成本和开发成本，为了解决这个问题，在上述DelegateFilterProxy基础上，Spring Security又引入了一个代理类FilterChainProxy，它可以看作是Spring Security Filter的统一入口，此时，从Servlet的FIlterChain角度来看，整个Spring Security只定义了一个Filter，即DelegatingFilterProxy，而执行doFilter时则委派给了FilterChainProxy，这样就可以利用这个入口简化很多工作，例如官方文档中提到，可以在调试Spring Security功能时，将断点设置在这个入口，方便我们跟踪定位问题等等
3. FilterChainProxy作为统一收口，同时也起到了打通SecurityFilterChain的桥梁作用，在调用doFilter方法时，实际上都交给某个SecurityFilterChain实例执行，到这里请求才算是进入了我们使用HttpSecurity配置的各个Filter，而在执行SecurityFilterChain的前后位置，又可以统一添加一些处理，例如添加Spring Security的防火墙HttpFirewall，用以防范某些特定类型的攻击
4. 最后还有一点，Servlet Filter本身也存在一定的局限性，例如映射配置不够灵活，只能根据URL进行匹配，而SecurityFilterChain通过RequestMatcher接口实现了不同匹配逻辑及组合，大大丰富了匹配规则映射的能力

综上所述，通过DelegatingFilterProxy->FilterChainProxy->SecurityFilterChain这样的三层结构关系，使得SecurityFilterChain中的各个Filter被当成了一个整体，置于Servlet FilterChain之中，又能和其他的Filter独立开，不论我们如何配置SecurityFilterChain，都不会引起Servlet FilterChain的变更，这样的设计很好地遵循了开放封闭原则，即对Servlet Filter的修改是保持封闭的，而对Spring Security Filter的配置和扩展是保持开放的。
其实，我们在很多Spring的框架中，都可以见到这种设计，本质上来说，即通过添加一个中间层来达到解耦的目的，我们应该深入地理解这种设计，并学以致用。

三、SecuriyFilterChain的工作原理

讨论完SecurityFilterChain必要性，再来介绍SecurityFilterChain的工作原理就会变得比较好理解了

1. 注册DelegatingFilterProxy

在非Spring Boot环境可以通过web.xml进行注册，配置如下：

<filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>

<filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

而在Spring Boot环境下，则是通过RegistrationBean的方式注册Servlet组件，具体实现类为DelegatingFilterProxyRegistrationBean，它由SecurityFilterAutoConfiguration配置类创建出来，并在Servlet容器启动的时候完成Filter的注册。
完成注册后，当Servlet容器启动时，FilterChain就包含了DelegatingFilterProxy这个Filter。

2.委派FilterChainProxy

上文提到在执行DelegatingFilterProxy的doFilter方法时，实际上都是交给FilterChainProxy来执行，它是由Spring容器托管的bean对象，通过下面WebSecurityConfiguration配置类源码可以看到，其中定义了一个名称为“springSecurityFilterChain”的Bean，而其中webSecurity#build方法返回的就是FilerChainProxy的实例，其构建过程和上一篇介绍的HttpSecurity类似，这里就不再展开。

@Bean(name = AbstractSecurityWebApplicationInitializer.DEFAULT_FILTER_NAME) // "springSecurityFilterChain"
public Filter springSecurityFilterChain() throws Exception {
    ...
    return this.webSecurity.build();
}

委派过程比较简单，下面是DelegatingFilterProxy#doFilter方法的源码（可以忽略并发控制的代码），当请求进入doFilter之后，首先调用initDelegate方法，这里利用Spring的ApplicationContext#getBean方法获取名为“springSecurityFilterChain“的bean对象，即FilterChainProxy，然后调用其doFilter方法，这样就完成了委派调用。

public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
       throws ServletException, IOException {

    // Lazily initialize the delegate if necessary.
    Filter delegateToUse = this.delegate;
    if (delegateToUse == null) {
       synchronized (this.delegateMonitor) {
          delegateToUse = this.delegate;
          if (delegateToUse == null) {
             WebApplicationContext wac = findWebApplicationContext();
             if (wac == null) {
                throw new IllegalStateException("No WebApplicationContext found: " +
                      "no ContextLoaderListener or DispatcherServlet registered?");
             }
             delegateToUse = initDelegate(wac);
          }
          this.delegate = delegateToUse;
       }
    }

    // Let the delegate perform the actual doFilter operation.
    invokeDelegate(delegateToUse, request, response, filterChain);
}

protected Filter initDelegate(WebApplicationContext wac) throws ServletException {
    String targetBeanName = getTargetBeanName(); // "springSecurityFilterChain"
    Assert.state(targetBeanName != null, "No target bean name set");
    Filter delegate = wac.getBean(targetBeanName, Filter.class);
    if (isTargetFilterLifecycle()) {
       delegate.init(getFilterConfig());
    }
    return delegate;
}

protected void invokeDelegate(
       Filter delegate, ServletRequest request, ServletResponse response, FilterChain filterChain)
       throws ServletException, IOException {

    delegate.doFilter(request, response, filterChain);
}

3. 执行SecurityFilterChain的过滤器链

严格来说，最终执行doFilter的并不是SecuritFilterChain，FilterChainProxy内部维护了一个SecurityFilterChain的List列表，在调用doFilter方法时，会根据SecurityFilterChain#match方法匹配的结果决定选择某一个SecurityFilterChain，然后取出该SecurityFilterChain所有的Filter，用其构造一个VirtualFilterChain，这才是实际意义上过滤器链执行的入口。

private void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
       throws IOException, ServletException {
    FirewalledRequest firewallRequest = this.firewall.getFirewalledRequest((HttpServletRequest) request);
    HttpServletResponse firewallResponse = this.firewall.getFirewalledResponse((HttpServletResponse) response);
    List<Filter> filters = getFilters(firewallRequest); // 重点关注这个方法，获取到某个SecurityFilterChain的所有Filter
    if (filters == null || filters.size() == 0) {
        ...
       firewallRequest.reset();
       this.filterChainDecorator.decorate(chain).doFilter(firewallRequest, firewallResponse);
       return;
    }
     ...
    FilterChain reset = (req, res) -> {
          ...
       // Deactivate path stripping as we exit the security filter chain
       firewallRequest.reset();
       chain.doFilter(req, res);
    };
    // 装饰器模式，实际上返回了VirtualFilterChain的实例
    this.filterChainDecorator.decorate(reset, filters).doFilter(firewallRequest, firewallResponse);
}

private List<Filter> getFilters(HttpServletRequest request) {
    int count = 0;
    for (SecurityFilterChain chain : this.filterChains) {
         ...
       if (chain.matches(request)) {
          return chain.getFilters();
       }
    }
    return null;
}


public FilterChain decorate(FilterChain original, List<Filter> filters) {
    return new VirtualFilterChain(original, filters);
}

VirtualFilterChain的实现也并不复杂，其doFilter方法源码如下，原理和Servlet的FilterChain的实现类ApplicationFilterChain基本类似，不过当所有Filter都执行完之后，它会交给originalChain继续执行，即回到Servlet的FilterChain。上文提到，如果要打断点debug，这里是一个比较好的位置，可以看到Spring Security中定义各个Filter执行的过程。

@Override
public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
    if (this.currentPosition == this.size) {
       this.originalChain.doFilter(request, response);
       return;
    }
    this.currentPosition++;
    Filter nextFilter = this.additionalFilters.get(this.currentPosition - 1);
    if (logger.isTraceEnabled()) {
       String name = nextFilter.getClass().getSimpleName();
       logger.trace(LogMessage.format("Invoking %s (%d/%d)", name, this.currentPosition, this.size));
    }
    nextFilter.doFilter(request, response, this);
}

最后，再结合Spring Security官方文档的图示，可以更好地理解整个执行流程

spring security filter的工作原理

这篇文章介绍filter的工作原理。配置方式为xml。

Filter如何进入执行逻辑的

初始配置：

 <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>

  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

DelegatingFilterProxy这个类继承了GenericFilterBean，GenericFilterBean实现了Filter接口。

这个配置是一切的开始，配置完这个之后，在启动项目的时候会执行Filterd的初始化方法：

@Override
    public final void init(FilterConfig filterConfig) throws ServletException {
        Assert.notNull(filterConfig, "FilterConfig must not be null");
        if (logger.isDebugEnabled()) {
            logger.debug("Initializing filter ''" + filterConfig.getFilterName() + "''");
        }

        this.filterConfig = filterConfig;

        // Set bean properties from init parameters.
        PropertyValues pvs = new FilterConfigPropertyValues(filterConfig, this.requiredProperties);
        if (!pvs.isEmpty()) {
            try {
                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
                ResourceLoader resourceLoader = new ServletContextResourceLoader(filterConfig.getServletContext());
                Environment env = this.environment;
                if (env == null) {
                    env = new StandardServletEnvironment();
                }
                bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, env));
                initBeanWrapper(bw);
                bw.setPropertyValues(pvs, true);
            }
            catch (BeansException ex) {
                String msg = "Failed to set bean properties on filter ''" +
                    filterConfig.getFilterName() + "'': " + ex.getMessage();
                logger.error(msg, ex);
                throw new NestedServletException(msg, ex);
            }
        }

        // Let subclasses do whatever initialization they like.
        initFilterBean(); // 这个方法

        if (logger.isDebugEnabled()) {
            logger.debug("Filter ''" + filterConfig.getFilterName() + "'' configured successfully");
        }
    }

在初始化方法中，会执行初始化Filter的方法initFilterBean。这个方法的实现在DelegatingFilterProxy中：

protected void initFilterBean() throws ServletException {
        synchronized (this.delegateMonitor) {
            if (this.delegate == null) {
                // If no target bean name specified, use filter name.
                if (this.targetBeanName == null) {
                    this.targetBeanName = getFilterName();
                }
                // Fetch Spring root application context and initialize the delegate early,
                // if possible. If the root application context will be started after this
                // filter proxy, we''ll have to resort to lazy initialization.
                WebApplicationContext wac = findWebApplicationContext();
                if (wac != null) {
                    this.delegate = initDelegate(wac); //这个方法
                }
            }
        }
    }

在这个初始化方法中又调用initDelegate方法进行初始化：

protected Filter initDelegate(WebApplicationContext wac) throws ServletException {
        String targetBeanName = getTargetBeanName();
        Assert.state(targetBeanName != null, "No target bean name set");
        Filter delegate = wac.getBean(targetBeanName, Filter.class);
        if (isTargetFilterLifecycle()) {
            delegate.init(getFilterConfig());
        }
        return delegate;
    }

在这个方法中，先获取targetBeanName，这个名字是构造方法中赋值的：

public DelegatingFilterProxy(String targetBeanName, @Nullable WebApplicationContext wac) {
        Assert.hasText(targetBeanName, "Target Filter bean name must not be null or empty");
        this.setTargetBeanName(targetBeanName);
        this.webApplicationContext = wac;
        if (wac != null) {
            this.setEnvironment(wac.getEnvironment());
        }
    }

这个名字就是web.xml中配置的名字springSecurityFilterChain：

 <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>

springSecurityFilterChain是固定不能改的，如果改了启动时就会报错，这是spring 启动时内置的一个bean，这个bean实际是FilterChainProxy。

这样一个Filter就初始化话好了，过滤器chain也初始化好了。

当一个请求进来的时候，会进入FilterChainProxy执行doFilter方法：

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);
        }
    }

先获取所有的Filter，然后执行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);
    }

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);
            }
        }
    }

filter集合执行的逻辑在VirtualFilterChain的doFilter方法中。

filter是如何执行的

上面说了怎么才能进入filter的执行逻辑，下面说一下filter到底怎么执行，为什么一个
在VirtualFilterChain的doFilter方法可以执行所有的filter。

下面写一个例子，模拟filter的执行逻辑。
定义FilterChain接口、Filter接口：

public interface Filter {

    void doFilter(String username, int age, FilterChain filterChain);
}

public interface FilterChain {

    void doFilter(String username, int age);
}

定义两个Filter实现：

public class NameFilter implements Filter {

    @Override
    public void doFilter(String username, int age, FilterChain filterChain) {

        username = username + 1;
        System.out.println("username: " + username + "   age: " + age);
        System.out.println("正在执行：NameFilter");
        filterChain.doFilter(username, age);
    }
}

public class AgeFilter implements Filter {

    @Override
    public void doFilter(String username, int age, FilterChain filterChain) {

        age += 10;
        System.out.println("username: " + username + "   age: " + age);
        System.out.println("正在执行：AgeFilter");
        filterChain.doFilter(username, age);
    }
}

定义一个FilterChain实现：

public class FilterChainProxy implements FilterChain {


    private int position = 0;
    private int size = 0;
    private List<Filter> filterList = new ArrayList<>();

    public void addFilter(Filter filter) {

        filterList.add(filter);
        size++;
    }

    @Override
    public void doFilter(String username, int age) {

        if (size == position) {
            System.out.println("过滤器链执行结束");
        } else {

            Filter filter = filterList.get(position);
            position++;
            filter.doFilter(username, age, this);
        }
    }
}

测试Filter实现：

public class FilterTest {

    public static void main(String[] args) {

        FilterChainProxy proxy = new FilterChainProxy();
        proxy.addFilter(new NameFilter());
        proxy.addFilter(new AgeFilter());

        proxy.doFilter("张三", 0);
    }
}
=======
username: 张三1   age: 0
正在执行：NameFilter
username: 张三1   age: 10
正在执行：AgeFilter
过滤器链执行结束

在这个执行逻辑中，最重要的是【this】，this就是初始化的好的FilterChain实例，在这个测试实例中，this就是FilterChainProxy。

执行FilterChainProxy的doFilter方法的时候，传入了初始参数username和age，进入这个方法后，根据position取出相应的Filter，初次进入position是0，执行Filter的doFilter方法，注意，此时Filter的doFilter方法额外传入了一个this参数，这个参数就是初始化的好的FilterChain实例，在Filter中的doFilter的方法中最后又会执行FilterChain的doFilter方法，相当于第二次调用FilterChain实例的doFilter方法，此时posotion是1，然后再执行Filter的doFilter方法，直到所有的Filter执行完，整个执行过程结束。

VirtualFilterChain的doFilter方法的执行逻辑和这个测试实例中的执行逻辑基本一致。
这样就完成了整个过滤器链的执行。

总结

以前用Filter的时候就非常疑惑过滤器怎么执行的，直到今天才算解决了这个疑惑。

我们今天的关于Spring Security 工作原理概览和spring security详解的分享已经告一段落，感谢您的关注，如果您想了解更多关于spring boot 整合spring security中spring security版本升级的遇到的坑、Spring security 5.0：spring security savedrequest 为空、Spring Security 6.x 过滤器链SecurityFilterChain是如何工作的、spring security filter的工作原理的相关信息，请在本站查询。