安全认证框架Shiro (二）- shiro过滤器工作原理
安全认证框架Shiro (二）- shiro过滤器工作原理
-
- 安全认证框架Shiro 二- shiro过滤器工作原理
- 第一前言
- 第二ShiroFilterFactoryBean入口
- 第三请求到来解析过程
- 第四过滤器执行原理
- 第五总结
第一：前言
由于工作原因，写上篇文章安全认证框架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配置为例讲解，如下：
<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>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);
}该方法创建过滤器管理器，同时设置到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.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
}可以看到每个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);
}进入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;
}最终返回的过滤器链是：
而backingList里数据如下：
我们们在xml里配置的是一样的。
/login = authc再往下一步一步走，中间过程省略看图
直到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);
}
}这行代码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方式提交的话，如果没登陆会去执行登陆操作。
未完这里，未完待续…..