一、Shiro
为什么要用shiro:
1.项目中的密码是否可以明文存储?
2.是否任意访客,无论是否登录都可以访问任何功能?
3.项目中的各种功能操作,是否是所有用户都可以随意使用?
综上,当项目中的某些功能被使用时,需要进行安全校验,进而保证整个系统的运行秩序。
1.1 Shiro是什么
• Apache Shiro 是 Java 的一个安全(权限)框架。
Shiro 可以轻松的完成:身份认证、授权、加密、会话管理等功能
• Shiro 可以非常容易的开发出足够好的应用,其不仅可以用在JavaSE 环境,也可以用在 JavaEE 环境。
功能强大且易用,可以快速轻松地保护任何应用程序 ( 从最小的移动应用程序到最大的Web和企业应用程序。)
• 方便的与Web 集成和搭建缓存。
• 下载:http://shiro.apache.org/
1.2 功能简介
• 基本功能点如下图所示:
• Authentication
身份认证/登录,验证用户是不是拥有相应的身份;
• Authorization
授权,即权限验证,验证某个已认证的用户是否拥有某个权限;即判断用户是否能进行什么操作
如:验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限;
• Session Manager
会话管理,即用户登录后就是一次会话,在没有退出之前,它的所有
信息都在会话中;会话可以是普通 JavaSE 环境,也可以是 Web 环境的;
• Cryptography
加密,保护数据的安全性,如密码加密存储到数据库,而不是明文存储;
• Web Support
Web 支持,可以非常容易的集成到Web 环境;
• Caching
缓存,比如用户登录后,其用户信息、拥有的角色/权限不必每次去查,这样可以提高效率;
• Remember Me
记住我,这个是非常常见的功能,即一次登录后,下次再来的话可以立即知道你是哪个用户
。。。。
二、Shiro 架构
2.1 工作流程
shiro 运行流程中,3个核心的组件:
Subject、SecutiryManager、Realm
shiro使用中,必须有的3个概念!!
• Subject
安全校验中,最常见的问题是"当前用户是谁?" "当前用户是否有权做x事?",所以考虑安全校验过程最自
然的方式就是基于当前用户。Subject 代表了当前“用户”,
应用代码直接交互的对象是 Subject,只要得到Subject对象马上可以做绝大多数的shiro操作。
也就是说 Shiro 的对外API 核心就是 Subject。
Subject 会将所有交互都会委托给 SecurityManager。
==Subject是安全管理中直接操作的对象==
• SecurityManager
安全管理器;即所有与安全有关的操作都会与SecurityManager 交互;
且其管理着所有 Subject;它是 Shiro的核心,
它负责与 Shiro 的其他组件进行交互,它相当于 SpringMVC 中DispatcherServlet 的角色
• Realm
Shiro 从 Realm 获取安全数据(如用户、角色、权限),就是说SecurityManager 要验证用户身份,那么
它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法;
也需要从 Realm 得到用户相应的角色/权限进行验证用户是否能进行操作;
可以把 Realm 看成 DAO,( 数据访问入口 )
2.2 RBAC模型
Role Base Access Controll 基于角色的访问控制
shiro采用的安全管理 模型
模型中3个主体:用户、角色、权限
每个角色可以有多个权限,每个权限可以分配给多个角色
每个用户可以有多个角色,每个角色可以分配给多个用户
两个多对多
则权限访问控制,做的事是:
- 身份校验:判断是否为合法用户
- 权限校验:用户要做做某件事或使用某些资源,必须要拥有某角色,或必须拥有某权限
2.3 架构(了解)
简单了解,在对shiro有了完整的应用体验后可以重点了解!
• Subject
任何可以与应用交互的“用户”;
• SecurityManager
相当于SpringMVC 中的 DispatcherServlet;是 Shiro 的心脏;
所有具体的交互都通过 SecurityManager 进行控制;它管理着所有 Subject、且负责进行认证、授权、会话及
缓存的管理。
• Authenticator
负责 Subject 身份认证,是一个扩展点,可以自定义实现;可以使用认证
策略(Authentication Strategy),即什么情况下算用户认证通过了;
• Authorizer
授权器、即访问控制器,用来决定主体是否有权限进行相应的操作;即控制着用户能访问应用中的哪些功能;
• Realm
可以有 1 个或多个 Realm,可以认为是安全实体数据源,即用于获取安全实体
的;可以是JDBC 实现,也可以是内存实现等等;由用户提供;所以一般在应用中都需要
实现自己的 Realm;
• SessionManager
管理 Session 生命周期的组件;而 Shiro 并不仅仅可以用在 Web环境,也可以用在如普通的 JavaSE 环境
• CacheManager
缓存控制器,来管理如用户、角色、权限等的缓存的;因为这些数据基本上很少改变,
放到缓存中后可以提高访问的性能
• Cryptography
密码模块,Shiro 提供了一些常见的加密组件用于如密码加密/解密。
三、HelloWorld
3.1 pom 文件
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
ops : require JDK 1.6+ and Maven 3.0.3+
3.2 配置
创建一个shiro.ini文件
#定义用户信息
#格式:用户名=密码,角色1,角色2,....
[users]
zhangsan=123,admin
lisi=456,manager,seller
wangwu=789,clerk
# -----------------------------------------------------------------------------
# 角色及其权限信息
# 预定权限:user:query
# user:detail:query
# user:update
# user:delete
# user:insert
# order:update
# ....
[roles]
# admin 拥有所有权限,用*表示
admin=*
# clerk 只有查询权限
clerk=user:query,user:detail:query
# manager 有 user 的所有权限
manager=user:*
3.3 代码
- 通过在ini中设置的 身份信息、角色、权限,做安全管理
- 1.身份认证: subject.login(token)
- 2.是否认证身份判断:subject.isAuthenticated()
- 3.角色校验:subject.hasRole(String:role); subject.hasRoles(List:roles)
- 4.权限校验:subject.isPermitted(String:perm); subject.isPermittedAll(List:perms)
// 定义main函数测试效果
// 创建 "SecurityFactory",加载ini配置,并通过它创建SecurityManager
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
SecurityManager securityManager = factory.getInstance();
// 将SecurityManager托管到SecurityUtils工具类中(ops:之后可以不必关心SecurityManager)
SecurityUtils.setSecurityManager(securityManager);
// 获得Subject,通过subject可以执行shiro的相关功能操作(身份认证或权限校验等)
Subject currentUser = SecurityUtils.getSubject();
// 身份认证( 类似登录逻辑 )
if (!currentUser.isAuthenticated()) {//判断是否已经登录
//如果未登录,则封装一个token,其中包含 用户名和密码
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
try {
//将token传入login方法,进行身份认证 (判断用户名和密码是否正确)
currentUser.login(token);//如果失败则会抛出异常
} catch (UnknownAccountException uae) {//用户不存在
System.out.println("There is no user with username of " + token.getPrincipal());
} catch (IncorrectCredentialsException ice) {//密码错误
System.out.println("Password for account " + token.getPrincipal() + " was incorrect!");
} catch (LockedAccountException lae) {//账户冻结
System.out.println("The account for username " + token.getPrincipal() + " is locked. "
+"Please contact your administrator to unlock it.");
}catch (AuthenticationException ae) {//其他认证异常
}
}
// 认证成功则用户信息会存入 currentUser(Subject)
System.out.println("User [" + currentUser.getPrincipal() + "] logged in successfully.");
// 可以进一步进行角色校验 和 权限校验
if (currentUser.hasRole("admin")) { //校验角色
System.out.println("hello,boss");
} else {
System.out.println("Hello, you");
}
if (currentUser.isPermitted("user:update")) { //校验权限
System.out.println("you can update user");
} else {
System.out.println("Sorry, you can not update.");
}
// 用户退出,会清除用户状态
currentUser.logout();
// System.exit(0);
3.4 权限规则
最常用的权限标识:【资源 :操作】
1> user:query , user:insert , order:delete , menu:show
【:】 作为分隔符,分隔资源和操作【资源:操作】
【,】 作为分隔,分隔多个权限【权限1,权限2,权限3】
2> user:* , *:query
【*】 作为通配符,代表所有操作、资源
【user:* 即user的所有操作】
【*:query 即所有资源的查询操作】
3> *
【代表一切资源的一切权限 = 最高权限】
4> 细节:
1)【user:* 可以匹配 user:xx, user:xx:xxx】
【*:query 只可以匹配 xx:query,不能匹配 xx:xx:query. 除非 *:*:query】
2)【user:update,user:insert】 可以简写为 【"user:update,insert"】
[roles]
manager1=user:query,user:update,user:insert
manager2="user:query,update,insert" #注意要加引号
#如上manager1和manager2权限等价
#subject.isPermittedAll("user:update","user:insert","user:query")
实例级权限标识:【资源 :操作 :实例】,粒度细化到具体某个资源实例
1> user:update:1 , user:delete:1
# 对用户1可以update,对用户1可以delete
2> "user:update,delete:1" #和上面等价
# subject.isPermittedAll("user:update,delete:1","user:update:1","user:delete:1")
3> user:*:1 , user:update:* , user:*:*
四、自定义Realm
存在的问题:目前所有的 用户、角色、权限数据都在ini文件中,不利于管理。
实际项目开发中这些信息,应该在数据库中。所以需要为这3类信息建表
4.1 建表
用户表,角色表,权限表
create table t_user(
id int primary key auto_increment,
username varchar(20) not null unique,
password varchar(100) not null
)engine=innodb default charset=utf8;
create table t_role(
id int primary key auto_increment,
role_name varchar(50) not null unique,
create_time timestamp not null
)engine=innodb default charset=utf8;
create table t_permission(
id int primary key auto_increment,
permission_name varchar(50) not null unique,
create_time timestamp
)engine=innodb default charset=utf8;
create table t_user_role(
id int primary key auto_increment,
user_id int references t_user(id),
role_id int references t_role(id),
unique(user_id,role_id)
)engine=innodb default charset=utf8;
create table t_role_permission(
id int primary key auto_increment,
permission_id int references t_user(id),
role_id int references t_role(id),
unique(permission_id,role_id)
)engine=innodb default charset=utf8;
4.2 自定义Realm
Realm的职责是,为shiro加载 用户,角色,权限数据,以供shiro内部校验。
之前定义在ini中的数据,默认有IniRealm去加载。
现在库中的数据,需要自定义Realm去加载。
ops : 没必要在Realm中定义大量的查询数据的代码,可以为Realm定义好查询数据的DAO和Service。
4.2.1 父类
如下是Realm接口的所有子类,其中IniRealm是默认的Realm,负责加载shiro.ini中的[users]和[roles]信息,当shiro需要用户,角色,权限信息时,会通过IniRealm获得。****
自定义realm有两个父类可以选择:
1> 如果realm只负责做身份认证 ,则可以继承:AuthenticatingRealm
2> 如果realm要负责身份认证和权限校验,则可以继承:AuthorizingRealm
4.2.2 定义Realm
public class MyRealm extends AuthorizingRealm {
/**
* 是否支持某种token
* @param token
* @return
*/
@Override
public boolean supports(AuthenticationToken token) {
System.out.println("is support in realm1");
if(token instanceof UsernamePasswordToken){
return true;
}
return false;
}
/**
* 当subject.login()时,shiro会调用Realm的此方法做用户信息的查询,然后做校验
* 职责:通过用户传递来的用户名查询用户表,获得用户信息
* 返回值:将查到的用户信息(用户名+密码)封装在AuthenticationInfo对象中返回
* 异常:如果没有查到用户可抛出用户不存在异常;如果用户被锁定可抛出用户被锁异常;或其它自定义异常.
* @param token
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
//获得用户名
String username = (String) token.getPrincipal();
System.out.println("user:"+username+" is authenticating~~");
UserService userService =
(UserService)ContextLoader.getCurrentWebApplicationContext().getBean("userService");
//身份认证
User user = userService.queryUser(username);
System.out.println("user:"+user);
/**
如果查询结果为空,直接返回null即可,
shiro的后续流程有null判断逻辑,为null时会抛出UnknownAccountException
**/
if(user == null){
return null;
}
// 将 当前用户的认证信息存入 SimpleAuthenticationInfo 并返回
// 注意此方法的本职工作就是查询用户的信息,所以查到后不用比对密码是否正确,那是shiro后续流程的职责。
// 如果密码错误,shiro的后续流程中会抛出异常IncorrectCredentialsException
return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(),getName());
/**
补充: 可以在user表中增加一列,用于存储用户是否被锁定,则查询的User对象中会有是否锁定的属性
如果发现锁定则可以在此方法中抛出异常:LockedAccountException,
**/
}
/**
* 当触发权限或角色校验时:subject.isPermitted() / subject.checkPermission();
* subject.hasRole() / subject.checkRole() 等。
* 此时需要数据库中的 权限和角色数据,shiro会调用Realm的此方法来查询
* 角色和权限信息存入SimpleAuthorizationInfo对象
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//获得username
String username = (String)principals.getPrimaryPrincipal();
//新建SimpleAuthorizationInfo对象
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
//查询当前用户的所有 "角色" 和 "权限"
UserService userService =
(UserService)ContextLoader.getCurrentWebApplicationContext().getBean("userService");
Set<String> roles = userService.queryRolesByUsername(username);
Set<String> perms = userService.queryPermissionsByUsername(username);
//“角色” 和 “权限” 存入 SimpleAuthorizationInfo对象
info.setRoles(roles);
info.setStringPermissions(perms);
//返回SimpleAuthorizationInfo
return info;
}
}
4.3 配置Realm
shiro.ini中 配置自定义Realm
注意:[users] [roles] 两个部分不再需要
[main]
#注意:此处实在安装自定义Realm 指定realm
#声明Realm 名称 = Realm类路径
realm1 = com.zhj.realm.MyRealm
realm2 = com.zhj.realm.MyRealm2
#安装Reaml 关联到SecurityManager
securityManager.realms=$realm1,$realm2
五、与Web 集成
与web项目集成后,shiro的工作模式如下:
如上:ShiroFilter拦截所有请求,对于请求做访问控制
如请求对应的功能是否需要有 认证的身份,是否需要某种角色,是否需要某种权限。
1> 如果没有做 身份认证,则将请求强制跳转到登录页面。
如果没有充分的角色或权限,则将请求跳转到权限不足的页面。
2> 如果校验成功,则执行请求的业务逻辑
5.1 pom
<!-- ============ Servlet ============ -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- ============== SpringMVC ============== -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.6.RELEASE</version>
</dependency>
<!-- ============ shiro ============ -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.4.0</version>
</dependency>
<!-- ============ log ============ -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
</dependency>
5.2 代码:Controller
定义一些Servlet 或 springMVC的controller,发送请求,验证shiro的验证
如下代码,除了登录中要用到 Shiro的Subject,其余没改动
@Controller
@RequestMapping("/user")
public class ShiroController {
@RequestMapping("/delete")
public String deleteUser(){//访问此删除功能时要先经过shiro的安全校验
System.out.println("delete User");
return "forward:/xx.jsp";
}
@RequestMapping("/update")
public String updateUser(){//访问此更新功能时要先经过shiro的安全校验
System.out.println("update User");
return "forward:/xx.jsp";
}
@RequestMapping("/insert")
public String insertUser(){//访问此增加功能时要先经过shiro的安全校验
System.out.println("insert User");
return "forward:/xx.jsp";
}
@RequestMapping("/login/page")
public String login(String username,String password){
System.out.println("goto login.jsp");
return "forward:/login.jsp";
}
@RequestMapping("/login/logic")
public String login(String username,String password){//登录功能不能被shiro校验,否则永不能登录
try{
Subject subject = SecurityUtils.getSubject();
subject.login(new UsernamePasswordToken(username,password));
String uname = (String)subject.getPrincipal();
System.out.println("uname:"+uname);
}catch (AuthenticationException e){
e.printStackTrace();
return "redirect:/login.jsp";
}
return "forward:/success.jsp";
}
}
5.3 配置
5.3.1 web.xml
安装 ShiroFilter
<!-- 接收所有请求,以通过请求路径 识别是否需要 安全校验,如果需要则触发安全校验
做访问校验时,会遍历过滤器链。(链中包含shiro.ini中urls内使用的过滤器)
会通过ThreadContext在当前线程中绑定一个subject和SecurityManager,供请求内使用
可以通过SecurityUtils.getSubject()获得Subject
-->
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 在项目启动时,加载web-info 或 classpath下的 shiro.ini ,并构建WebSecurityManager。
构建所有配置中使用的过滤器链(anon,authc等),ShiroFilter会获取此过滤器链
-->
<listener>
<listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>
</listener>
<!-- 自定义ini文件名称和位置
<context-param>
<param-name>shiroConfigLocations</param-name>
<param-value>classpath:shiro9.ini</param-value>
</context-param>-->
<!-- springMVC的配置照旧,此处省略...-->
5.3.2 shiro.ini
新增部分(section) [urls]
如下定义shiro的Realm、访问控制细节
[main]
#没有身份认证时,跳转地址
shiro.loginUrl = /user/login/page
#角色或权限校验不通过时,跳转地址
shiro.unauthorizedUrl=/author/error
#登出后的跳转地址,回首页
shiro.redirectUrl=/
#注意:此处实在安装自定义Realm 指定realm
#声明Realm 名称 = Realm类路径
realm1 = com.zhj.realm.MyRealm
realm2 = com.zhj.realm.MyRealm2
#安装Reaml 关联到SecurityManager
securityManager.realms=$realm1,$realm2
[urls]
# 如下格式:"访问路径 = 过滤器"
#【1.ant路径:? * ** 细节如下】
# /user/login/page , /user/login/logic 是普通路径
# /user/* 代表/user后还有一级任意路径 : /user/a , /user/b , /user/c , /user/xxxxxxxxxxx
# /user/** 代表/user后还有任意多级任意路径: /user/a , /user/a/b/c , /user/xxxx/xxxxxx/xxxxx
# /user/hello? 代表hello后还有一个任意字符: /user/helloa , /user/hellob , /user/hellox
#【2.过滤器,细节如下】
# anon => 不需要身份认证
# authc => 指定路径的访问,会验证是否已经认证身份,如果没有则会强制转发到 最上面配置的loginUrl上
# ( ops:登录逻辑本身千万不要被认证拦截,否则无法登录 )
# logout => 访问指定的路径,可以登出,不用定义handler。
# roles["manager","seller"] => 指定路径的访问需要subject有这两个角色
# perms["user:update","user:delete"] => 指定路径的访问需要subject有这两个权限
/user/login/page = anon
/user/login/logic = anon
/user/query = authc
/user/update = authc,roles["manager","seller"]
/user/delete = authc, perms["user:update","user:delete"]
/user/logout = logout
#其余路径都需要身份认证【用此路径需谨慎】
/** = authc
#【3.注意】
# url的匹配,是从上到下匹配,一旦找到可以匹配的则停止,所以,通配范围大的url要往后放,
# 如"/user/delete" 和 "/user/**"
5.3.3 其他默认过滤器
5.5 总结
通过ShiroFilter和定义在shiro.ini中的配置信息,即可在项目接收用户访问时,进行身份,角色,权限进行访问控制啦!!!!
现在的项目架构 |
---|
![]() ![]() |
六、Spring集成
web项目的核心组件都在spring工厂中管理,利用IOC和AOP,组建了关系松散,稳健的系统。
shiro的诸多组件也需要由spring统一管理,进而可以更好的和其他组件协作。
之前的Realm中一直有如下代码:
//由于Realm还未进入spring工厂,所以无法直接注入工厂内部的DAO组件 UserService userService =(UserService)ContextLoader.getCurrentWebApplicationContext().getBean("xx");
ops:shiro的组件都是pojo组件,非常容易用spring管理,可以方便的从ini迁移到spring
6.1 pom
<!-- 其他依赖和web集成中 一致 ,此处省略-->
<!-- 新增一个依赖 用于在工厂中生产 ShiroFilter-->
<!-- 会传递导入shiro-core 和 shiro-web -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency>
6.2 aplicationContext.xml
将SecurityManager和Realm和ShiroFilter 都迁移到applicationContext.xml中
建议将如下配置,单独定义在一个配置文件:shiro-spring.xml,然后在applicationContext.xml中引入:
<import resource="classpath:shiro-spring.xml"/>
<!-- 连接池,SqlSessionFactory,MapperScannerConfigurer,事务控制等 配置不变 -->
<!-- 添加如下shiro配置 -->
<!-- shiro -->
<!-- 声明realm -->
<bean id="realm1" class="com.zhj.realm.MyRealm">
<property name="userService" ref="userService"/>
</bean>
<!-- 声明SecurityManager -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入Realm -->
<property name="realm" ref="realm1"/>
</bean>
<!-- 生产SpringShiroFilter
( 持有shiro的过滤相关规则,可进行请求的过滤校验,校验请求是否合法 )
-->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<property name="loginUrl" value="/user/login/page"/>
<property name="unauthorizedUrl" value="/error.jsp"/>
<property name="filterChainDefinitions">
<value>
/user/query=anon
/user/insert=authc,roles["banfu"]
/user/update=authc,perms["student:update"]
/order/insert=authc,roles["xuewei"]
/user/logout=logout
</value>
</property>
</bean>
6.3 web.xml
<!-- 会从spring工厂中获取和它同名的bean,(id="shiroFilter")
接到请求后调用bean的doFilter方法,进行访问控制。
-->
<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>
<!-- EnvironmentLoaderListener不再需要,因为shiro环境已由spring初始化
springMVC,spring配置不变 -->
七、记住我
在登录后,可以将用户名存在cookie中,下次访问时,可以先不登录,就可以识别身份。
在确实需要身份认证时,比如购买,支付或其他一些重要操作时,再要求用户登录即可,用户体验好。
由于可以保持用户信息,系统后台也可以更好的监控、记录用户行为,积累数据。
7.1 代码
”记住我“ 起点在登录时刻:Subject.login(UsernameAndPasswordToken)
而是否确定要“记住我”,由登录时的token控制开关:token.setRememberMe(true);
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
//如果需要记住我的话,需要在token中设置
token.setRememberMe(true);//shiro默认支持”记住我“,只要有此设置则自动运作。
subject.login(token);
7.2 效果
登录后效果
7.3 页面中显示
在页面中显示,cookie中记录的用户信息
<shiro:user> 当有记住我信息,或已登录,则显示标签体内容
<shiro:principal> 获取用户信息
注意:首页的访问路径的过滤器 不能是 authc,只能是 user 或 anon
<!-- 首页 xx.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<html>
<body>
<h2>Hello World! </h2>
<!-- 重点在此:通过如下shiro标签显示 -->
<shiro:user>
欢迎您,<shiro:principal/> <a href="#">退出登录</a>
</shiro:user>
</body>
</html>
<!-- 登录页面 login.jsp 自动填充用户名 -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="<c:url value="/user/login"/>" method="post">
<!-- 重点在此:<shiro:principal/> -->
username:<input type="text" name="username" value="<shiro:principal/>"> <br>
password:<input type="password" name="password"><br>
<input type="submit" value="登录">
</form>
</body>
</html>
7.4 自定义
如果需要做自定义,可以明确定义如下两个组件:
SimpleCookie
:封装cookie的相关属性,定制cookie写出逻辑(详见:addCookieHeader()
)
CookieRememberMeManager
:接受SecurityManager调度,获取用户信息,加密数据,并调度SimpleCookie写出cookie。
<!-- 之前的配置不变,添加如下配置 -->
<!-- remember me -->
<bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
<!-- rememberMe是cookie值中的key,value时用户名的密文
cookie["rememberMe":"deleteMe"] 此cookie每次登陆后都会写出,用于清除之前的cookie
cookie["rememberMe":username的密文] 此cookie也会在登录后写出,用于记录最新的username
(ops: 如上设计,既能保证每次登陆后重新记录cookie,也能保证切换账号时,记录最新账号)
-->
<property name="name" value="rememberMe"/>
<!-- cookie只在http请求中可用,那么通过js脚本将无法读取到cookie信息,有效防止cookie被窃取 -->
<property name="httpOnly" value="true"/>
<!-- cookie的生命周期,单位:秒 -->
<property name="maxAge" value="2592000"/><!-- 30天 -->
</bean>
<bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
<!-- 注入SimpleCookie -->
<property name="cookie" ref="rememberMeCookie"/>
</bean>
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
...
<!-- CookieRememberMeManager注入给SecurityManager,
SecurityManager在处理login时,如果login成功,则会通过rememberMeManager做"记住我",
将用户名存入cookie
-->
<property name="rememberMeManager" ref="rememberMeManager"/>
</bean>
八、shiro标签
shiro提供了很多标签,用于在jsp中做安全校验。
完成对页面元素的访问控制
8.1 导入shiro标签库
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags"%>
<html>
....
</html>
8.2 身份认证
**shiro:authenticated shiro:user shiro:guest ** **已登录 已登录或记住我 游客(未登录 且 未记住我) **
**shiro:notAuthenticated shiro:principal ** 未登录 获取用户身份信息
<shiro:authenticated>
欢迎您,<shiro:principal/>
</shiro:authenticated>
<shiro:user> <!-- 常用,包含已登录 且配合记住我,用户体验好 -->
欢迎您,<shiro:principal/>
</shiro:user>
<shiro:guest>
欢迎您,未登录,请<a href="<c:url value="/user/login/page"/>">登录</a>
</shiro:guest>
<shiro:notAuthenticated>
您尚未登录(记住我也算在未登录中)
</shiro:notAuthenticated>
8.3 角色校验
<shiro:hasAnyRoles name="admin,manager">
<shiro:hasRole name="admin">
是其中任何一种角色 是指定角色
<shiro:lacksRole name="admin">
不是指定角色
<table>
<tr>
<td>id</td>
<td>name</td>
<td>operation</td>
</tr>
<tr>
<td>001</td>
<td>张三</td>
<td>
<shiro:hasAnyRoles name="admin,manager">
<a href="#" style="text-decoration:none">详情</a>
</shiro:hasAnyRoles>
<shiro:hasRole name="admin">
<a href="#" style="text-decoration: none">删除</a>
</shiro:hasRole>
<shiro:lacksRole name="admin">
<a href="#" style="text-decoration: none">点击升级</a>
</shiro:lacksRole>
</td>
</tr>
</table>
8.4 权限校验
<shiro:hasPermission name="user:delete">
有指定权限
<shiro:lacksPermission name="user:delete">
缺失指定权限
...
<td>
<a href="#" style="text-decoration:none">查看详情</a>
<shiro:hasPermission name="user:delete">
<a href="#" style="text-decoration: none">删除</a>
</shiro:hasPermission>
<shiro:lacksPermission name="user:delete">
<a href="#" style="text-decoration: none" >无权删除</a>
</shiro:lacksPermission>
</td>
...
8.5 自定义标签(了解)
jsp中允许自定义标签,所以可以根据需求 自定义一些shiro标签。
8.5.1 定义标签类
public class MyAllRoleTag extends RoleTag {
// jsp中使用:<xxx:xx name="角色参数1,角色参数2,..."/>
private String name;//存储传入的角色参数
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
protected boolean showTagBody(String name) {
System.out.println("验证角色:"+name);
String[] roles = name.split(",");
Subject subject = getSubject();
for(String role:roles) {
if(!subject.hasRole(role)){
return false;
}
}
return true;
}
}
8.5.2 定义tld文件
要放在
WEB-INF
目录下,名称任意
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
<tlib-version>1.1.2</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>zhj</short-name>
<uri>http://zhj.apache.org/tags</uri>
<description>Apache Shiro JSP Tag Library.</description>
<tag>
<!-- 标签名 <zhj:hasAllRoles .../> -->
<name>hasAllRoles</name>
<!-- 自定义Tag类路径 -->
<tag-class>com.zhj.tag.MyAllRoleTag</tag-class>
<body-content>JSP</body-content>
<description>Displays body content only if the current Subject (user)
'has' (implies) all the specified roles
</description>
<!-- 自定义Tag中属性名:name
<zhj:hasAllRoles name="role1,role2"/>
-->
<attribute>
<name>name</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>
8.5.3 使用
<%@ taglib prefix="zhj" uri="http://zhj.apache.org/tags" %>
<!-- tld中定义的标签名:hasAllRoles, 向Tag类中传递参数:“seller,manager” -->
<zhj:hasAllRoles name="seller,manager">
有所有的角色2:manager,seller
</zhj:hasAllRoles>
九、Session管理
shiro作为一款安全管理框架,对状态保持有很强的需要。
比如最常用的用户认证,就必需状态的保持,以及其他的一些功能实现的需要。
【shiro需要:认证中的
记住我中的用户名
正式登陆的用户名
】【 开发者需要:其他功能中需要存入session的值 】
shiro提供了一整套session管理方案.
1. shiro的session方案和任何容器无关(如servlet容器);
2. javaSE也可以使用;相关组件都是pojo对ioc极其友好(方便的管理对象和满足依赖关系,定制参数)
3. 可以方便的扩展定制存储位置(内存,缓存,数据库等)
4. 对web透明支持:用了shiro的session后,项目中关于session的代码完全不用任何改动
5. 提供了全面的session监听机制,和session检测机制,对session可以细粒度操作
即,使用了shiro后,采用shiro的session方案是最优的方案。
9.1 配置
<!-- 会话Cookie模板 默认可省-->
<bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
<!-- cookie的 key="sid" -->
<property name="name" value="JSESSIONID"/>
<!-- 只允许http请求访问cookie -->
<property name="httpOnly" value="true"/>
<!-- cookie过期时间,-1:存活一个会话 ,单位:秒 ,默认为-1-->
<property name="maxAge" value="-1"/>
</bean>
<bean id="sessionManager"
class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
<property name="sessionDAO" ref="sessionDAO"/>
<!-- 默认为true,代表用cookie存储session的id -->
<property name="sessionIdCookieEnabled" value="true"/>
<!-- 默认值和配置中给出的一致,所bean:sessionIdCookie 可以省略 -->
<property name="sessionIdCookie" ref="sessionIdCookie"/>
<!-- session全局超时时间, 单位:毫秒 ,30分钟 默认值为1800000-->
<property name="globalSessionTimeout" value="1800000"/>
</bean>
<!-- 将sessionManager关联到SecurityManager -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
...
<!-- 增加配置sessionManager -->
<property name="sessionManager" ref="sessionManager"/>
</bean>
9.2 Session监听
session有三个核心过程:创建、过期、停止
过期:session的默认过期时间为30分钟。通过比对最近一次使用时间和当前使用时间判断
session不会自动报告过期,需检测器检测时,或再次访问时,才可以识别是否过期并移除。
停止:用户主动
logout
;主动调用session.stop()
; 两种情况会将session标志为停止状态。
// 定义监听类 exentends SessionListenerAdapter
public class MySessionListener extends SessionListenerAdapter{
//当有session创建时 触发
@Override
public void onStart(Session session) {
System.out.println("session:"+session.getId()+" start");
}
//当有session停止时 触发
@Override
public void onStop(Session session) {
System.out.println("session:"+session.getId()+" stop");
}
//当有session过期时 触发
// 但不会主动触发,需要再次访问时,即又要使用session时才会发现session过期,并触发。
@Override
public void onExpiration(Session session) {
System.out.println("session:"+session.getId()+" expired");
}
}
配置监听类,关联给SessionManager
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
...
<property name="sessionListeners">
<list>
<bean class="com.zhj.listener.MySessionListener"></bean>
</list>
</property>
...
</bean>
9.3 Session检测
用户如果没有主动退出登录,只是关闭浏览器,则session是否过期无法获知,也就不能停止session。
为此,shiro提供了session的检测机制,可以定时发起检测,识别session过期 并停止session。
<!-- sessionManager默认开启session检测机制 -->
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
...
<!-- 开启检测器,默认开启 -->
<property name="sessionValidationSchedulerEnabled" value="true"/>
<!--- 检测器运行间隔,单位:毫秒 默认1小时
//检测到过期后,会直接将session删除
protected void afterExpired(Session session) {
if (isDeleteInvalidSessions()) {
delete(session);
}
}
-->
<property name="sessionValidationInterval" value="3600000"/>
...
</bean>
如上,通过检测器,定时的检测session,并及时移除无效session,释放资源。
十、加密
用户的密码是不允许明文存储的,因为一旦数据泄露,用户的隐私信息会完全暴露。
密码必须结果加密,生成密文,然后数据库中只存储用户的密码的密文。
在加密过程中需要使用到一些"不可逆加密",如 md5,sha等
所谓不可逆是指:
- 加密函数A, 明文 “abc”, A("abc") = "密文",不能通过 "密文" 反推出 "abc",即使密文泄露密码仍然安全。
10.1 加密介绍
shiro支持hash(散列)加密,常见的如 md5, sha等
基本加密过程
md5(明文),sha(明文) 得到明文的密文,但明文可能比较简单导致密文容易被破解。
加盐加密过程
系统生成一个随机salt="xxxxxx", md5(明文+salt) ,sha(明文+salt),则提升了密文的复杂度。
加盐多次迭代加密过程
如果迭代次数为2,则加密2次: md5(明文+salt)=密文a , md5(密文a+salt)=最终密文
sha(明文+salt)=密文a , sha(密文a+salt)=最终密文
则进一步提升了密文的复杂度,和被破解的难度。
加密过程中建议使用salt,并指定迭代次数,迭代次数的建议值1000+
实例代码:
String password="abc";//密码明文
String salt=UUID.randomUUID().toString();//盐
Integer iter = 1000;//迭代次数
String pwd = new Md5Hash(password, salt,iter).toString(); //md5加密
String pwd = new Md5Hash(password, salt, iter).toBase64(); //加密后转base64
String pwd = new Sha256Hash(password, salt, iter).toString();//sha256加密
String pwd = new Sha256Hash(password, salt, iter).toBase64();//加密后转base64
String pwd = new Sha512Hash(password, salt, iter).toString();//sha256加密
String pwd = new Sha512Hash(password, salt, iter).toBase64()//加密后转base64
10.2 加密
增加用户,或修改用户密码时,涉及到密码的加密
在注册用户的业务中,对用户提交的密码加密即可。
注意:之前的用户表,并未考虑存储加密相关信息,所以此时需要对用户表做出改进,
加一列【 salt varchar(50) 】,用于存储每个用户的盐。
class UserServiceImpl implements UserService{
@Autowired
private UserDAO userDAO;
public void createUser(User user){
user.setSalt(UUID.randomUUID().toString());//设置随机盐
//设置加密属性:sha256算法,随机盐,迭代1000次
Sha256Hash sha256Hash = new Sha256Hash(user.getPassword(),user.getSalt(),1000);
//将用户信息 (包括密码的密文 和 盐) 存入数据库
user.setPassword(sha256Hash.toBase64());//密文采用base64格式化
userDAO.createUser(user);
}
}
10.3 密码比对
登录认证身份时,涉及到密码 比对 过程
注意,加密过程中使用的加密属性,和此处使用的加密属性 必须一致:
【sha256,迭代1000次,使用base64格式化密文】
10.3.1 指定比对器
<!-- 声明realm -->
<bean id="realm1" class="com.zhj.realm.MyRealm">
<property name="userService" ref="userService"/>
<!-- 此属性如果通过注解注入,则需要将注解加载set方法上,不能用在属性上。
此属性是父类属性,所以只有在set方法上注入,才能覆盖父类属性值。
-->
<property name="credentialsMatcher">
<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<property name="hashAlgorithmName" value="SHA-256"/>
<!-- true means hex encoded, false means base64 encoded -->
<property name="storedCredentialsHexEncoded" value="false"/>
<property name="hashIterations" value="1000"/>
</bean>
</property>
</bean>
10.3.2 修改Realm
doGetAuthenticationInfo方法的返回值中需要添加salt:
ByteSource.Util.bytes(user.getSalt())
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
String username = (String) token.getPrincipal();
UserService userService =
(UserService)ContextLoader.getCurrentWebApplicationContext().getBean("userService");
User user = userService.queryUser(username);
System.out.println("user:"+user);
if(user==null){
System.out.println("用户不存在");
throw new UnknownAccountException("username:"+username+"不存在");
}
//以上逻辑不变
//在最后返回用户认证info时,添加一个属性:ByteSource.Util.bytes(user.getSalt()) = 盐
//用于密码比对
return new SimpleAuthenticationInfo(user.getUsername(),
user.getPassword(),
ByteSource.Util.bytes(user.getSalt()),
getName());
}
至此,可以进行注册,注册中已经会加密密码。
然后登陆认证身份,认证时realm会调用比对器比对密文。