SpringSecurity实现原理及多过滤器链匹配规则详解_Java

springsecurity的实现原理

spring security能完成各种认证和授权功能其实是依赖其底层的多个过滤器进行实现的，

借用官方的一张原理图如下：

但是实际上这些filter并不是直接配置在tomcat中，其实他们都由一个叫做filterchainproxy的类进行管理

这些filter包括spring security默认生成的以及我们自己自定义的，通通都被封装成成一个个filterchain并且保存在filterchainproxy的一个成员变量中，一个filterchain包含多个filter，

filterchainproxy包含多个filterchain

原理图和代码如下:

public class filterchainproxy extends genericfilterbean {
    private static final log logger = logfactory.getlog(filterchainproxy.class);
    private static final string filter_applied =                filterchainproxy.class.getname().concat(".applied");
    private list<securityfilterchain> filterchains; //多个过滤器链
    private filterchainproxy.filterchainvalidator filterchainvalidator;
    private httpfirewall firewall;
}

当一个请求过来的时候，spring security会根据规则匹配到第一个过滤器链，并使用它过滤该请求

这里又引申出一些问题，既然存在多过滤链的情况，那么用户怎么配置多个过滤链，并且springsecurity是怎么根据请求选择相应的过滤器链

如何配置多个过滤器链

其实配置多个过滤器链并不难，项目中每存在一个继承了websecurityconfigureradapter类的配置类，spring securiy就会生成一个过滤器链；

继承resourceserverconfigureradapter类的配置类也会对应一个过滤器链，但是与继承了websecurityconfigureradapter类的配置类不同，

多个继承resourceserverconfigureradapter类的配置类都共存于一个过滤器链中，也就是无论配置多少个resourceserverconfigureradapter也仅仅存在一个对应的过滤链。

同时需要注意的是，存在多个websecurityconfigureradapter配置类的时候，需要用@order进行区分，代表了它们之间的优先级

配置代码如下

@configuration
@order(200)
public class defaultwebsecurityconfig extends websecurityconfigureradapter {

    @override
    protected void configure(httpsecurity http) throws exception {
        system.out.println("defaultwebsecurityconfig "+http);
    }
}


@configuration
public class websecurityconfig extends websecurityconfigureradapter {

    @override
    protected void configure(httpsecurity http) throws exception {
        system.out.println("websecurityconfig "+http);
    }
}


@configuration
public class resourcesecurityconfig {

    public static final string resource_id = "resource-server";

    @resource
    private resourceservertokenservices resourceservertokenservices;

    @configuration
    @enableresourceserver
    public class firstresourceconfig extends resourceserverconfigureradapter{
        //配置token服务以及资源id
        @override
        public void configure(resourceserversecurityconfigurer resources) throws exception {
            resources.resourceid(resource_id)
                    .tokenservices(resourceservertokenservices);
        }

        //配置访问控制
        @override
        public void configure(httpsecurity http) throws exception {
            system.out.println("firstresourceconfig "+http);
                    http
                    .authorizerequests()
                    .antmatchers("/**").access("#oauth2.hasscope('server')")
            ;
        }

    }

    @configuration
    @enableresourceserver
    public class secondresourceconfig extends resourceserverconfigureradapter{
        //配置token服务以及资源id
        @override
        public void configure(resourceserversecurityconfigurer resources) throws exception {
            resources.resourceid(resource_id)
                    .tokenservices(resourceservertokenservices);
        }

        //配置访问控制
        @override
        public void configure(httpsecurity http) throws exception {
            system.out.println("secondresourceconfig "+http);
                    http
                    .authorizerequests()
                    .antmatchers("/**").access("#oauth2.hasscope('server')")
            ;
        }

    }




}

上面的代码就是配置了三个过滤器链，最后一个虽然好像配置了两个过滤器链，但是前面已经说过了resourceserverconfigureradapter的配置类其实都会被合并在同一个过滤器链

那我们怎么知道的的确确存在三个过滤器链呢，过滤器链都存在filterchainproxy的成员变量中，我们只要debug一下看看它的成员变量就知道了，如下图:

每一个filterchain都包含一个requestmatcher，如下图

实际上过滤器链的requestmatcher是和我们的配置有关系，前面我们的配置都是使用了.authorizerequests()方法，其实这个就是代表anyrequestmatcher这个类

我们改变一下配置可以看看requestmatcher会有什么变化

@configuration
@order(200)
public class defaultwebsecurityconfig extends websecurityconfigureradapter {

    @override
    protected void configure(httpsecurity http) throws exception {
        system.out.println("defaultwebsecurityconfig "+http);
        http.antmatcher("/user")
                .authorizerequests().anyrequest().permitall()
                .and()
                .formlogin();
    }
}

我们把第一个配置类的规则改变了，看看debug会发生什么变化

它变成了antpathrequestmatcher，这里可以看出我们的配置会直接影响到springsecurity为我们选择合适的过滤器链，如果改成上面的配置，其实就代表

defaultwebsecurityconfig对应的过滤器链只匹配/user的请求，而其他两个过滤器链就是匹配/**的请求，虽然两个过滤器链都是匹配相同的地址，

但是他们的优先级不同，一般resourceserverconfigureradapter类默认的优先级是@order(3)，而websecurityconfigureradapter类默认是@order(100)

优先级的值越低就越先被匹配到，所以resourceserverconfigureradapter会被先匹配到

如何匹配多个过滤器链

要知道springsecurity是怎样匹配一个合适的过滤链，我们先看下面的代码:

private list<filter> getfilters(httpservletrequest request) {
        iterator var2 = this.filterchains.iterator();

        securityfilterchain chain;
        do {
            if (!var2.hasnext()) {
                return null;
            }

            chain = (securityfilterchain)var2.next();
        } while(!chain.matches(request)); //这里就是匹配过滤器链的方法

        return chain.getfilters();
    }

chain.matches()就是匹配一个过滤器链的方法，我们继续进入该方法:

public final class defaultsecurityfilterchain implements securityfilterchain {
    private static final log logger = logfactory.getlog(defaultsecurityfilterchain.class);
    private final requestmatcher requestmatcher;
    private final list<filter> filters;


    public boolean matches(httpservletrequest request) {
        return this.requestmatcher.matches(request);//实际上是调用了requestmatcher的matches方法
    }
}

实际上是调用了requestmatcher的matches方法，所以其实springsecurity在对一个请求选择一个过滤器链，就是通过调用每个过滤器链的requestmatcher进行匹配

匹配到第一个成功的就是处理该请求的过滤器链