1、Shiro概述
1.1、Shiro简介
Apache Shiro是Java的一个安全(权限)框架。
Shiro可以非常容易的开发出足够好的应用,不仅可以用在JavaSE环境,也可以用在JavaEE环境。
Shiro可以完成:认证、授权、加密、会话管理、与Web集成、缓存等。
1.2、Shiro的下载
在官网上进行下载：http://shiro.apache.org/
选择Download跳转到下载界面：
选择版本，（当前稳定版本，源代码分发，单击进入）
之后可以在单击zip进行直接下载
或者使用Git项目管理工具进行克隆源代码：Git项目管理工具专栏，供参考（博客）
1.3、hello world
在编写代码的时候需要用到对应的jar包，下载地址（世界大学城） 或者 CSDN下载
把jar包带入到项目当中：
随后打开刚下载的Shiro的源文件，进行解压缩，打开目录：shiro-root-1.5.3\samples\quickstart\src\main\resources在这个路径下you俩个文件，把文件添加到项目src文件夹下。回退一格，打开java目录，右下图这个文件，在src下新建一个包，复制到这个包下面。
直接运行这个java文件，查看输出。
下面就是代码的部分解释：获取subject对象和session对象，
以及读取shiro.ini文件对用户的账号密码进行检验：
打开shiro.ini文件（使用Text Editor打开），可以查看最开始的账号与密码：
测试用户是否拥有这个角色，以及权限。这些都可以在shiro.ini文件当中进行查看。
到最后退出登录，查看当前的状态：运行项目
在Github当中看获取对应的源码：https://github.com/lizuoqun/Gitlzq.git
2、Shiro 与 Spring 框架的集成
Shiro 提供了与 Web 集成的支持，其通过一个ShiroFilter 入口来拦截需要安全控制的URL，然后进行相应的控制
ShiroFilter 类似于如 Strut2 / SpringMVC 这种 web 框架的前端控制器，是安全控制的入口点，其负责读取配置（如ini 配置文件），然后判断URL 是否需要登录/权限等工作。
2.1、对部分访问请求进行拦截
第一步：当然是搭建起来一个Spring的程序了。导入相对应的jar包，搭建起一个Spring web程序，添加上一个user.jsp文件，使得可以正常对这个jsp页面进行访问。第一个Spring MVC 程序，当中的Java代码可以不进行编写，直接运行jsp文件查看是否成功即可。
第二步：要使用Shiro和Spring进行集成，当然还要导入Shiro所需要的jar包
第三步：对web.xml文件进行配置。配置 Shiro的shiroFilter.也可以理解为拦截器：Spring MVC拦截器可以参考这篇博文，添加代码段如下所示：
<filter>
<filter-name>shiroFilter</filter-name>
<!--DelegatingFilterProxy是filter的代理-->
<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>
第四步：需要对applicationContext.xml文件进行配置：配置对应的核心组件
- 配置 SecurityManager
<bean id="securityManager"
class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="cacheManager" ref="cacheManager" />
<property name="authenticator" ref="authenticator"></property>
<property name="rememberMeManager.cookie.maxAge" value="10"></property>
</bean>
- 配置 CacheManager. 需要加入 ehcache 的 jar 包及配置文件.
<bean id="cacheManager"
class="org.apache.shiro.cache.ehcache.EhCacheManager">
<property name="cacheManagerConfigFile"
value="classpath:ehcache.xml" />
</bean>
<bean id="authenticator"
class="org.apache.shiro.authc.pam.ModularRealmAuthenticator">
<property name="authenticationStrategy">
<bean
class="org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy"></bean>
</property>
</bean>
在进行CacheManager配置的时候需要添加对应的一个xml文件，ehcache.xml 可在该链接进行获取。把这个文件添加到src目录下，
- 新建一个 com.lzq.shiro.realms包，在包下新建一个ShiroReamls类，该类实现Realm接口。并且在xml文件当中进行添加。
<bean id="jdbcRealm" class="com.lzq.shiro.realms.ShiroReamls"></bean>
- 配置生命周期管理器 ：可以自定的来调用配置在 Spring IOC 容器中 shiro bean 的生命周期方法.。
<bean id="lifecycleBeanPostProcessor"
class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
- 启用 IOC 容器中使用 shiro 的注解. 但必须在配置了 LifecycleBeanPostProcessor之后才可以使用.。
<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>
- 配置 ShiroFilter. id 必须和 web.xml 文件中配置的 DelegatingFilterProxy的 一致.若不一致, 则会抛出: NoSuchBeanDefinitionException. 因为 Shiro 会来 IOC 容器中查找和 名字对应的 filter bean.
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<property name="loginUrl" value="/login.jsp"/>
<property name="successUrl" value="/list.jsp"/>
<property name="unauthorizedUrl" value="/unauthorized.jsp"/>
<!-- 配置哪些页面需要受保护. 以及访问这些页面需要的权限.
anon 可以被匿名访问
roles 角色过滤器 -->
<property name="filterChainDefinitions">
<value>
/login.jsp = anon
#/** = authc
/user.jsp=authc
</value>
</property>
</bean>
在这里是对不同的jsp页面佐不同的处理，在WEB-INF目录下面新建对应的jsp文件，login.jsp、list.jsp 和 unauthorized.jsp 然后运行项目。运行项目之后，对访问做了一定的处理，当我们访问user.jsp文件时是没有权限进行访问的，而是会跳转到login.jsp页面的。
当然了，在运行的时候会看到有warning抛出，是因为没有添加log4j.properties文件，把文件进行添加上去即可。
到这里，当然如果你会git项目管理工具，可以直接在github当中获取上述代码，地址：https://github.com/lizuoqun/Gitlzq.git ShiroWeb文件夹。（原先在学Git的时候还有一个测试Git代码，也就不做删除了。）
2.2、URL匹配
2.2.1、URL的配置
拦截器 [urls] 部分的配置，其格式是： “url=拦截器[参数]，拦截器[参数]”；
如果当前请求的 url 匹配 [urls] 部分的某个 url 模式，将会执行其配置的拦截器
- anon（anonymous） 拦截器表示匿名访问（即不需要登录即可访问）
- authc （authentication）拦截器表示需要身份认证通过后才能访问
2.2.2、URL的匹配模式
Ant 路径通配符支持 ?、*、**，注意通配符匹配不包括目录分隔符“/”：
– ?：匹配一个字符，如 /admin? 将匹配 /admin1，但不匹配 /admin 或 /admin/；
– *：匹配零个或多个字符串，如 /admin 将匹配 /admin、/admin123，但不匹配 /admin/1；
– ** ：匹配路径中的零个或多个路径，如 /admin/** 将匹配 /admin/a 或 /admin/a/b
2.2.3、URL 匹配顺序
URL 权限采取第一次匹配优先的方式，即从头开始，使用第一个匹配的 url 模式对应的拦截器链
3、身份验证及盐值加密
3.1、身份验证
一般需要提供如身份 ID 等一些标识信息来表明登录者的身份，如提供 email，用户名/密码来证明。
- 在 shiro 中，用户需要提供 principals （身份）和 credentials（证明）给shiro，从而应用能验证用户身份：
- principals：身份，即主体的标识属性，可以是任何属性，如用户名、邮箱等，唯一即可。一个主体可以有多个 principals，但只有一个Primary principals，一般是用户名/邮箱/手机号。
- credentials：证明/凭证，即只有主体知道的安全值，如密码/数字证书等。
- 最常见的 principals 和 credentials 组合就是用户名/密码了
3.2、身份验证基本流程
- 收集用户身份/凭证，即如用户名/密码
- 调用 Subject.login 进行登录，如果失败将得到相应的 AuthenticationException 异常，根据异常提示用户错误信息；否则登录成功
- 创建自定义的 Realm 类，继承org.apache.shiro.realm.AuthorizingRealm 类，实现doGetAuthenticationInfo() 方法
3.3、代码实现的步骤
- 首先调用 Subject.login(token) 进行登录，其会自动委托给SecurityManager
- SecurityManager 负责真正的身份验证逻辑；它会委托给Authenticator 进行身份验证；
- Authenticator 才是真正的身份验证者，Shiro API 中核心的身份认证入口点，此处可以自定义插入自己的实现；
- Authenticator 可能会委托给相应的 AuthenticationStrategy 进 行多 Realm 身份验证，默认 ModularRealmAuthenticator 会调用AuthenticationStrategy 进行多 Realm 身份验证；
- Authenticator 会把相应的 token 传入 Realm，从 Realm 获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。
3.4、案例实现
要实现登录认证的话，第一步还是需要配置一个表单页面进行账号密码的提交：
<form action="Shiro/Login" method="POST">
username : <input type="text" name="username" /> <br> password :
<input type="password" name="password" /> <br> <input
type="submit" value="登录" />
</form>
新建一个控制器类，用于验证登录：
package com.lzq.shiro.handles;
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;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
@RequestMapping("/Shiro")
public class ShiroHandler {
@RequestMapping("/Login")
public String login(@RequestParam("username") String username,
@RequestParam("password") String password) {
Subject currentUser = SecurityUtils.getSubject();
if (!currentUser.isAuthenticated()) {
// 把用户名和密码进行封装成一个对象
UsernamePasswordToken token = new UsernamePasswordToken(username,password);
token.setRememberMe(true);
try {
// 执行登录
System.out.println("1 = " + token.hashCode());
//从这里传递过去的值给到 ShiroReamls 类当中重写的 doGetAuthenticationInfo 方法
currentUser.login(token);
}
catch (AuthenticationException ae) {
System.out.println("登录失败 = "+ae.getMessage());
}
}
return "redirect:/list.jsp";
}
}
以及ShiroReamls类继承父类AuthenticatingRealm重写方法：
public class ShiroReamls extends AuthenticatingRealm {
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
System.out.println("doGetAuthenticationInfo = "+token.hashCode());
return null;
}
}
之后我们对这个方法进行编写：在这里也就是把用户名设置为admin与user，密码为123456，以及使用unknow与master进行登录会抛出不同的异常进行模拟：
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
System.out.println("doGetAuthenticationInfo = " + token.hashCode());
System.out.println("token2 = " + token);
// 把 AuthenticationToken 转换为 UsernamePasswordToken 类型
UsernamePasswordToken UpToken = (UsernamePasswordToken) token;
// 从UsernamePasswordToken当中获取username
String username = UpToken.getUsername();
System.out.println("getUserName = " + username);
// 根据username查询password
System.out.println("在数据库当中查询 . . .");
// 不存在，抛出异常
if ("unknow".equals(username)) {
throw new UnknownAccountException("用户不存在");
}
// 判断是否需要抛出其他异常 AuthenticationException
if ("monter".equals(username)) {
throw new LockedAccountException("用户被锁定");
}
// 根据用户情况来构建AuthenticationInfo对象
// principal : 认证的实体信息。可以是 username,也可以是数据表对应的用户的实体类对象。
Object principal = username;
// credentials : 密码
Object credentials = "123456";
// realmName : 当前Realm对象的name，调用父类的getName方法
String realmName = getName();
//盐值加密,用用户名作为底层加密使用的字符
ByteSource credentialsSalt = ByteSource.Util.bytes(username);
//以及对用户名进行加密，作为限定
if ("admin".equals(username)) {
credentials = "038bdaf98f2037b31f1e75b5b4c9b26e"; // YWRtaW4= admin YQ==a
} else if ("user".equals(username)) {
credentials = "098d2c478e9c11555ce2823231e02ec1";
}
System.out.println("credentialsSalt = " + credentialsSalt);
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(principal, credentials, credentialsSalt,
realmName);
System.out.println(info);
return info;
}
密码进行储存的时候直接进行储存很显然是不够安全的，这个时候就需要使用到加密技术。需要在application,xml文件当中对加密进行定义：
<bean id="jdbcRealm" class="com.lzq.shiro.realms.ShiroRealm">
<!-- 使用MD5进行密码加密 -->
<property name="credentialsMatcher">
<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<property name="hashAlgorithmName" value="MD5"></property>
<property name="hashIterations" value="1024"></property>
</bean>
</property>
</bean>
直接在上述的这个ShiroReamls类进行密码加密：使用以下代码实现：
public static void main(String[] args) {
String hashAlgorithName = "MD5";
Object credentials = "123456";
Object sale = null;
int hashIterations = 1024;
Object res = new SimpleHash(hashAlgorithName, credentials, sale, hashIterations);
System.out.println("密码加密：res =" + res);
}
运行代码查看输出的加密的密码：
对于不同的数据库使用的密码加密的方式也是不一样的：使用SHA1方式进行加密：
这个时候我们可以配置第二个Realm进行测试：现在appicationContext.xml文件当中定义对应的Realm。以及添加到SecurityManager当中：
<!-- 1. 配置 SecurityManager! -->
<bean id="securityManager"
class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="cacheManager" ref="cacheManager" />
<property name="authenticator" ref="authenticator"/>
<property name="realms">
<list>
<ref bean="jdbcRealm"/>
<ref bean="secondRealm"></ref>
</list>
</property>
<property name="rememberMeManager.cookie.maxAge" value="10"></property>
</bean>
<!-- 配置 Realm 直接配置实现了 org.apache.shiro.realm.Realm接口的 bean -->
<bean id="jdbcRealm" class="com.lzq.shiro.realms.ShiroRealm">
<!-- 使用MD5进行密码加密 -->
<property name="credentialsMatcher">
<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<property name="hashAlgorithmName" value="MD5"></property>
<property name="hashIterations" value="1024"></property>
</bean>
</property>
</bean>
<bean id="secondRealm" class="com.lzq.shiro.realms.SecondRealm">
<!-- 使用SHA1进行密码加密 -->
<property name="credentialsMatcher">
<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<property name="hashAlgorithmName" value="SHA1"></property>
<property name="hashIterations" value="1024"></property>
</bean>
</property>
</bean>
相对应的创建一个SecondRealm类与ShiroRealm类当中代码相同，修改admin和user对应的加密值即可：
登录成功之后会跳转到list界面，这个时候就可以访问其他的界面了，以及在list界面有一个登出的选项，防止后续登录使用的是Session值，效果如下图所示：先直接访问user是访问不了的，随后当用户名与密码不正确的时候是登录不成功的（这里不论是否登录成功都会跳转到list），到最后登录成功之后就可以对user进行访问了。
3.5、身份认证策略 AuthenticationStrategy接口实现
- FirstSuccessfulStrategy：只要有一个 Realm 验证成功即可，只返回第一个 Realm 身份验证成功的认证信息，其他的忽略；
- AtLeastOneSuccessfulStrategy：只要有一个Realm验证成功即可，和FirstSuccessfulStrategy 不同，将返回所有Realm身份验证成功的认证信息；
- AllSuccessfulStrategy：所有Realm验证成功才算成功，且返回所有Realm身份验证成功的认证信息，如果有一个失败就失败了。
- ModularRealmAuthenticator 默认是 AtLeastOneSuccessfulStrategy策略
4、授权管理
4.1、授权是什么
授权，也叫访问控制，即在应用中控制谁访问哪些资源（如访问页面/编辑数据/页面操作 等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限（Permission）、角色（Role）。
- 主体(Subject)：访问应用的用户，在 Shiro 中使用 Subject 代表该用户。用户只有授权后才允许访问相应的资源。
- 资源(Resource)：在应用中用户可以访问的 URL，比如访问 JSP 页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问。
- 权限(Permission)：安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如：访问用户列表页面查看/新增/修改/删除用户数据（即很多时候都是CRUD（增查改删）式权限控制）等。权限代表了用户有没有操作某个资源的权利，即反映在某个资源上的操作允不允许。
- Shiro 支持粗粒度权限（如用户模块的所有权限）和细粒度权限（操作某个用户的权限，即实例级别的）
- 角色(Role)：权限的集合，一般情况下会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。不同的角色拥有一组不同的权限。
4.2、授权的方式
- 编程式：通过写if/else 授权代码块完成
- 注解式：通过在执行的Java方法上放置相应的注解完成，没有权限将抛出相应的异常
- JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成
4.3、代码案例实现
在前文的基础上进行授权管理，在配置文件当中对俩个界面进行不同的权限给予。表示当只有使用这个角色才能对页面进行访问。
权限添加之后添加这俩个页面，在登录之后的list.jsp当中使用a标签进行指向。
以及在ShiroRealm 类当中进行继承 AuthorizingRealm 类，重写doGetAuthorizationInfo方法：对权限进行分析：
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("没有权限,进行授权。");
//从PrincipalCollection获取信息
Object principal=principals.getPrimaryPrincipal();
//用信息获取权限
Set<String> roles= new HashSet<String>();
roles.add("user");
if ("admin".equals(principal)) {
roles.add("admin");
}
//创建SimpleAuthorizationInfo接口并设置对应的Reles属性
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roles);
//返回对象
return info;
}
配置完成之后就可以运行查看效果了，当使用admin进行登录的时候admin.jsp和user.jsp都能访问，而使用user进行登录，只能访问user.jsp页面。
4.4、授权流程
- 首先调用 Subject.isPermitted*/hasRole* 接口，其会委托给SecurityManager，而 SecurityManager 接着会委托给 Authorizer；
- Authorizer是真正的授权者，如果调用如isPermitted(“user:view”)，其首先会通过 PermissionResolver 把字符串转换成相应的 Permission 实例；
- 在进行授权之前，其会调用相应的 Realm 获取 Subject 相应的角色/权限用于匹配传入的角色/权限；
- Authorizer 会判断 Realm 的角色/权限是否和传入的匹配，如果有多个Realm，会委托给 ModularRealmAuthorizer 进行循环判断，如果匹配如 isPermitted*/hasRole* 会返回true，否则返回false表示授权失败。
4.5、Shiro 标签
Shiro 提供了 JSTL 标签用于在 JSP 页面进行权限控制，如根据登录用户显示相应的页面按钮。
- guest 标签：用户没有身份验证时显示相应信息，即游客访问信息。
- user 标签：用户已经经过认证/记住我登录后显示相应的信息。
- authenticated 标签：用户已经身份验证通过，即Subject.login登录成功，不是记住我登录的。
- notAuthenticated 标签：用户未进行身份验证，即没有调用Subject.login进行登录，包括记住我自动登录的也属于未进行身份验证。
- pincipal 标签：显示用户身份信息，默认调用Subject.getPrincipal() 获取，即 Primary Principal。
- hasRole 标签：如果当前 Subject 有角色将显示 body 体内容。
- hasAnyRoles 标签：如果当前Subject有任意一个角色（或的关系）将显示body体内容。
- lacksRole：如果当前 Subject 没有角色将显示 body 体内容。
- hasPermission：如果当前 Subject 有权限将显示 body 体内容。
10.lacksPermission：如果当前Subject没有权限将显示body体内容。
4.6、Shiro 标签的使用
第一步导入shiro包：
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags"%>
第二步使用：如下图所示
4.7、权限注解
- @RequiresAuthentication：表示当前Subject已经通过login 进行了身份验证；即 Subject. isAuthenticated() 返回 true
- @RequiresUser：表示当前 Subject 已经身份验证或者通过记住我登录的。
- @RequiresGuest：表示当前Subject没有身份验证或通过记住我登录过，即是游客身份。
- @RequiresRoles(value={“admin”, “user”}, logical= Logical.AND)：表示当前 Subject 需要角色 admin 和user
- @RequiresPermissions (value={“user:a”, “user:b”}, logical= Logical.OR)：表示当前 Subject 需要权限 user:a 或user:b。
4.8、页面权限再配置
以及可以对页面的权限可以进行封装，如下代码进行封装：
全部注释，使用一个新的属性进行封装；
<property name="filterChainDefinitionMap" ref="filterChainDefinitionMap"></property>
需要定义一个bean指向那个Map
<!-- 配置一个bean 指向map -->
<bean id="filterChainDefinitionMap"
factory-bean="filterChainDefinitionMapBuilder"
factory-method="buildFilterChainDefinitionMap"></bean>
<bean id="filterChainDefinitionMapBuilder"
class="com.lzq.shiro.factory.FilterChainDefinitionMapBuilder">
</bean>
定义一个bean就需要添加对应的类，com.lzq.shiro.factory.FilterChainDefinitionMapBuilder 包+类
package com.lzq.shiro.factory;
import java.util.LinkedHashMap;
public class FilterChainDefinitionMapBuilder {
public LinkedHashMap<String, String> buildFilterChainDefinitionMap(){
LinkedHashMap<String, String> map = new LinkedHashMap<>();
map.put("/login.jsp", "anon");
map.put("/Shiro/Login", "anon");
map.put("/Shiro/Logout", "logout");
map.put("/user.jsp", "authc,roles[user]");
map.put("/admin.jsp", "authc,roles[admin]");
map.put("/list.jsp", "user");
map.put("/**", "authc");
return map;
}
}
5、会话管理
5.1、会话管理概述
Shiro 提供了完整的企业级会话管理功能，不依赖于底层容器（如web容器tomcat），不管 JavaSE 还是 JavaEE 环境都可以使用，提供了会话管理、会话事件监听、会话存储/持久化、容器无关的集群、失效/过期支持、对Web 的透明支持、SSO 单点登录的支持等特性
5.2、会话的API
- Subject.getSession()：即可获取会话；其等价于Subject.getSession(true)，即如果当前没有创建 Session 对象会创建一个；Subject.getSession(false)，如果当前没有创建 Session 则返回null
- session.getId()：获取当前会话的唯一标识
- session.getHost()：获取当前Subject的主机地址
- session.getTimeout() & session.setTimeout(毫秒)：获取/设置当前Session的过期时间
- session.getStartTimestamp() & session.getLastAccessTime()：获取会话的启动时间及最后访问时间；如果是 JavaSE 应用需要自己定期调用 session.touch() 去更新最后访问时间；如果是 Web 应用，每次进入 ShiroFilter 都会自动调用 session.touch() 来更新最后访问时间。
- session.touch() & session.stop()：更新会话最后访问时间及销毁会话；当Subject.logout()时会自动调用 stop 方法来销毁会话。如果在web中，调用 HttpSession. invalidate() 也会自动调用Shiro Session.stop 方法进行销毁Shiro 的会 话
- session.setAttribute(key, val) & session.getAttribute(key) & session.removeAttribute(key)：设置/获取/删除会话属性；在整个会话范围内都可以对这些属性进行操作
5.3、Session的简单测试
在前面的代码当中进行添加：先绑定一个Session对象，
随后在跳转过去的页面获取这个Session值进行打印输出
运行项目进行访问对应页面，可以看到有这个Session值输出。
5.4、SessionDao
- AbstractSessionDAO 提供了 SessionDAO 的基础实现，如生成会话ID等 • CachingSessionDAO提供了对开发者透明的会话缓存的功能，需要设置相应的 CacheManager
- MemorySessionDAO 直接在内存中进行会话维护
- EnterpriseCacheSessionDAO 提供了缓存功能的会话维护，默认情况下使用 MapCache 实现，内部使用ConcurrentHashMap 保存缓存的会话。
5.5、会话验证
- Shiro 提供了会话验证调度器，用于定期的验证会话是否已过期，如果过期将停止会话
- 出于性能考虑，一般情况下都是获取会话时来验证会话是否过期并停止会话的；但是如在 web 环境中，如果用户不主动退出是不知道会话是否过期的，因此需要定期的检测会话是否过期，Shiro 提供了会话验证调度器SessionValidationScheduler
- Shiro 也提供了使用Quartz会话验证调度器：QuartzSessionValidationScheduler
6、Shiro缓存与RememberMe
6.1、CacheManagerAware 接口
Shiro 内部相应的组件（DefaultSecurityManager）会自动检测相应的对象（如Realm）是否实现了CacheManagerAware 并自动注入相应的CacheManager。
6.2、Realm 缓存
- Shiro 提供了 CachingRealm，其实现了CacheManagerAware 接口，提供了缓存的一些基础实现；
- AuthenticatingRealm 及 AuthorizingRealm 也分别提供了对AuthenticationInfo 和 AuthorizationInfo 信息的缓存
6.3、Session 缓存
- 如 SecurityManager 实现了 SessionSecurityManager， 其会判断 SessionManager 是否实现了
CacheManagerAware 接口，如果实现了会把CacheManager 设置给它。 - SessionManager 也会判断相应的 SessionDAO（如继承自CachingSessionDAO）是否实现了CacheManagerAware，如果实现了会把 CacheManager设置给它
- 设置了缓存的 SessionManager，查询时会先查缓存，如果找不到才查数据库。
6.4、RememberMe
Shiro 提供了记住我（RememberMe）的功能，比如访问如淘宝等一些网站时，关闭了浏览器，下次再打开时还是能记住你是谁，下次访问时无需再登录即可访问，基本流程如下：
- 首先在登录页面选中 RememberMe 然后登录成功；如果是浏览器登录，一般会把 RememberMe 的Cookie 写到客户端并保存下来；
- 关闭浏览器再重新打开；会发现浏览器还是记住你的；
- 访问一般的网页服务器端还是知道你是谁，且能正常访问；
- 但是比如我们访问淘宝时，如果要查看我的订单或进行支付时，此时还是需要再进行身份认证的，以确保当前用户还是你。
6.5、认证和记住我的区别
- subject.isAuthenticated() 表示用户进行了身份验证登录的，即使有 Subject.login 进行了登录；
- subject.isRemembered()：表示用户是通过记住我登录的，此时可能并不是真正的你（如你的朋友使用你的电脑，或者你的cookie 被窃取）在访问的
- 两者二选一，即 subject.isAuthenticated()==true，则subject.isRemembered()==false；反之一样。
6.6、使用上的区别与建议
- 访问一般网页：如个人在主页之类的，我们使用user 拦截器即可，user 拦截器只要用户登录(isRemembered() || isAuthenticated())过即可访问成功；
- 访问特殊网页：如我的订单，提交订单页面，我们使用authc 拦截器即可，authc 拦截器会判断用户是否是通过Subject.login（isAuthenticated()==true）登录的，如果是才放行，否则会跳转到登录页面叫你重新登录。
6.7、案例实现
如果要自己做RememeberMe，需要在登录之前这样创建Token：UsernamePasswordToken(用户名，密码，是否记住我)，且调用UsernamePasswordToken 的：token.setRememberMe(true); 方法
- 在Handler当中直接设置使用Rememberme为true，或者在前端页面当中使用一个复选框，将值传递过来。
- 使用RememberMe之后需要在配置文件当中添加时长的控制l：如下所示，为10秒钟
- 运行项目：在第一次登录之后关闭页面，在10秒之内再一次访问这个list界面是不再需要进行登录认证的，而10秒钟之后，缓存失效，再进行访问则需要进行再登录。
扫一扫
142
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
