使用shiro拦截器链实现权限管理
在开篇之前，先介绍一下shiro，那么
什么是shiro呢？
Apache Shiro（发音为“shee-roh”，日语“堡垒（Castle）”的意思）是一个强大易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可为任何应用提供安全保障 - 从命令行应用、移动应用到大型网络及企业应用。
Shiro为解决下列问题（我喜欢称它们为应用安全的四要素）提供了保护应用的API：
认证 - 用户身份识别，常被称为用户“登录”；
授权 - 访问控制；
密码加密 - 保护或隐藏数据防止被偷窥；
会话管理 -每用户相关的时间敏感的状态。Shiro还支持一些辅助特性，如Web应用安全、单元测试和多线程，它们的存在强化了上面提到的四个要素
由上面介绍可知，shiro可以实现认证及授权，这也是本篇的重点，使用shiro实现认证和授权。
使用shiro实现权限管理
首先看一下我的项目结构：
图 1.项目结构
项目代码地址：GitHub地址
我们跳过无关紧要的内容，直接讲最关建的shiro部分。
shiro
我们先看一下项目中和shiro有关的文件，java文件三个，分别是：MyRealm.java、ShiroConfig.java、ShiroManager.java；
在spring-mvc.xml文件中，我们对shiro的bean注解开启了配置
<context:component-scan base-package="shiro"/>在web.xml文件中，我们配置了shiro的过滤器
<filter>
<filter-name>shiroFilterfilter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxyfilter-class>
<init-param>
<param-name>targetFilterLifecycleparam-name>
<param-value>trueparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>shiroFilterfilter-name>
<url-pattern>/a/*url-pattern>
filter-mapping>由此，我们开始整理shiro的实现脉路。
shiro拦截器链的实现原理
首先我们的请求通过web.xml的时候被shiro的拦截器过滤了一波，也就是
<filter>
<filter-name>shiroFilterfilter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxyfilter-class>
<init-param>
<param-name>targetFilterLifecycleparam-name>
<param-value>trueparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>shiroFilterfilter-name>
<url-pattern>/a/*url-pattern>
filter-mapping>在起效，这里看一看到所有的/a开头的url都需要经过shiro的过滤器。
spring-mvc.xml中的注解开启配置就不说了，主要是shiro的java代码中涉及了比较多的注解配置，所以这条配置是必须的
<context:component-scan base-package="shiro"/>
接下来，我们看shiro的主体部分，也是本篇的重点
首先是MyRealm.java
package shiro;
import model.Role;
import model.User;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.credential.AllowAllCredentialsMatcher;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import service.RoleService;
import service.UserService;
import util.SplitUtil;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Created by yubotao on 2017/12/03.
*/
@SuppressWarnings("ALL")
@Component
public class MyRealm extends AuthorizingRealm{
private static final Log log = LogFactory.getLog(MyRealm.class);
public MyRealm(){
super(new AllowAllCredentialsMatcher());
setAuthenticationTokenClass(UsernamePasswordToken.class);
//FIXME:暂时禁用Cache
setCachingEnabled(false);
}
@Autowired
UserService userService;
@Autowired
RoleService roleService;
//验证时调用
//此方法调用subject.hasRole("admin")或subject.isPermitted("admin");
//自己去调用这个是否有什么角色或有什么权限
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals){
User user = (User) principals.getPrimaryPrincipal();
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
User user1 = null;
/*新建角色与权限的set*/
Set shiroPermissions = new HashSet<>();
Set roleSet = new HashSet<>();
try{
/*1.通过userName获取userId*/
user1 = userService.getUserByName(user.getName());
if(user1 != null){
Role role = roleService.getRoleById(user.getRole());
log.info("role permission : " + role.getPermission());
SplitUtil splitUtil = new SplitUtil();
List permissionList = splitUtil.stringToIntegerList(role.getPermission());
log.info("permisson list : " + permissionList);
for (int i = 0; i < permissionList.size(); i++){
shiroPermissions.add(permissionList.get(i).toString());
}
authorizationInfo.setStringPermissions(shiroPermissions);
log.info("shiroPermissions : " + shiroPermissions);
return authorizationInfo;
}
}catch (Exception e){
e.printStackTrace();
}
return null;
}
//登陆时调用
//调用Subject currentUser = SecurityUtils.getSubject();
// currentUser.login(token);
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token){
String username = (String) token.getPrincipal();
log.info("username : " + username);
User user = null;
String password = null;
try{
/*通过username获取User*/
user = userService.getUserByName(username);
log.info("user : " + user);
password = new String((char[]) token.getCredentials());
log.info("password : " + password);
//账号不存在
if(user == null){
throw new UnknownAccountException("账号不正确");
}
//密码错误
//简单起见，没有加密，应该加上
if(!password.equals(user.getPassword())){
throw new UnknownAccountException("密码错误");
}
}catch (Exception e){
throw new AuthenticationException();
}
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,getName());
return info;
}
}
在讲解该部分代码前，我们首先介绍一下Realm这个shiro的组件。
Realm
此部分内容参考该blog：Realm的介绍
Realm 是一个能够访问应用程序特定的安全数据（如用户、角色及权限）的组件。
Realm 通常和数据源是一对一的对应关系，如关系数据库，LDAP 目录，文件系统，或其他类似资源。Realm
实质上就是一个特定安全的DAO。因为这些数据源大多通常存储身份验证数据（如密码的凭证）以及授权数据（如角色或权限），每个Realm能够执行身份验证和授权操作。
由这篇blog我们可以整理出如下信息：
1.shiro的认证最后是交给Realm的，调用的是doGetAuthenticationInfo()方法；
2.如果验证通过，会返回一个非空的AuthenticationInfo实例来代表来自该数据源的Subject账户信息。
为了便于理解，这里首先介绍俩个词：
Authorization —— 授权
Authentication —— 认证
然后我们看一下我们自定义的MyRealm的内容，首先是构造函数
public MyRealm(){
super(new AllowAllCredentialsMatcher());
setAuthenticationTokenClass(UsernamePasswordToken.class);
//FIXME:暂时禁用Cache
setCachingEnabled(false);
}这里借用一张图：该图源自对于shiro有比较深入的介绍
这张图展示了shiro的认证匹配接口结构图，这里面就有我们提到的AllowAllCredentialsMatcher，它的含义是：只要该用户名存在即可，不用去验证密码是否匹配。
然后我们在构造函数中将Cache设为暂不使用。
接下来是Realm中的认证内容
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals){
User user = (User) principals.getPrimaryPrincipal();
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
User user1 = null;
/*新建角色与权限的set*/
Set<String> shiroPermissions = new HashSet<>();
Set<String> roleSet = new HashSet<>();
try{
/*1.通过userName获取userId*/
user1 = userService.getUserByName(user.getName());
if(user1 != null){
Role role = roleService.getRoleById(user.getRole());
log.info("role permission : " + role.getPermission());
SplitUtil splitUtil = new SplitUtil();
List<Integer> permissionList = splitUtil.stringToIntegerList(role.getPermission());
log.info("permisson list : " + permissionList);
for (int i = 0; i < permissionList.size(); i++){
shiroPermissions.add(permissionList.get(i).toString());
}
authorizationInfo.setStringPermissions(shiroPermissions);
log.info("shiroPermissions : " + shiroPermissions);
return authorizationInfo;
}
}catch (Exception e){
e.printStackTrace();
}
return null;
}这里可以看到，该代码块的主要逻辑就是，获取用户对应角色所拥有的权限，然后将这些权限放到SimpleAuthorizationInfo的权限认证书中，这个地方是为了之后的shiro权限认证所做的铺垫。
这里使用了PrincipalCollection，这个接口是干什么用的呢，经过查阅，发现该值是唯一的，在所有用户帐户中唯一的字符串用户名。所以代码中的
User user = (User) principals.getPrimaryPrincipal();使用它来获取当前subject中的唯一用户。
到此，我们已经完成了授权，接下来就就是认证了。
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token){
String username = (String) token.getPrincipal();
log.info("username : " + username);
User user = null;
String password = null;
try{
/*通过username获取User*/
user = userService.getUserByName(username);
log.info("user : " + user);
password = new String((char[]) token.getCredentials());
log.info("password : " + password);
//账号不存在
if(user == null){
throw new UnknownAccountException("账号不正确");
}
//密码错误
//简单起见，没有加密，应该加上
if(!password.equals(user.getPassword())){
throw new UnknownAccountException("密码错误");
}
}catch (Exception e){
throw new AuthenticationException();
}
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,getName());
return info;
}这部分的代码块主要逻辑是：通过token.getPrincipal()方法获取到Token中的用户名，然后根据用户名查找数据库，找出数据库中记录并进行对比，如果确实有该用户，并且帐密无误，那么就会通过
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,getName());生成一个认证信息。
到此，我们的自定义Realm内容就完毕了。
ShiroManager
首先看一下ShiroManager.java的代码：
package shiro;
/**
* Created by yubotao on 2017/12/03.
*/
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.DependsOn;
/**
* shiro Config Manager
* */
public class ShiroManager {
/**
* 保证了实现shiro内部的lifecycle函数的bean执行
* */
@Bean(name = "lifecycleBeanPostProcessor")
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){return new LifecycleBeanPostProcessor();}
@Bean(name = "defaultAdvisorAutoProxyCreator")
@DependsOn("lifecycleBeanPostProcessor")
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
return defaultAdvisorAutoProxyCreator;
}
@Bean
public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultSecurityManager securityManager){
AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
aasa.setSecurityManager(securityManager);
return aasa;
}
}
首先这个ShiroManager的名字就暴露出，这部分是管理shiro的一些bean的，那么我们先来看第一个代码块：
@Bean(name = "lifecycleBeanPostProcessor")
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){return new LifecycleBeanPostProcessor();}查看shiro的官方文档我们发现，这个LifecycleBeanPostProcessor是shiro和Spring整合的一个生命周期bean，自动使用init和destroy，无需我们进行管理；
接下来第二个代码块
@Bean(name = "defaultAdvisorAutoProxyCreator")
@DependsOn("lifecycleBeanPostProcessor")
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
return defaultAdvisorAutoProxyCreator;
}这里关键的类时DefaultAdvisorAutoProxyCreator，该类时spring-aop包下的类，具体功能为：自动创建代理，它会搜寻所有的Advisor，并自动将Advisor应用到符合的PointCuts（切点）物件上。
通俗讲就是我们生成了一个可以自动帮我们实现aop代理的bean，并且对相应的切点使用已有的Advisor。
接下来我们看第三个代码块
@Bean
public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultSecurityManager securityManager){
AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
aasa.setSecurityManager(securityManager);
return aasa;
}这个类可以在shiro官方文档中查看，我们通过查看可以看到这个AuthorizationAttributeSourceAdvisor就是我们刚才提到的Advisor，并且它实际上使用了AopAllianceAnnotationsAuthorizingMethodInterceptor，而该类的官方文档解释为：
Allows Shiro Annotations to work in any AOP Alliance specific implementation environment (for example, Spring).
使shiro注解能够在任意的特定AOP联合环境工作，比如我们现在使用的Spring。
至此，ShiroManager的讲解也完毕了。
ShiroConfig
这里是整个shiro拦截链的关键。
ShiroConfig.java
package shiro;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Import;
import java.util.LinkedHashMap;
/**
* Created by yubotao on 2017/12/03.
*/
@Configuration
@Import(ShiroManager.class)
public class ShiroConfig {
private static final Log log = LogFactory.getLog(ShiroConfig.class);
@Bean(name = "realm")
@DependsOn("lifecycleBeanPostProcessor")
public Realm realm(){return new MyRealm();}
/**
* 用户授权信息Cache
* */
@Bean(name = "shiroCacheManager")
public CacheManager cacheManager(){return new MemoryConstrainedCacheManager();}
@Bean(name = "securityManager")
public DefaultSecurityManager securityManager(){
//这里注意，需要实现DefaultWebSecurityManager
DefaultSecurityManager sm = new DefaultWebSecurityManager();
sm.setCacheManager(cacheManager());
return sm;
}
/**
* shiro核心，拦截器链，顺序执行
* */
@Bean(name = "shiroFilter")
@DependsOn("securityManager")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultSecurityManager securityManager,Realm realm){
securityManager.setRealm(realm);
ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
shiroFilter.setSecurityManager(securityManager);
shiroFilter.setLoginUrl("/a/login/fail");//未登录跳转
shiroFilter.setUnauthorizedUrl("/a/login/fail");//未授权跳转
LinkedHashMap filterChainDefinitionMap = new LinkedHashMap<>();
filterChainDefinitionMap.put("/a/u/first","perms[1]");
log.info("第一链");
filterChainDefinitionMap.put("/a/u/second","perms[2]");
log.info("第二链");
filterChainDefinitionMap.put("/a/u/third","perms[3]");
log.info("第三链");
filterChainDefinitionMap.put("/a//**","anon");
log.info("执行顺序 : " + filterChainDefinitionMap);
shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilter;
}
}
和之前一样，我们还是逐个击破。
首先这里使用了注解@Import(ShiroManager.class)，也就是引用了我们刚才配置的ShiroManager，也就是在这个类里，完成了所有shiro配置的大汇合。
先看第一个代码块
@Bean(name = "realm")
@DependsOn("lifecycleBeanPostProcessor")
public Realm realm(){return new MyRealm();}这里我们依赖了刚才配置的生命周期bean，并且配置出了我们自定义的MyRealm。
然后是第二个代码块
/**
* 用户授权信息Cache
* */
@Bean(name = "shiroCacheManager")
public CacheManager cacheManager(){return new MemoryConstrainedCacheManager();}这里我们将使用用户授权信息的Cache。
第三个代码块
@Bean(name = "securityManager")
public DefaultSecurityManager securityManager(){
//这里注意，需要实现DefaultWebSecurityManager
DefaultSecurityManager sm = new DefaultWebSecurityManager();
sm.setCacheManager(cacheManager());
return sm;
}这里需要注意的是需要实现DefaultWebSecurityManager，否则会在使用shiro拦截链的时候报错，一开始的时候我在这里没有注意，少写了个Web，然后就出错了，一定要特别注意。
那么为什么这个类这么重要呢？
我们可以参考该文章：对于DefaultWebSecurityManager的介绍
大概解释如下
DefaultWebSecurityManager类主要定义了设置subjectDao，获取会话模式，设置会话模式，设置会话管理器，是否是http会话模式等操作，它继承了DefaultSecurityManager类，实现了WebSecurityManager接口
也就是说，如果没有使用这个类，我们无法验证会话中登陆的用户，也就无法进行登陆、校验、登出等操作；主要和Subject有关。
接下来就是本文的核心，shiro的拦截器链：
/**
* shiro核心，拦截器链，顺序执行
* */
@Bean(name = "shiroFilter")
@DependsOn("securityManager")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultSecurityManager securityManager,Realm realm){
securityManager.setRealm(realm);
ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
shiroFilter.setSecurityManager(securityManager);
shiroFilter.setLoginUrl("/a/login/fail");//未登录跳转
shiroFilter.setUnauthorizedUrl("/a/login/fail");//未授权跳转
LinkedHashMap filterChainDefinitionMap = new LinkedHashMap<>();
filterChainDefinitionMap.put("/a/u/first","perms[1]");
log.info("第一链");
filterChainDefinitionMap.put("/a/u/second","perms[2]");
log.info("第二链");
filterChainDefinitionMap.put("/a/u/third","perms[3]");
log.info("第三链");
filterChainDefinitionMap.put("/a//**","anon");
log.info("执行顺序 : " + filterChainDefinitionMap);
shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilter;
} 相信注解已经很清楚了，这里的逻辑就是：新建shiro的拦截链，然后设置未登录和未授权的两种跳转，这里为了简便，我将两种跳转设置为一个了；然后向拦截链里添加规则，最后返回shiro的拦截链信息。
成果展示
经过如上的讲解，我们检验一下效果。
当我们处于未登录状态的时候，请求权限url会跳转至之前设定的失败页面
当我们登陆后有对应权限时
当我们登陆后无权限访问时
