权限控制框架-shiro
一。 shiro简介
Apache Shiro（发音为“shee-roh”，日语“堡垒（Castle）”的意思）是一个强大易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可为任何应用提供安全保障 - 从命令行应用、移动应用到大型网络及企业应用。
Shiro为解决下列问题（我喜欢称它们为应用安全的四要素）提供了保护应用的API：
- 认证 - 用户身份识别，常被称为用户“登录”；
- 授权 - 访问控制；
- 密码加密 - 保护或隐藏数据防止被偷窥；
- 会话管理 - 每用户相关的时间敏感的状态。
从2003年至今，框架选择方面的情况已经改变了不少，但今天仍有令人信服的理由让你选择Shiro。其实理由相当多，Apache Shiro：
- 易于使用 - 易用性是这个项目的最终目标。应用安全有可能会非常让人糊涂，令人沮丧，并被认为是“必要之恶”【译注：比喻应用安全方面的编程。】。若是能让它简化到新手都能很快上手，那它将不再是一种痛苦了。
- 广泛性 - 没有其他安全框架可以达到Apache Shiro宣称的广度，它可以为你的安全需求提供“一站式”服务。
- 灵活性 - Apache Shiro可以工作在任何应用环境中。虽然它工作在Web、EJB和IoC环境中，但它并不依赖这些环境。Shiro既不强加任何规范，也无需过多依赖。
- Web能力 - Apache Shiro对Web应用的支持很神奇，允许你基于应用URL和Web协议（如REST）创建灵活的安全策略，同时还提供了一套控制页面输出的JSP标签库。
- 可插拔 - Shiro干净的API和设计模式使它可以方便地与许多的其他框架和应用进行集成。你将看到Shiro可以与诸如Spring、Grails、Wicket、Tapestry、Mule、Apache Camel、Vaadin这类第三方框架无缝集成。
核心概念：Subject，SecurityManager和Realms
Subject
Subject一词是一个安全术语，其基本意思是“当前的操作用户”。称之为“用户”并不准确，因为“用户”一词通常跟人相关。在安全领域，术语“Subject”可以是人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途，你可以把它认为是Shiro的“用户”概念。在代码的任何地方，你都能轻易的获得Shiro Subject，
SecurityManager
Subject的“幕后”推手是SecurityManager。Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。它是Shiro框架的核心，充当“保护伞”，引用了多个内部嵌套安全组件，它们形成了对象图。但是，一旦SecurityManager及其内部对象图配置好，它就会退居幕后，应用开发人员几乎把他们的所有时间都花在Subject API调用上。
那么，如何设置SecurityManager呢？嗯，这要看应用的环境。例如，Web应用通常会在Web.xml中指定一个Shiro Servlet Filter，这会创建SecurityManager实例，如果你运行的是一个独立应用，你需要用其他配置方式，但有很多配置选项。
一个应用几乎总是只有一个SecurityManager实例。它实际是应用的Singleton（尽管不必是一个静态Singleton）。跟Shiro里的几乎所有组件一样，SecurityManager的缺省实现是POJO，而且可用POJO兼容的任何配置机制进行配置 - 普通的Java代码、Spring XML、YAML、.properties和.ini文件等。基本来讲，能够实例化类和调用JavaBean兼容方法的任何配置形式都可使用。
为此，Shiro借助基于文本的INI配置提供了一个缺省的“公共”解决方案。INI易于阅读、使用简单并且需要极少依赖。你还能看到，只要简单地理解对象导航，INI可被有效地用于配置像SecurityManager那样简单的对象图。注意，Shiro还支持Spring XML配置及其他方式，但这里只我们只讨论INI。
Realms
Shiro的第三个也是最后一个概念是Realm。Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当切实与像用户帐户这类安全相关数据进行交互，执行认证（登录）和授权（访问控制）时，Shiro会从应用配置的Realm中查找很多内容。
从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现
文字摘自 （http://www.infoq.com/cn/articles/apache-shiro）
shiro架构
除前面所讲Subject、SecurityManager 、Realm三个核心组件外，Shiro主要组件还包括：
- Authenticator ：认证就是核实用户身份的过程。这个过程的常见例子是大家都熟悉的“用户/密码”组合。多数用户在登录软件系统时，通常提供自己的用户名（当事人）和支持他们的密码（证书）。如果存储在系统中的密码（或密码表示）与用户提供的匹配，他们就被认为通过认证。
- Authorizer ：授权实质上就是访问控制 - 控制用户能够访问应用中的哪些内容，比如资源、Web页面等等。
- SessionManager ：在安全框架领域，Apache Shiro提供了一些独特的东西：可在任何应用或架构层一致地使用Session API。即，Shiro为任何应用提供了一个会话编程范式 - 从小型后台独立应用到大型集群Web应用。这意味着，那些希望使用会话的应用开发者，不必被迫使用Servlet或EJB容器了。或者，如果正在使用这些容器，开发者现在也可以选择使用在任何层统一一致的会话API，取代Servlet或EJB机制。
- CacheManager :对Shiro的其他组件提供缓存支持。
- Cryptography 提供安全的支持
常用的操作
ini配置权限信息（参考http://shiro.apache.org/configuration.html）
# =======================
# Shiro INI configuration
# =======================
[main]
[users]
# 设置用户信息
# 语法是 username = password, roleName1, roleName2, …, roleNameN
jiaozi = 123456,role1
[roles]
# 角色信息和角色拥有的权限
#语法是 rolename = permissionDefinition1, permissionDefinition2, …, permissionDefinitionN
#权限的语法 * 表示所有权限 一般语法是 权限类型.权限动作.权限的资源id 比如 user:delete:1 表示拥有删除1号用户的权限 user:delete:*表示删除所有用户权限
admin = *
role1 = user:query:*, user:delete:1
[urls]
# web中的url过滤
org.apache.shiro
shiro-core
1.4.0
commons-logging
commons-logging
1.2
package shiro;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
public class TestShiro {
public static void main(String[] args) {
testIni();
}
public static void testIni() {
//从配置文件中读取用户的权限信息
Factory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
org.apache.shiro.mgt.SecurityManager securityManager = (org.apache.shiro.mgt.SecurityManager)factory.getInstance();
SecurityUtils.setSecurityManager(securityManager);
//获取登录用户信息
Subject currentUser = SecurityUtils.getSubject();
Session session = currentUser.getSession();
session.setAttribute( "保存数据的键", "保存数据的值" );
/**
* 用户包括两部分
// * principals and credentials
* principals（本人）表示用户的标识信息 比如用户名 用户地址等
* credentials（凭证）表示用户用于登录的凭证 比如密码 证书等
*/
//isAuthenticated判断是否登录过
if ( !currentUser.isAuthenticated() ) {
//令牌 用户名和密码 其实就是credentials
UsernamePasswordToken token = new UsernamePasswordToken("jiaozi", "123456");
token.setRememberMe(true);
//开始登录操作 操作后 isAuthenticated就是true
currentUser.login(token);
System.out.println("登录成功");
//判断是否有某个角色
if(currentUser.hasRole("role1")){
System.out.println("拥有角色role1");
}
if(currentUser.isPermitted("user:query:1")){
System.out.println("拥有查询1号用户权限");
}
}
currentUser.logout();
}
}
添加realm的实现类
package shiro;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAccount;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
/**
* 自定义realm的实现
* @author jiaozi
*
*/
public class MyRealm extends AuthorizingRealm {
//用于存放用户信息
static Map userList=null;
//用于存放角色信息
static Map roleList=null;
//每个realm都有一个名字
static String REALM_NAME="myrealm";
static{
//这里也可以从数据库读取
//模拟用户
userList=new HashMap();
userList.put("zs", "123456,role2,role3");
//模拟权限
roleList=new HashMap();
roleList.put("role2","user:query:*");
roleList.put("role3", "user:*");
}
/**
* 支持哪种令牌
*/
@Override
public boolean supports(AuthenticationToken token) {
// TODO Auto-generated method stub
return token instanceof UsernamePasswordToken;
}
/**
* 获取权限过程
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//获取用户名
String userName=principals.getPrimaryPrincipal().toString();
//构建权限的类
SimpleAuthorizationInfo sai=new SimpleAuthorizationInfo();
Set proleList=new HashSet();
Set stringPermissions=new HashSet();
if(userList.containsKey(userName)){
String[] roles=userList.get(userName).toString().split(",");
for(int i=1;i [main]
# 定义securityManager, Realms and 其他
myRealm= shiro.MyRealm
securityManager.realms=$iniRealm , $myRealm
#iniRealm是内置的默认realm读取ini文件的传入 如果自定义了realm该realm被替代 如果还想使用可以直接引用
#如果有多个realm 策略是所有的realm都要验证通过 还是只需要一个验证通过 我这里只需要一个验证通过 默认是所有
#参考http://shiro.apache.org/authentication.html
authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy
securityManager.authenticator.authenticationStrategy = $authcStrategy二。 shiro web
集成web集成 参考 http://shiro.apache.org/web.html#programmatic-support
在之前例子基础上进行拓展 添加war项目 添加shiro-web依赖
org.apache.shiro
shiro-web
1.4.0
web.xml添加shiro支持的过滤器和ini文件路径配置参数
shiroConfigLocations
/WEB-INF/shiro.ini
org.apache.shiro.web.env.EnvironmentLoaderListener
ShiroFilter
org.apache.shiro.web.servlet.ShiroFilter
ShiroFilter
/*
REQUEST
FORWARD
INCLUDE
ERROR
login.html添加用于登录的表单
這是測試查詢頁面
這是測試新增頁面
没有权限
web.xml
LoginServlet
LoginServlet
cn.et.web.LoginServlet
LoginServlet
/loginServlet
package cn.et.web;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
public class LoginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* 登录进入方法
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken upt=new UsernamePasswordToken(request.getParameter("userName"), request.getParameter("password"));
try {
subject.login(upt);
request.getRequestDispatcher("/query.jsp").forward(request, response);
} catch (AuthenticationException e) {
request.getRequestDispatcher("/login.html").forward(request, response);
}
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}# =======================
# Shiro INI configuration
# =======================
[main]
# 定义securityManager, Realms and 其他
myRealm= shiro.MyRealm
securityManager.realms=$iniRealm , $myRealm
#如果有多个realm 策略是所有的realm都要验证通过 还是只需要一个验证通过 我这里只需要一个验证通过 默认是所有
authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy
securityManager.authenticator.authenticationStrategy = $authcStrategy
authc.loginUrl = /login.html
#如果沒有登錄 會先跳轉到loginUrl 如果登錄了沒權限 跳轉到unauthorizedUrl指定頁面
roles.loginUrl= /login.html
roles.unauthorizedUrl= /un.html
[users]
# 设置用户信息
# 语法是 username = password, roleName1, roleName2, …, roleNameN
jiaozi = 123456,role1
[roles]
# 角色信息和角色拥有的权限
#语法是 rolename = permissionDefinition1, permissionDefinition2, …, permissionDefinitionN
#权限的语法 * 表示所有权限 一般语法是 权限类型.权限动作.权限的资源id 比如 user:delete:1 表示拥有删除1号用户的权限 user:delete:*表示删除所有用户权限
admin = *
role1 = user:query:*, user:delete:1
[urls]
# web中的url过滤
#語法是 某個路徑 = 怎麼樣過濾1，過濾2 常用的過濾有
# anon 匿名用戶
# authc 表示用戶和密碼驗證過濾 類 org.apache.shiro.web.filter.authc.FormAuthenticationFilter 沒有登錄自動跳轉到登錄頁
# perms 是否擁有某些權限過濾 類 org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter 用法 perms["remote:invoke"]
# roles是否擁有某個角色 org.apache.shiro.web.filter.authz.RolesAuthorizationFilter 用法roles[administrator]
# user 是否是某個用戶 org.apache.shiro.web.filter.authc.UserFilter
# 也可以在main中自定義filter url就可以應用 參考http://shiro.apache.org/web.html#programmatic-support
/login.html = anon
/loginServlet = anon
/query.jsp = authc
/add.jsp = roles[role2]
测试登录ini中的jiaozi用户登录成功后可以访问query.jsp访问add.jsp自动跳转到un.jsp 因为jiaozi用户没有role2这个juese
测试登录自定义relam的zs用户 发现都可以进入
shiro通过自定义过滤器 定制自己的过滤规则 比如url信息全部位于数据库 需要所有的除了控制层的路径都经过自定义的url过滤可以添加类 继承自AuthorizationFilter实现isAccessAllowed方法
package cn.et.conf;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.apache.shiro.web.filter.authz.AuthorizationFilter;
public class MyFilter extends AuthorizationFilter {
/*
* 返回true表示允许访问 false表示不允许访问
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
throws Exception {
return false;
}
}myfilter=cn.et.conf.MyFilter
/** myfilter当用户访问了某个页面 通过authc过滤跳转到登录页面 当用户登录后 希望自动跳转到之前的页面 如果是直接进入的登录页就进入默认的页面 的实现过程
偶尔 有些无法跳转 结果下载了fav.ico 因为有时一个请求到页面 会顺带一个获取图标的请求 如果图标请求在后面 shiro记录的前面的途径就是这个图标的请求 此时在html添加 禁止网页图标的请求
@RequestMapping("loginBlog")
public String login(String userName,String password,HttpServletRequest request){
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken upt=new UsernamePasswordToken(userName,password);
try {
subject.login(upt);
subject.getSession().setAttribute("userInfo", userDao.queryByContent(userName, password).get(0));
//关键代码 shiro自动保存了上一次请求的地址 只需要获取并重新跳转即可
//可以使用WebUtils.issueRedirect重定向跳转
SavedRequest savedRequest = WebUtils.getSavedRequest(request);
if(savedRequest!=null)
return "redirect:"+savedRequest.getRequestURI()+"?"+savedRequest.getQueryString();
return "/queryBlog";
} catch (AuthenticationException e) {
return "redirect:/login.html";
}
}三。 shiro集成springboot
参考官网 spring集成 只是换成springboot （http://shiro.apache.org/spring.html）
添加maven的jsp支持和shiro-spring和springboot
org.springframework.boot
spring-boot-starter-parent
1.5.9.RELEASE
org.springframework.boot
spring-boot-starter-web
org.apache.tomcat.embed
tomcat-embed-jasper
org.apache.shiro
shiro-core
1.4.0
org.apache.shiro
shiro-web
1.4.0
org.apache.shiro
shiro-spring
1.4.0
commons-logging
commons-logging
1.2
package cn.et.boot;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.DelegatingFilterProxy;
import shiro.MyRealm;
@Configuration
public class Config {
/**
* 等價于 web.xml配置
* 自動 將 /*的請求 委託給spring容器中 bean名字和filter-name一致的bean處理
*
shiroFilter
org.springframework.web.filter.DelegatingFilterProxy
targetFilterLifecycle
true
shiroFilter
/*
* @return
*/
@Bean
public FilterRegistrationBean webShiroFilter(){
FilterRegistrationBean frb=new FilterRegistrationBean();
DelegatingFilterProxy dfp=new DelegatingFilterProxy();
frb.setFilter(dfp);
frb.setName("shiroFilter");
LinkedHashSet linkedHashSet = new LinkedHashSet();
linkedHashSet.add("/*");
frb.setUrlPatterns(linkedHashSet);
Map initParameters=new HashMap();
initParameters.put("targetFilterLifecycle", "true");
frb.setInitParameters(initParameters);
return frb;
}
/**
* 配置我的realm
* @return
*/
@Bean
public Realm myRealm(){
return new MyRealm();
}
/**
* 定義默認的securityManager
* @return
*/
@Bean
public DefaultWebSecurityManager securityManager(@Autowired Realm myRealm){
DefaultWebSecurityManager dwm=new DefaultWebSecurityManager();
dwm.setRealm(myRealm);
return dwm;
}
/**
* 定義和過濾器一致名字的ShiroFilterFactoryBean
*/
@Bean
public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){
ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();
sffb.setSecurityManager(securityManager);
sffb.setLoginUrl("/login.html");
sffb.setUnauthorizedUrl("/un.jsp");
Map urls=new HashMap();
/*
* 定义url
/login.html = anon
/loginServlet = anon
/query.jsp = authc
/add.jsp = roles[role2]
* */
urls.put("/login.html", "anon");
urls.put("/loginServlet", "anon");
urls.put("/query.jsp", "authc");
urls.put("/add.jsp", "roles[role1]");
sffb.setFilterChainDefinitionMap(urls);
return sffb;
}
/**
* 定義後置處理器
* @return
*/
@Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
return new LifecycleBeanPostProcessor();
}
}
package cn.et.boot;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class LoginController {
@RequestMapping("loginServlet")
public String login(String userName,String password){
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken upt=new UsernamePasswordToken(userName,password);
try {
subject.login(upt);
return "/query.jsp";
} catch (AuthenticationException e) {
return "redirect:/login.html";
}
}
}
package cn.et.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Main {
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
}
测试 输入错误的密码
测试使用zs登录 访问 add.jsp发现跳转到un.jsp
四。自定义filter实现动态配置url拦截
如果在spring中配置静态的url拦截 添加一个新的路径 每次都需要修改配置文件 如果使用springboot 每次都需要修改urls这个map 这个map是初始化bean
的时候创建 后面再往里面加是没有效果的 所以需要在拦截时自己手工调用对应的filter逻辑
@Bean
public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){
ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();
sffb.setSecurityManager(securityManager);
sffb.setLoginUrl("/login.html");
sffb.setUnauthorizedUrl("/un.jsp");
Map urls=new HashMap();
/*
* 定义url
/login.html = anon
/loginServlet = anon
/query.jsp = authc
/add.jsp = roles[role2]
* */
urls.put("/login.html", "anon");
urls.put("/loginServlet", "anon");
urls.put("/query.jsp", "authc");
urls.put("/add.jsp", "roles[role1]");
sffb.setFilterChainDefinitionMap(urls);
return sffb;
} package cn.et.conf;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import javax.servlet.Filter;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.CollectionUtils;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.apache.shiro.web.filter.authz.AuthorizationFilter;
import org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter;
import org.apache.shiro.web.filter.authz.RolesAuthorizationFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class MyFilter extends AuthorizationFilter {
static Map urls=new HashMap();
@Autowired
private ShiroFilterFactoryBean sffb;
/**
* 匹配指定过滤器规则的url
* @param regex
* @param url
* @return
*/
public static boolean matchUrl(String regex,String url){
regex=regex.replaceAll("/+", "/");
if(regex.equals(url)){
return true;
}
regex=regex.replaceAll("\\.", "\\\\.");
// /login.html /l*.html
regex=regex.replaceAll("\\*", ".*");
// /**/login.html /a/b/login.html
if(regex.indexOf("/.*.*/")>=0){
regex=regex.replaceAll("/\\.\\*\\.\\*/", "((/.*/)+|/)");
}
System.out.println(regex+"----"+url);
return Pattern.matches(regex, url);
}
/**
* 测试
* @param args
*/
public static void main(String[] args) {
System.out.println(matchUrl("/**/s*.html","/t/g/login.html"));
}
/**
* 在map中模拟 这个也可以将来定义在数据库中
*/
static{
urls.put("/login.html", "anon");
urls.put("/loginBlog", "anon");
urls.put("/un.jsp", "anon");
urls.put("/queryBlogByToken", "anon");
urls.put("/query.jsp", "authc");
urls.put("/add.jsp", "roles[role1]");
}
/**
* isAccessAllowed用于判断当前url的请求是否能验证通过 如果验证失败 调用父类的onAccessDenied决定跳转到登录失败页还是授权失败页面
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
throws Exception {
HttpServletRequest req=(HttpServletRequest)request;
String url=req.getRequestURI();
//通过url获取授权类型
String urlAuth=urls.get(url);
if(urlAuth==null){
return false;
}
//配置的过滤器是anon 直接放过
if(urlAuth.startsWith("anon")){
return true;
}
//配置的是authc 判断当前用户是否认证通过
Subject subject = getSubject(request, response);
if(urlAuth.startsWith("authc")){
return subject.isAuthenticated();
}
//授权认证 也需要判断是否登录 没有登录返回 登录继续下面的验证
boolean ifAuthc=subject.isAuthenticated();
if(!ifAuthc)
return ifAuthc;
//如果是定义的roles过滤器 获取所有的roles 一般是roles[a,b]
if(urlAuth.startsWith("roles")){
String[] rolesArray=urlAuth.split("roles\\[")[1].split("\\]")[0].split(",");
if (rolesArray == null || rolesArray.length == 0) {
return true;
}
Set roles = CollectionUtils.asSet(rolesArray);
return subject.hasAllRoles(roles);
}
if(urlAuth.startsWith("perms")){
String[] perms=urlAuth.split("perms\\[")[1].split("\\]")[0].split(",");
boolean isPermitted = true;
if (perms != null && perms.length > 0) {
if (perms.length == 1) {
if (!subject.isPermitted(perms[0])) {
isPermitted = false;
}
} else {
if (!subject.isPermittedAll(perms)) {
isPermitted = false;
}
}
}
return isPermitted;
}
return false;
}
}
@Bean
public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){
ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();
sffb.setSecurityManager(securityManager);
sffb.setLoginUrl("/login.html");
sffb.setUnauthorizedUrl("/un.jsp");
Map urls=new HashMap();
urls.put("/**", "myFilter");
sffb.setFilterChainDefinitionMap(urls);
return sffb;
} /**
* 多个relms 只要有一个realm的数据通过则通过
* @return
*/
@Bean
public ModularRealmAuthenticator authentictor(){
org.apache.shiro.authc.pam.ModularRealmAuthenticator mra=new org.apache.shiro.authc.pam.ModularRealmAuthenticator();
mra.setAuthenticationStrategy(new org.apache.shiro.authc.pam.FirstSuccessfulStrategy());
return mra;
}
/**
* 定義默認的securityManager
* @return
*/
@Bean
public DefaultWebSecurityManager securityManager(@Autowired Realm myRealm,@Autowired ModularRealmAuthenticator authentictor){
DefaultWebSecurityManager dwm=new DefaultWebSecurityManager();
dwm.setRealm(myRealm);
authentictor.setRealms(dwm.getRealms());
dwm.setAuthenticator(authentictor);
return dwm;
}