安全认证框架Shiro 二- shiro过滤器工作原理

				版权声明：本文为博主原创文章，未经博主允许不得转载。					https://blog.csdn.net/achenyuan/article/details/78541529				</div>
							            <div id="content_views" class="markdown_views">
						<!-- flowchart 箭头图标 勿删 -->
						<svg xmlns="http://www.w3.org/2000/svg" style="display: none;"><path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path></svg>
						<h2 id="安全认证框架shiro-二-shiro过滤器工作原理"><a name="t0"></a>安全认证框架Shiro (二）- shiro过滤器工作原理</h2>

第一：前言

由于工作原因，写上篇文章安全认证框架Shiro (一）- ini配置文件过了好久，这里补上Shiro的后续学习经历。

第二：ShiroFilterFactoryBean入口

ShiroFilterFactoryBean实现FactoryBean，说明它是ShiroFilter的工厂类。它是怎么初始化让Shiro能很好的工作的呢，该类的入口方法是createInstance()，该方法实现了几个功能
1.创建了一个过滤器管理类FilterChainManager，该类主要管理shiro里的过滤器，里面有2个重要的属性
1.1 filters:管理全部过滤器，包括默认的关于身份验证和权限验证的过滤器，这些过滤器分为两组，一组是认证过滤器，有anon，authcBasic，auchc，user，一组是授权过滤器，有perms，roles，ssl，rest，port。同时也包含在xml里filters配置的自定义过滤器。在其它地方使用时都是从过滤器管理类里filters里拿的。且过滤器是单例的，整个Shiro框架只维护每种类型过滤器的单例。
1.2 filterChains:过滤链。它是我们重点关注的东西，是一个Map对象，其中key就是我们请求的url,value是一个NamedFilterList对象，里面存放的是与url对应的一系列过滤器。这后面会详细讲解。

2.将过滤器管理类设置到PathMatchingFilterChainResolver类里，该类负责路径和过滤器链的解析与匹配。根据url找到过滤器链。

我们以如下的xml配置为例讲解，如下：

<!-- Shiro的Web过滤器 -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/login.jsp"/>
        <property name="filters">
            <util:map>
                <entry key="authc" value-ref="formAuthenticationFilter"/>
                <entry key="logout" value-ref="logoutFilter" />
            </util:map>
        </property>
        <property name="filterChainDefinitionMap" ref="filterChainDefinitionMap" />
    </bean>

    <bean id="filterChainDefinitionMap"
        class="com.haedrig.shiro.spring.ChainDefinitionSectionMetaSource">
        <!-- 默认的连接配置 -->
        <property name="filterChainDefinitions">
            <value>
                /login.jsp = anon
                /login = authc
                /logout = logout
                /authenticated = authc
                /views/**=anon
                /** = authc, perms
            </value>
        </property>
    </bean>
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

createInstance()源码如下：

 protected AbstractShiroFilter createInstance() throws Exception {
        log.debug("Creating Shiro Filter instance.");

        SecurityManager securityManager = getSecurityManager();
        if (securityManager == null) {
            String msg = "SecurityManager property must be set.";
            throw new BeanInitializationException(msg);
        }

        if (!(securityManager instanceof WebSecurityManager)) {
            String msg = "The security manager does not implement the WebSecurityManager interface.";
            throw new BeanInitializationException(msg);
        }
        //创建默认的过滤器管理器
        FilterChainManager manager = createFilterChainManager();

        //Expose the constructed FilterChainManager by first wrapping it in a
        // FilterChainResolver implementation. The AbstractShiroFilter implementations
        // do not know about FilterChainManagers - only resolvers:
        PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
        //将过滤器管理器设置到PathMatchingFilterChainResolver对象里。
        chainResolver.setFilterChainManager(manager);

        //Now create a concrete ShiroFilter instance and apply the acquired SecurityManager and built
        //FilterChainResolver.  It doesn't matter that the instance is an anonymous inner class
        //here - we're just using it because it is a concrete AbstractShiroFilter instance that accepts
        //injection of the SecurityManager and FilterChainResolver:
        return new SpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

该方法创建过滤器管理器，同时设置到PathMatchingFilterChainResolver对象里，当有请求过来里，shiro会通过PathMatchingFilterChainResolver解析得到请求的url对应的过滤器链。

createFilterChainManager()方法：

 protected FilterChainManager createFilterChainManager() {

        DefaultFilterChainManager manager = new DefaultFilterChainManager();
        //获得shiro默认的过滤器，同时将xml里配置的loginUrl,successUrl,unauthorizedUrl设置到不同过滤器里
        Map<String, Filter> defaultFilters = manager.getFilters();
        //apply global settings if necessary:
        for (Filter filter : defaultFilters.values()) {
            applyGlobalPropertiesIfNecessary(filter);
        }

        //将自定义过滤器添加到filters里让管理器管理，注意，filters是Map，所以key同名的会被覆盖。
        //Apply the acquired and/or configured filters:
        Map<String, Filter> filters = getFilters();
        if (!CollectionUtils.isEmpty(filters)) {
            for (Map.Entry<String, Filter> entry : filters.entrySet()) {
                String name = entry.getKey();
                Filter filter = entry.getValue();
                applyGlobalPropertiesIfNecessary(filter);
                if (filter instanceof Nameable) {
                    ((Nameable) filter).setName(name);
                }
                //'init' argument is false, since Spring-configured filters should be initialized
                //in Spring (i.e. 'init-method=blah') or implement InitializingBean:
                manager.addFilter(name, filter, false);
            }
        }

        //build up the chains:
        //获得xml里filterChainDefinitions配置
        Map<String, String> chains = getFilterChainDefinitionMap();
        if (!CollectionUtils.isEmpty(chains)) {
            for (Map.Entry<String, String> entry : chains.entrySet()) {
                String url = entry.getKey();
                String chainDefinition = entry.getValue();
                //根据url创建url对应的过滤链**重点**重点**重点，每个配置过的url都对应一个过滤链
                manager.createChain(url, chainDefinition);
            }
        }

        return manager;
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

讲解：
1.applyGlobalPropertiesIfNecessary(filter);方法是将配置的loginUrl,successUrl,unauthorizedUrl设置到不同过器里。其中loginUrl赋值到所以继承自AccessControlFilter的过滤器里，successUrl赋值到所以继承自AuthenticationFilter的过滤器里，unauthorizedUrl赋值到所以继承自AuthorizationFilter的过滤器里。
当然其实过滤器可以自己设置loginUrl,successUrl,unauthorizedUrl，自定义赋值的也覆盖全局指定的。

2.读取filters配置的自定义过滤器，将它们纳入到过滤器管理器里。

3.最后读取filterChainDefinitions配置，根据配置设置每个url对应的过滤链,filterChains保存这些配置，它是一个Map集合，key就是url，value就是过滤器组成的NamedFilterList集合。其实当请求过来时，解析出请求路径，会从filterChains里找到url对应的过滤链，按过滤器的策略一个一个执行下去。
同时会调用PathMatchingFilter的processPathConfig()方法做些赋值操作。下面会专门讲将从PathMatchingFilter开始工作的过程。

4.一步一步分析下来过滤器管理器里的过滤链filterChains如下：

{
    /login.jsp=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@6ed97422,
    /login=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@592dbd8,
    /logout=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@1141badb,
    /authenticated=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@2d1b876e,
    /views/**=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@31106774,
    /**=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@14cd7d10,
    /index.jsp=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@712384a,
    /admin.jsp=org.apache.shiro.web.filter.mgt.SimpleNamedFilterList@7643ef31
}
 
 
1
2
3
4
5
6
7
8
9
10

可以看到每个url对应一个SimpleNamedFilterList对象，SimpleNamedFilterList是个List子类对象，保存的是过滤器集。

第三：请求到来解析过程

我们知道DelegatingFilterProxy过滤器的代理类来实现拦截的，任何请求都会先经过shiro先过滤，直到成功才会执行javaweb本身的过滤器。
一个请求过来时，先到达AbstractShiroFilter.executeChain()方法，去根据request解析出来的url找到对应的过滤链，然后执行过滤器链。
executeChain()方法如下：

 protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain)
            throws IOException, ServletException {
            //得到过滤器链
        FilterChain chain = getExecutionChain(request, response, origChain);
        chain.doFilter(request, response);
    }
 
 
1
2
3
4
5
6

进入getExecutionChain()方法：

 protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
        FilterChain chain = origChain;

        //resolver即是前面说的PathMatchingFilterChainResolver对象。里面保存有过滤器管理器实例
        FilterChainResolver resolver = getFilterChainResolver();
        if (resolver == null) {
            log.debug("No FilterChainResolver configured.  Returning original FilterChain.");
            return origChain;
        }

        //进入PathMatchingFilterChainResolver对象里，根据解析出来的requestURI找到对应的过滤器链并返回
        FilterChain resolved = resolver.getChain(request, response, origChain);
        if (resolved != null) {
            log.trace("Resolved a configured FilterChain for the current request.");
            chain = resolved;
        } else {
            log.trace("No FilterChain configured for the current request.  Using the default.");
        }

        return chain;
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

最终返回的过滤器链是：

而backingList里数据如下：

我们们在xml里配置的是一样的。

/login = authc
 
 
1

再往下一步一步走，中间过程省略看图

直到FormAuthenticationFilter.doFilterInternal()方法

public void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {

        Exception exception = null;

        try {

            boolean continueChain = preHandle(request, response);
            if (log.isTraceEnabled()) {
                log.trace("Invoked preHandle method.  Continuing chain?: [" + continueChain + "]");
            }

            if (continueChain) {
                executeChain(request, response, chain);
            }

            postHandle(request, response);
            if (log.isTraceEnabled()) {
                log.trace("Successfully invoked postHandle method");
            }

        } catch (Exception e) {
            exception = e;
        } finally {
            cleanup(request, response, exception);
        }
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

这行代码boolean continueChain = preHandle(request, response);其实是真正直到的单个过滤器里了，要想知道这里面在干什么，需要往下继续看。

第四：过滤器执行原理

先从PathMatchingFilter类讲解开始，匹配路径的过滤器，因为所以的过滤器都会继承PathMatchingFilter类，它的作用是路径匹配。过滤器单独维护自己需要过滤的url。
整体看一下类的属性：

分别介绍属性详情：
appliedPaths：是个map类，存放需要过滤的URL的。
比如如下的配置：

会将这红框中的属性添加到appliedPaths集合里。
结果如下：

pathMatcher：匹配器，就是当请求过来时，匹配哪个url对应哪个过滤器的。
processPathConfig：解析xml里配置的url对应的过滤器，分别加到appliedPaths要应用的map集合里，由于每个过滤器都继承PathMatchingFilter,故每个过滤器都会经过这步操作。
比如如下图，刚启动web服务时过滤器管理器会解析xml里filterChainDefinitions配置的过滤链，在根据配置给每个url创建过滤器链时，会调用不同过滤器的processPathConfig方法让过滤器自己把url添加到appliedPaths集合里，因为过滤器是单例的，过滤器管理器的filters里也只维护过滤器的单个实例：

preHandle方法：请求过来时该方法匹配url路径是否是该过滤器要处理的。遍历appliedPaths里所有的url直到完全匹配成功或遍历完为止。如果匹配成功则表明该url请求是需要该过滤器处理。然后就会进入onPreHandle方法。
onPreHandle方法：该方法在路径匹配成功时决定对url是否需要身份验证。默认是返回true，意思是不需要验证的。但子类需要根据业务逻辑自己重写该方法。
看看对该方法的实现类有哪些。

其中重点看看AccessControlFilter和AnonymousFilter。一个是需要身份验证的，一个是匿名访问的。
AnonymousFilter就比较简单了，任何对象访问都一直返回true，表明任何用AnonymousFilter过滤的请求都不需要验证。因为它一直返回true。

AccessControlFilter是需要身份验证的过滤器。当请求在过滤器里匹配成功后。后续验证处理在这里。如图：

如果isAccessAllowed()验证成功则返回true,否则交由onAccessDenied()方法处理，最后将onAccessDenied()方法处理的结果返回。
isAccessAllowed()方法是决定了当前请求的subject是否允许访问。如果以前做过验证则返回true，否则返回false。
onAccessDenied()方法是在被拒绝访问时处理。AccessControlFilter类有很多子类重载了该方法。以FormAuthenticationFilter类的onAccessDenied()方法为例。

如果是登陆请求，则执行登陆操作，否则保存请求链接跳转到登陆请求界面。
executeLogin()方法就比较简单了。创建 token,获得Subject对象，然后执行login()最后到realm里查询数据库做比较，这里先不讲。
saveRequestAndRedirectToLogin()方法会执行WebUtils.saveRequest()将请求保存到session里

redirectToLogin()即是服务器跳转到登陆界面。
流程如下：

---

2017-11-16补

---

有必要再补充PathMatchingFilter里属性appliedPaths和过滤器链的关系：
如下图：

每个过滤器自己在appliedPaths集合维护自己需要处理的url集合，而url对应的过滤器链可能串连多个，它只要求对应的过滤器有自己的url即可，不管过滤器是否还要处理其它url.

第五：总结

入口在ShiroFilterFactoryBean,每个过滤器都会根据类型不同拥有loginUrl,successUrl,unauthorizedUrl中的一个或多个配置，过滤器管理器负责为配置的每个url创建过滤器链，对于没配置的url则对应到“/**”路径的过滤器链上。当请求过来时，ShiroFilterFactoryBean负责接收请求并让过滤器管理器通过一定的策略找到url对应的过滤器链执行过滤器链，这里有个特殊情况，登陆请求，如果是登陆请求且是POST方式提交的话，如果没登陆会去执行登陆操作。

未完这里，未完待续…..