7.shiro学习笔记(7) – filter
1. Filter:
shiro拦截器的基础类图：
1、NameableFilter
NameableFilter给Filter起个名字，如果没有设置默认就是FilterName；还记得之前的如authc吗？当我们组装拦截器链时会根据这个名字找到相应的拦截器实例；
2、OncePerRequestFilter
OncePerRequestFilter用于防止多次执行Filter的；也就是说一次请求只会走一次拦截器链；另外提供enabled属性，表示是否开启该拦截器实例，默认enabled=true表示开启，如果不想让某个拦截器工作，可以设置为false即可。
3、ShiroFilter
ShiroFilter是整个Shiro的入口点，用于拦截需要安全控制的请求进行处理，这个之前已经用过了。
4、AdviceFilter
AdviceFilter提供了AOP风格的支持，类似于SpringMVC中的Interceptor：
preHandler：类似于AOP中的前置增强；在拦截器链执行之前执行；如果返回true则继续拦截器链；否则中断后续的拦截器链的执行直接返回；进行预处理（如基于表单的身份验证、授权）
postHandle：类似于AOP中的后置返回增强；在拦截器链执行完成后执行；进行后处理（如记录执行时间之类的）；
afterCompletion：类似于AOP中的后置最终增强；即不管有没有异常都会执行；可以进行清理资源（如接触Subject与线程的绑定之类的）；
5、PathMatchingFilter
PathMatchingFilter提供了基于Ant风格的请求路径匹配功能及拦截器参数解析的功能，如“roles[admin,user]”自动根据“，”分割解析到一个路径参数配置并绑定到相应的路径：
pathsMatch：该方法用于path与请求路径进行匹配的方法；如果匹配返回true；
onPreHandle：在preHandle中，当pathsMatch匹配一个路径后，会调用opPreHandle方法并将路径绑定参数配置传给mappedValue；然后可以在这个方法中进行一些验证（如角色授权），如果验证失败可以返回false中断流程；默认返回true；也就是说子类可以只实现onPreHandle即可，无须实现preHandle。如果没有path与请求路径匹配，默认是通过的（即preHandle返回true）。
6、AccessControlFilter
AccessControlFilter提供了访问控制的基础功能；比如是否允许访问/当访问拒绝时如何处理等：
isAccessAllowed：表示是否允许访问；mappedValue就是[urls]配置中拦截器参数部分，如果允许访问返回true，否则false；
onAccessDenied：表示当访问拒绝时是否已经处理了；如果返回true表示需要继续处理；如果返回false表示该拦截器实例已经处理了，将直接返回即可。
boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
return isAccessAllowed(request, response, mappedValue) || onAccessDenied(request, response, mappedValue);
}
另外AccessControlFilter还提供了如下方法用于处理如登录成功后/重定向到上一个请求：
x 1void setLoginUrl(String loginUrl) //身份验证时使用，默认/login.jsp 2String getLoginUrl() 3Subject getSubject(ServletRequest request, ServletResponse response) //获取Subject实例 4boolean isLoginRequest(ServletRequest request, ServletResponse response)//当前请求是否是登录请求 5void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException //将当前请求保存起来并重定向到登录页面 6void saveRequest(ServletRequest request) //将请求保存起来，如登录成功后再重定向回该请求 7void redirectToLogin(ServletRequest request, ServletResponse response) //重定向到登录页面 java
2.拦截器链
Shiro对Servlet容器的FilterChain进行了代理，即ShiroFilter在继续Servlet容器的Filter链的执行之前，通过ProxiedFilterChain对Servlet容器的FilterChain进行了代理；即先走Shiro自己的Filter体系，然后才会委托给Servlet容器的FilterChain进行Servlet容器级别的Filter链执行；
Shiro的ProxiedFilterChain执行流程：
1、先执行Shiro自己的Filter链；
2、再执行Servlet容器的Filter链（即原始的Filter）。
而ProxiedFilterChain是通过FilterChainResolver根据配置文件中[urls]部分是否与请求的URL是否匹配解析得到的。
两个值得注意的地方：
1. 为什么相同url规则，后面定义的会覆盖前面定义的(执行的时候只执行最后一个)。
/usr/login.do=test3
/usr/login.do=test1,test2
不会执行test3的filter
因为spring把具体工作委派给ShiroFilterFactoryBean后使用了ini转换方法，内部使用LinkedHashMap保存url和filter的映射关系，保证了顺序。既然使用LinkedHashMap，那么后面的将会把前面的覆盖。
2. 为什么两个url规则都可以匹配同一个url，只执行第一个呢。
同一个url可以匹配不同的规则，但只执行首行
/usr/* =test1,test2
/usr/login.do=test3
url = /usr/login.do请求来了，不会执行test3，因为已经匹配了/usr/* =test1,test2
要解答该问题，需要知道每个url的FilterChain是如何获取的
因为每个url在匹配他的FilterChain时，当匹配到第一个URL规则时，就返回
具体详解请见：Shiro的Filter机制详解—源码分析
补充一下：
public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {
FilterChainManager filterChainManager = getFilterChainManager();
if (!filterChainManager.hasChains()) {
return null;
}
String requestURI = getPathWithinApplication(request);
//the 'chain names' in this implementation are actually path patterns defined by the user. We just use them
//as the chain name for the FilterChainManager's requirements
for (String pathPattern : filterChainManager.getChainNames()) {
// If the path does match, then pass on to the subclass implementation for specific checks:
if (pathMatches(pathPattern, requestURI)) {
if (log.isTraceEnabled()) {
log.trace("Matched path pattern [" + pathPattern + "] for requestURI [" + requestURI + "]. " +
"Utilizing corresponding filter chain...");
}
return filterChainManager.proxy(originalChain, pathPattern);
}
}
return null;
}
pathMatches(pathPattern, requestURI) //路径匹配，进行判断，
protected boolean pathMatches(String pattern, String path) {
PatternMatcher pathMatcher = this.getPathMatcher();
return pathMatcher.matches(pattern, path);
}
-------------------------------------------------------------------------
进入：pathMatcher.matches(pattern, path)
然后在点进去AntPathMatcher类：该类就是行特定检查
protected boolean doMatch(String pattern, String path, boolean fullMatch) {
if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
return false;
} else {
String[] pattDirs = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator);
String[] pathDirs = StringUtils.tokenizeToStringArray(path, this.pathSeparator);
int pattIdxStart = 0;
int pattIdxEnd = pattDirs.length - 1;
int pathIdxStart = 0;
int pathIdxEnd;
String patDir;
for(pathIdxEnd = pathDirs.length - 1; pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd; ++pathIdxStart) {
patDir = pattDirs[pattIdxStart];
if ("**".equals(patDir)) {
break;
}
if (!this.matchStrings(patDir, pathDirs[pathIdxStart])) {
return false;
}
++pattIdxStart;
}
int patIdxTmp;
if (pathIdxStart > pathIdxEnd) {
if (pattIdxStart > pattIdxEnd) {
return pattern.endsWith(this.pathSeparator) ? path.endsWith(this.pathSeparator) : !path.endsWith(this.pathSeparator);
} else if (!fullMatch) {
return true;
} else if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") && path.endsWith(this.pathSeparator)) {
return true;
} else {
for(patIdxTmp = pattIdxStart; patIdxTmp <= pattIdxEnd; ++patIdxTmp) {
if (!pattDirs[patIdxTmp].equals("**")) {
return false;
}
}
return true;
}
} else if (pattIdxStart > pattIdxEnd) {
return false;
} else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) {
return true;
} else {
while(pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
patDir = pattDirs[pattIdxEnd];
if (patDir.equals("**")) {
break;
}
if (!this.matchStrings(patDir, pathDirs[pathIdxEnd])) {
return false;
}
--pattIdxEnd;
--pathIdxEnd;
}
if (pathIdxStart > pathIdxEnd) {
for(patIdxTmp = pattIdxStart; patIdxTmp <= pattIdxEnd; ++patIdxTmp) {
if (!pattDirs[patIdxTmp].equals("**")) {
return false;
}
}
return true;
} else {
while(pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) {
patIdxTmp = -1;
int patLength;
for(patLength = pattIdxStart + 1; patLength <= pattIdxEnd; ++patLength) {
if (pattDirs[patLength].equals("**")) {
patIdxTmp = patLength;
break;
}
}
if (patIdxTmp == pattIdxStart + 1) {
++pattIdxStart;
} else {
patLength = patIdxTmp - pattIdxStart - 1;
int strLength = pathIdxEnd - pathIdxStart + 1;
int foundIdx = -1;
int i = 0;
label140:
while(i <= strLength - patLength) {
for(int j = 0; j < patLength; ++j) {
String subPat = pattDirs[pattIdxStart + j + 1];
String subStr = pathDirs[pathIdxStart + i + j];
if (!this.matchStrings(subPat, subStr)) {
++i;
continue label140;
}
}
foundIdx = pathIdxStart + i;
break;
}
if (foundIdx == -1) {
return false;
}
pattIdxStart = patIdxTmp;
pathIdxStart = foundIdx + patLength;
}
}
for(patIdxTmp = pattIdxStart; patIdxTmp <= pattIdxEnd; ++patIdxTmp) {
if (!pattDirs[patIdxTmp].equals("**")) {
return false;
}
}
return true;
}
}
}
}
3. 自定义拦截器
继承：AccessControlFilter，PathMatchingFilter，AdviceFilter，OncePerRequestFilter,具体什么功能看 1.Filter.
然后就是在shiroConfig中配置
/**
* 设置过滤规则
*
* @param securityManager
* @return
*/
@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
Map<String, Filter> cumstomfilterMap = new HashMap<>();
//map里面key值要为authc才能使用自定义的过滤器
cumstomfilterMap.put("user", new SessionCheckFilter());
cumstomfilterMap.put("myOncePerRequestFilter", new MyOncePerRequestFilter());
cumstomfilterMap.put("url", new URLPathMatchingFilter());
shiroFilterFactoryBean.setFilters(cumstomfilterMap);
shiroFilterFactoryBean.setSecurityManager(securityManager);
shiroFilterFactoryBean.setLoginUrl("/login");
shiroFilterFactoryBean.setSuccessUrl("/");
shiroFilterFactoryBean.setUnauthorizedUrl("/unauth");
//注意此处使用的是LinkedHashMap，是有顺序的，shiro会按从上到下的顺序匹配验证，匹配了就不再继续验证
//所以上面的url要苛刻，宽松的url要放在下面，尤其是"/**"要放到最下面，如果放前面的话其后的验证规则就没作用了。
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
filterChainDefinitionMap.put("/static/**", "anon");
filterChainDefinitionMap.put("/login", "anon");
filterChainDefinitionMap.put("/addUser", "anon");
filterChainDefinitionMap.put("/captcha.jpg", "anon");
filterChainDefinitionMap.put("/favicon.ico", "anon");
// 如果想实现多个就 , 隔开
filterChainDefinitionMap.put("/**", "url,myOncePerRequestFilter");
// filterChainDefinitionMap.put("/**", "myOncePerRequestFilter");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilterFactoryBean;
}
这里有两个坑：
- 自定义filter 需要定义一个map来添加进shiroFilterFactoryBean中，不需要注入到Bean中，new就行了。
- 在自定义多个filter ，并且你想把他作用在同一个URL中时，用 , 隔开，别在put一个filter 。（原因上面讲了）
851
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
