Shiro简介与入门
Apache Shiro是一个强大且易用的Java安全框架,有身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
Spring security 重量级安全框架
Apache Shiro轻量级安全框架
i. 导入jar
<dependencies>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
ii. 准备资源
资源我们可以到shiro的源码文件中拷备:
/shiro-root-1.4.0-RC2/samples/quickstart/src/main/resources
shiro.ini
log4j.properties
注:users下面代表的登录的用户(用户名=密码)
shiro.ini文件(对拷备过来的数据进行了解释):
#-----------------------------------------------------------------------------
所有的用户与对应的用户密码 ,用户的角色
-----------------------------------------------------------------------------
[users] root用户有一个密码是secret,他的角色是admin
root = secret, admin
guest = guest, guest
presidentskroob = 12345, president
darkhelmet用户有一个密码是ludicrousspeed,他的角色是darklord, schwartz
darkhelmet = ludicrousspeed, darklord, schwartz
lonestarr = vespa, goodguy, schwartz
-----------------------------------------------------------------------------
#所有的用户的角色
#-----------------------------------------------------------------------------
[roles]
#admin这个角色有所有权限功能
admin = *
#schwartz这个角色可以操作所有的lightsaber权限功能
schwartz = lightsaber:*
#goodguy这个角色可以操作winnebago下面的drive权限的一个eagle5资源
goodguy = winnebago:drive:eagle5
iii. 总结
- 通过SecurityManger获取Suject :
SecurityUtils.setSecurityManager(securityManager);
Subject currentUser = SecurityUtils.getSubject(); - 通过Subject来做事情:
获取Session-存值和获取值 Suject.getSession session.setAttribute session.getAttribute - 认证(登录):
判断是否登录Suject.isAuthenticated()
如果没有登录,通过用户名和密码创建UsernamePasswordToken
调用subject.login(UsernamePasswordToken)来进行登录判断
登陆成功: 返回principal给当前用户
登陆失败: 抛出异常
授权
判断是否具有某个角色subject .hasRole
判断是否有权限subject .isPrermited(resource:操作)
自定义Realm
i. 准备工作
自定义Realm一般直接继承AuthorizingRealm接口即可(里面包含身份认证与授权两个方法)
/**
* 自定义一个Realm
*/
public class MyRealm extends AuthorizingRealm {
//获取到这个Realm的名称(随便取)
@Override
public String getName() {
return "MyRealm";
}
//进行授权判断(权限)
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return null;
}
//进行身份认证(登录)
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
return null;
}
}
ii. 身份认证(登录)
身份认证的代码
/**
* 自定义一个Realm
*/
public class MyRealm extends AuthorizingRealm {
//获取到这个Realm的名称(随便取)
@Override
public String getName() {
return "MyRealm";
}
//进行授权的认证
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return null;
}
//进行登录的认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//明显的知道:这个authenticationToken就是UsernamePasswordtoken
UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
String username = token.getUsername(); //拿到用户名(注:这个用户名是传过来的)
//这里根据用户名去获取密码(如果没有获取到,相当于这个用户不存在,就返回null值)
String password = getByName(username);
if(password==null){
return null;
}
//创建一个简单的身份信息(把用户名与密码放进去-注:它会自动的比较获取的密码与你传过来的密码)
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username,password,getName());
return authenticationInfo;
}
//模拟从数据库中获取信息
private String getByName(String username) {
if("admin".equals(username)){
return "123456";
}else if("guest".equals(username)){
return "abcd";
}
return null;
}
}
iii. 授权(权限)认证
授权认证的代码
public class MyRealm extends AuthorizingRealm {
//获取到这个Realm的名称(随便取)
@Override
public String getName() {
return "MyRealm";
}
//进行授权的认证
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
//拿到认证的主要信息(用户名)
String username = (String) principalCollection.getPrimaryPrincipal();
//模拟根据用户名拿到角色信息与权限信息
Set<String> roles = getRolesByUsername(username);
Set<String> permissions = getPermissionsByUsername(username);
//拿到验证信息对象
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
//设置用户的角色
authorizationInfo.setRoles(roles);
//设置用户的权限
authorizationInfo.setStringPermissions(permissions);
return authorizationInfo;
}
//模拟根据用户名拿到角色的功能
private Set<String> getRolesByUsername(String username) {
Set<String> roles = new HashSet<>();
roles.add("admin");
roles.add("it");
return roles;
}
//模拟根据用户名拿到权限的功能
private Set<String> getPermissionsByUsername(String username) {
Set<String> permissions = new HashSet<>();
permissions.add("employee.*");
permissions.add("department.save");
return permissions;
}
......
}
密码加密功能
i. Shiro中密码加密
/**
* algorithmName:加密算法(md5,sha)
* source:原始密码
* salt,加盐
* hashIterations:遍历次数
*/
SimpleHash simpleHash = new SimpleHash("MD5","admin","itsource",10);
System.out.println(simpleHash);
ii. 测试时让自定义Reaml加上算法
@Test
public void testMyRealm() throws Exception{
//创建自己定义的Realm
MyRealm myRealm = new MyRealm();
//把Realm放到securityManager中去
DefaultSecurityManager securityManager = new DefaultSecurityManager();
securityManager.setRealm(myRealm);
//把权限管理器放到相应的环境中(我们可以在项目任何位置拿到)
SecurityUtils.setSecurityManager(securityManager);
//设置咱们Realm的密码匹配器(我们的密码要怎么处理)
HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
matcher.setHashAlgorithmName("md5"); //匹配器使用MD5的算法
matcher.setHashIterations(10);//加密算法要迭代多少次
myRealm.setCredentialsMatcher(matcher);
//拿到当前用户(Subject就是当前用户,游客)
Subject currentUser = SecurityUtils.getSubject();
//准备登录的令牌(准备用户名与密码) -> 这里的密码进行了加密
UsernamePasswordToken token = new UsernamePasswordToken("admin","123456");
try {
//根据令牌进行功能登录(当前用户进行登录)
currentUser.login(token);
System.out.println("登录成功啦。。。。");
} catch (UnknownAccountException e) {
System.out.println("这个账号不存在!" + token.getPrincipal());
e.printStackTrace();
} catch (IncorrectCredentialsException ice) {
System.out.println("这个密码不存在!" + token.getPrincipal());
ice.printStackTrace();
}catch (AuthenticationException e){
System.out.println("i don't k");
}
}
iii. 自定义Reaml加上盐值
//进行登录的认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//明显的知道:这个authenticationToken就是UsernamePasswordtoken
UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
String username = token.getUsername(); //拿到用户名(注:这个用户名是传过来的)
//这里根据用户名去获取密码(如果没有获取到,相当于这个用户不存在,就返回陪我)
String password = getByName(username);
if(password==null){
return null;
}
//在这里加盐值需一个ByteSource对象,而Shiro提供了一个ByteSource对象给咱们
ByteSource salt = ByteSource.Util.bytes("itsource");
//创建一个简单的身份信息(把用户名与密码放进去-注:它会自动的比较获取的密码与你传过来的密码)
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username,password,salt,getName());
return authenticationInfo;
}
private String getByName(String username) {
if("admin".equals(username)){
// 4a95737b032e98a50c056c41f2fa9ec6: 123456 迭代10次不加盐的结果
// 831d092d59f6e305ebcfa77e05135eac: 123456 迭代10次加盐(itsource)的结果
return "831d092d59f6e305ebcfa77e05135eac"; //修改为加密加盐后的数据
}else if("guest".equals(username)){
return "abcd";
}
return null;
}
Shiro集成Spring
i. 准备Spring-web项目
拷备咱们的SSJ集成项目/直接在当前配置中完成
ii. 集成
1)导入shiro-all-1.3.2.ja(现升级到1.4.0)r
参考官方demo做示例:
<!-- shiro的支持包 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-all</artifactId>
<version>1.4.0</version>
<type>pom</type>
</dependency>
<!-- shiro与Spring的集成包 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency>
2)拷贝shiroFilter配置到web.xml
<!-- Spring与shiro集成:需要定义一个shiro过滤器(这是一个代理过滤器,它会到spring的配置中找一个名称相同的真实过滤器) -->
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
3)拷贝shiro Spring配置文件并集成到Spring
applicationContext.xml 改名为applicationContext-shiro.xml并在applicationContext.xml中导入
4)修改配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- 1.配置apache的管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 配置一个realm,到数据库中获取权限数据 -->
<property name="realm" ref="jpaRealm"/>
</bean>
<!-- 2.我们可以自定义一个realm【暂时未实现功能】这个必需实现org.apache.shiro.realm.Realm接口 -->
<bean id="jpaRealm" class="cn.itsource.yxb.shiro.realm.JpaRealm">
</bean>
<!-- 3.lifecycleBeanPostProcessor:可以自动调用在Spring Ioc窗口中 Shiro bean的生成周期方法 -->
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
<!-- 4.启动ioc容器中使用 shiro的注解,但是必需配置在Spring Ioc容器中Shiro bean的生成周期方法 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
depends-on="lifecycleBeanPostProcessor"/>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager"/>
</bean>
<!-- 5.shiro的真实过滤器(注:这个名称必需和web.xml的代表过滤器【DelegatingFilterProxy】名称一样) -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<!-- 登录的url,如果没有登录,你访问的路径会跳到这个页面 -->
<property name="loginUrl" value="/s/login.jsp"/>
<!-- 登录成功的url,如果登录成功,会跳转到这个页面 -->
<property name="successUrl" value="/s/main.jsp"/>
<!-- 没有权限时跳转到这个位置 -->
<property name="unauthorizedUrl" value="/s/unauthorized.jsp"/>
<!--
配置哪些资源被保护,哪些资源需要权限
anon:不需要登录也可以访问相应的权限
authc:需要权限才能访问
/** :所有文件及其子文件
-->
<property name="filterChainDefinitions">
<value>
/s/login.jsp = anon
/** = authc
</value>
</property>
</bean>
</beans>
Authentication(身份认证)
i. 详细步骤分析
要想实现登录,分前台和后台两部分:
前台:
实现一个login.jsp的页面,用来搜集登录信息(用户名和密码)!当点击登录时把登录信息提交到后台完成认证。
后台:
写一个Controller接收前台传入的登录信息,完成登录认证。
具体步骤如下:
1)创建LoginConroller,写一个方法接收前台登录请求并接受登录信息(用户名和密码)
2)获取当前的 Subject. 调用 SecurityUtils.getSubject();
3)测试当前的用户是否已经被认证. 即是否已经登录. 调用 Subject 的 isAuthenticated()
4)若没有被认证, 则把用户名和密码封装为 UsernamePasswordToken 对象
5)执行登录: 调用 Subject 的 login(AuthenticationToken) 方法.
6)自定义 Realm 的方法, 从数据库中获取对应的记录, 返回给 Shiro.
入门中使用的是Shiro自带的IniRealm,IniRealm从ini配置文件中读取用户的信息,大部分情况下需要从系统的数据库中读取用户信息,所以需要自定义realm。
实际上需要继承 org.apache.shiro.realm.AuthenticatingRealm 类
实现 doGetAuthenticationInfo(AuthenticationToken) 方法.
7)由 shiro 完成对密码的比对.
ii. 简单认证实现
login.jsp
<form action="/login" method="post">
用户名<input type="text" name="username" /> <br />
密码:<input type="password" name="password" /> <br />
<input type="submit" value="登录" />
</form>
LoginController
@Controller
public class LoginController {
@RequestMapping("/login")
public String login(String username,String password){
/**
* 获取当前的 Subject. 调用 SecurityUtils.getSubject();
* 测试当前的用户是否已经被认证. 即是否已经登录. 调用 Subject 的 isAuthenticated()
* 若没有被认证, 则把用户名和密码封装为 UsernamePasswordToken 对象
* 执行登录: 调用 Subject 的 login(AuthenticationToken) 方法.
*/
//1.拿到访问的主体(当前登录用户)
Subject subject = SecurityUtils.getSubject();
//2.判断这个用户是否已经登录(通过验证)
if(!subject.isAuthenticated()){
//3.如果没有验证,就要完成登录
UsernamePasswordToken token = new UsernamePasswordToken(username,password);
try{
//4.根据toke完成登录功能
subject.login(token);
}catch (UnknownAccountException e){
System.out.println("用户名不存在!!");
e.printStackTrace();
}catch (IncorrectCredentialsException e){
System.out.println("密码不存在!");
e.printStackTrace();
}catch (AuthenticationException e){
System.out.println("登录出错!");
e.printStackTrace();
}
}
return "redirect:/s/main.jsp";
}
}
JpaRealm
public class JpaRealm extends AuthenticatingRealm {
//AuthenticationInfo:认证; 身份验证; 证明
//登录的时候就会调用这个方法来做验证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
//System.out.println(token.getClass().getName());
//可以转成相应的token
//UsernamePasswordToken upToken =(UsernamePasswordToken)token;
//拿到传过来的用户名
//String username = upToken.getUsername();
//自定义Realm中,需要根据用户名到数据库中拿到密码,然后返回给shiro
//String password = "123456";
//身份认证(用户名)
Object principal = token.getPrincipal();
Object credentials = "123456"; //密码假设是根据用户名到数据库中查询出来的
// Object principal, Object credentials, String realmName
return new SimpleAuthenticationInfo(principal,credentials,getName());
}
}
iii. 加密认证
分析:
1、密码不能明文保存到数据库 加密保存,比对也要加密比对,具体的比对CredentialsMatcher,默认使用就是SimpleCredentialsMatcher,不做加密的比对.要想做md5加密要使用HashedCredentialsMatcher,并且设置加密为md5
数据库加密保存
加密比对代码实现
//完成登录的认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
String username = token.getUsername();
String dbPassword = findByUsername(token.getUsername());
if(dbPassword==null){
return null;
}
SimpleAuthenticationInfo authorizationInfo = new SimpleAuthenticationInfo(username,dbPassword,getName());
return authorizationInfo;
}
private String findByUsername(String username) {
if("admin".equals(username)){
//这里是没有加盐的结果
return "4a95737b032e98a50c056c41f2fa9ec6";
}
return null;
}
设置Realm的匹配值:
<!-- 2.我们可以自定义一个realm 这个必需实现org.apache.shiro.realm.Realm接口 -->
<bean id="jpaRealm" class="cn.itsource.yxb.shiro.realm.JpaRealm">
<property name="credentialsMatcher">
<!—设置加密匹配方案-->
<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<!-- 编码的方式使用:md5 -->
<property name="hashAlgorithmName" value="MD5"/>
<!-- 编码的次数:10 -->
<property name="hashIterations" value="10"/>
</bean>
</property>
</bean>
iv. 盐值加密认证
为什么要使用盐值加密。盐值加密,更安全!
数据库要加密保存
@Test
public void testHash() throws Exception{
/**
* algorithmName:加密算法(md5,sha)
* source:原始密码
* salt,加盐
* hashIterations:遍历次数
*/
SimpleHash simpleHash = new SimpleHash("MD5","123456","itsource",10);
System.out.println(simpleHash);
}
认证时要支持盐值
//AuthenticationInfo:认证; 身份验证; 证明
//登录的时候就会调用这个方法来做验证
//进行登录的认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//明显的知道:这个authenticationToken就是UsernamePasswordtoken
UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
String username = token.getUsername(); //拿到用户名(注:这个用户名是传过来的)
//这里根据用户名去获取密码(如果没有获取到,相当于这个用户不存在,就返回陪我)
String password = getByName(username);
if(password==null){
return null;
}
//在这里加盐值需一个ByteSource对象,而Shiro提供了一个ByteSource对象给咱们
ByteSource salt = ByteSource.Util.bytes("itsource");
//创建一个简单的身份信息(把用户名与密码放进去-注:它会自动的比较获取的密码与你传过来的密码)
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username,password,salt,getName());
return authenticationInfo;
}
private String getByName(String username) {
if("admin".equals(username)){
// 4a95737b032e98a50c056c41f2fa9ec6: 123456 迭代10次不加盐的结果
// 831d092d59f6e305ebcfa77e05135eac: 123456 迭代10次加盐(itsource)的结果
return "831d092d59f6e305ebcfa77e05135eac"; //修改为加密加盐后的数据
}else if("guest".equals(username)){
return "abcd";
}
return null;
}
Authorizing(授权)
Shiro的三种权限判断方式
- 编程式
通过写if/else 授权代码块完成:
Subject subject = SecurityUtils.getSubject();
if(subject.hasRole(“admin”)) {
//有权限
} else {
//无权限
}
- 注解式
通过在执行的Java方法上放置相应的注解完成:
@RequiresRoles("admin")
public void hello() {
//有权限
}
- JSP/GSP 标签
在JSP/GSP 页面通过相应的标签完成:
<%@taglib prefix=”shiro” uri=”http://shiro.apache.org/tags”%>
<shiro:hasRole name="admin">
<!— 有权限—>
<button>删除</button>
</shiro:hasRole>
//1、控制哪些资源要做权限拦截 如果不做拦截,直接放行,如果要拦截就要做权限判断
//2、获取用户能够访问资源,如果你访问资源在里面,说明有权限。可以访问,否则不能访问。
不控制直接放行,要控制查看用户是否拥有,如果有直接访问,否则不能访问
授权拦截
权限拦截同样需要从数据库中获取权限或角色信息,所以同样需要自定义Realm.
注意:现要权限写死在配置中!
<!-- 5.shiro的真实过滤器(注:这个名称必需和web.xml的代表过滤器【DelegatingFilterProxy】名称一样) -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<!-- 登录的url,如果没有登录,你访问的路径会跳到这个页面 -->
<property name="loginUrl" value="/s/login.jsp"/>
<!-- 登录成功的url,如果登录成功,会跳转到这个页面 -->
<property name="successUrl" value="/s/main.jsp"/>
<!-- 没有权限时跳转到这个位置 -->
<property name="unauthorizedUrl" value="/s/unauthorized.jsp"/>
<!--
配置哪些资源被保护,哪些资源需要权限
anon:不需要登录也可以访问相应的权限
authc:需要权限才能访问
/** :所有文件及其子文件
-->
<property name="filterChainDefinitions">
<value>
/s/login.jsp = anon
/login = anon
<!--对资源进行权限控制,要控制的资源都应该从数据库查出,现在咱们先写死-->
/s/permission.jsp = perms[user:*]
/** = authc
</value>
</property>
</bean>
- 自定义Realm授权
授权需要继承 AuthorizingRealm 类, 并实现其 doGetAuthorizationInfo 方法
AuthorizingRealm 类继承自 AuthenticatingRealm, 但没有实现 AuthenticatingRealm 中的doGetAuthenticationInfo, 所以认证和授权只需要继承 AuthorizingRealm 就可以了. 同时实现他的两个抽象方法.
具体实现:
public class JpaRealm extends AuthorizingRealm {
//AuthorizationInfo:授权(是否有权限进入操作)
// 我们只需要把相应的权限交给Shiro,它就会自动比对
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//拿到主体信息(指的就是当前登录用户名) -> 咱们的权限应该是根据当前用户进行查询到的
String username = (String) principals.getPrimaryPrincipal();
System.out.println("后面需要根据用户名获取资源"+username);
//获取权限资源(这里假设已经根据用户名到数据库中获取到了)
Set<String> permissions = new HashSet<>();
permissions.add("user:*");
//拿到授权对象,并且所有权限交给它
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
simpleAuthorizationInfo.setStringPermissions(permissions);
//返回授权对象
return simpleAuthorizationInfo;
}
//AuthenticationInfo:认证; 身份验证; 证明
//登录的时候就会调用这个方法来做验证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
/**
* Object principal:主体(现在就是登录的用户名)
* Object hashedCredentials:编码后的认证密码
* ByteSource credentialsSalt:加盐
* String realmName
*/
//身份认证(用户名)
Object principal = token.getPrincipal();
//密码假设是根据用户名到数据库中查询出来的(数据库密码是经过加密的)
Object credentials = "d5a3fedf6c59c2ecbe7f7a6c1a22da37";
//加盐的数据
ByteSource byteSource = ByteSource.Util.bytes("itsource");
return new SimpleAuthenticationInfo(principal,credentials,byteSource,getName());
}
}
项目中使用
i. 授权数据库查询
要控制权限的资源做拦截
/**
* 准备一个构造器类
*/
public class FilterChainDefinitionMapBuilder {
public Map<String,String> createFilterChainDefinitionMap(){
Map<String, String> filterChainDefinitionMap = new LinkedHashMap();
filterChainDefinitionMap.put("/s/login.jsp","anon");
filterChainDefinitionMap.put("/login","anon");
//这个值之后从数据库中查询到【用户-角色-权限-资源】
filterChainDefinitionMap.put("/s/permission.jsp","perms[user:*]");
filterChainDefinitionMap.put("//**","authc");
return filterChainDefinitionMap;
}
}
<!-- 5.shiro的真实过滤器(注:这个名称必需和web.xml的代表过滤器【DelegatingFilterProxy】名称一样) -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<!-- 登录的url,如果没有登录,你访问的路径会跳到这个页面 -->
<property name="loginUrl" value="/s/login.jsp"/>
<!-- 登录成功的url,如果登录成功,会跳转到这个页面 -->
<property name="successUrl" value="/s/main.jsp"/>
<!-- 没有权限时跳转到这个位置 -->
<property name="unauthorizedUrl" value="/s/unauthorized.jsp"/>
<!--
配置哪些资源被保护,哪些资源需要权限
anon:不需要登录也可以访问相应的权限
authc:需要权限才能访问
/** :所有文件及其子文件
-->
<!--<property name="filterChainDefinitions">-->
<!--<value>-->
<!--/s/login.jsp = anon-->
<!--/login = anon-->
<!--对资源进行权限控制,要控制的资源都应该从数据库查出,现在咱们先写死-->
<!--/s/permission.jsp = perms[user:*]-->
<!--/** = authc-->
<!--</value>-->
<!--</property>-->
<!-- 这个配置我们可以直接给一个map(动态的可以从代码中获取) -->
<property name="filterChainDefinitionMap" ref="filterChainDefinitionMap"></property>
</bean>
<!-- 这个bean是帮助咱们获取相应的值:它会到一个工厂bean中通过对应的方法拿到相应的值 -->
<bean id="filterChainDefinitionMap" factory-bean="filterChainDefinitionMapBuilder" factory-method="createFilterChainDefinitionMap"></bean>
<!-- 配置可以创建 -->
<bean id="filterChainDefinitionMapBuilder" class="cn.itsource.yxb.shiro.realm.FilterChainDefinitionMapBuilder"></bean>
</beans>