安全框架Shiro
1,什么是RBAC
Role-Based Access Control 基于角色的访问控制
Resource-Based Access Control 基于资源的访问控制
2,什么是安全框架?
给项目添加认证与授权功能的框架, 就叫安全框架
认证: 验证用户身份的合法性(验证用户名和密码是否正确)
授权: 授权用户访问资源的权限
3, 都有哪些安全框架
Spring Security
Shiro
sa-token
4,Shiro的4大核心
认证(Authentication), 就相当于验证账号和密码是否正确. 就是判断你的身份是否合法.
授权(Authorization), 就是授予你访问资源的权利
session会话管理,
加密(Cryptography), 一般就是给密码加密
5,springboot2里添加shiro
maven的中央仓库: https://mvnrepository.com/
<!-- shiro依赖包 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring-boot-web-starter</artifactId>
<version>1.9.1</version>
</dependency>
6, 加密
shiro自带6种加密方式分别是
MD2, MD5, SHA-1, SHA-256, SHA-384, SHA-512
我们选择SHA-256进行一次加密,试试
RandomNumberGenerator random = new SecureRandomNumberGenerator();
String salt = random.nextBytes().toHex();
System.out.println("salt = " + salt);
//SimpleHash构造函数的参数说明(加密方式, 原密码, 盐, 哈希迭代数)
String pass = new SimpleHash("SHA-256", "zhaogang", salt, 1).toHex();
System.out.println("pass = " + pass);
打印结果
salt = 17228b8287f254609b0e00471ddaee37
pass = 81bffda6895fa3eb78523412fb6ad659b62cd0a4bc4f990b6edcb7e386704842
我们把数据库里的密码和盐进行修改
7,创建自定义Realm
Realm(域): 用来编写认证与授权代码的一个地方
public class MyRealm extends AuthorizingRealm {
/**
* 授权
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
return null;
}
/**
* 认证
* @param token
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
return null;
}
}
Authentication: 认证 [ɔːˌθentɪˈkeɪʃn]
Authorization: 授权 [ˌɔːθərəˈzeɪʃn]
8,创建shiro配置类, 将自义定Realm放入ioc容器
@Configuration
public class ShiroConfig {
@Bean("authorizer")
public MyRealm myRealm(){
MyRealm realm = new MyRealm();
//添加一个凭证匹配器,设置了加密方式为SHA-256, 哈希迭代数为1, 存储格式为Hex16进制
realm.setCredentialsMatcher(new HashedCredentialsMatcher("SHA-256"));
return realm;
}
}
9, 启动项目后,请求改变为/login.jsp
启动项目后,shiro要进行认证, 结果发现未认证, shiro会重定向到未认证的请求/login.jsp
为什么未认证
因为自定义Realm里负责认证的代码还是空的呢, 啥也没写, 如下
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
return null;
}
10, 认证
下面是shiro认证过程的流程思想图
修改登录代码为如下写法
@RequestMapping("/login")
@ResponseBody
public Result login(String username, String password, HttpServletRequest request){
//获取当前用户
Subject subject = SecurityUtils.getSubject();
//创建账号和密码的令牌
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
//登录
try {
subject.login(token);
//查询用户信息
SysUser user = sysUserService.getUserByUsername(username);
//把用户信息存储到session里
request.getSession().setAttribute("user", user);
//修改登录次数和最后登录时间
sysUserService.updateLoginCount(user.getUid());
} catch (UnknownAccountException e) {
return Result.error("账号错误");
} catch (IncorrectCredentialsException e) {
return Result.error("密码错误");
} catch (AuthenticationException e) {
e.printStackTrace();
return Result.error("认证错误");
}
return Result.success();
}
自定义Realm里认证的代码编写如下
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
UsernamePasswordToken token1 = (UsernamePasswordToken)token;
//账号
String username = token1.getUsername();
//判断账号是否正确
SysUser user = sysUserMapper.getUserByUsername(username);
if (user == null) {
throw new UnknownAccountException();
}
//返回认证对象, 将判断密码是否正确的工作交给shiro里的凭证匹配器来完成
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
username,
user.getPwd(),
ByteSource.Util.bytes(user.getSalt()),
getName()
);
return info;
}
shiro给我们提供了一些异常, 供我们所使用
11, 退出
@RequestMapping("/logout")
@ResponseBody
public Result logout(HttpServletRequest request){
//shiro里的退出
Subject subject = SecurityUtils.getSubject();
if (subject.isAuthenticated()) {
subject.logout();
}
return Result.success();
}
12, 拦截器
给shiro设置拦截器
@Bean
public ShiroFilterChainDefinition shiroFilterChainDefinition(){
DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
//anon 不拦截
definition.addPathDefinition("/", "anon");
definition.addPathDefinition("/login", "anon");
definition.addPathDefinition("/logout", "anon");
//登录成功后跳转的页面
definition.addPathDefinition("/login-success", "anon");
definition.addPathDefinition("/static/**", "anon");
//网页上面的图标
definition.addPathDefinition("/favicon.ico", "anon");
definition.addPathDefinition("/error", "anon");
//其他请求都必须认证才能通过 authc 表示必须认证才行
definition.addPathDefinition("/**", "authc");
return definition;
}
13, 未认证
shiro的认证不能通过后, shiro会进行一个重定向的请求 /login.jsp
我们有两种方法来处理这个请求
在application.properties里设置shiro的未认证请求路径
# 默认, 可以修改
shiro.loginUrl=/login.jsp
在WebMvcConfig类中设置页面的跳转
@Override
public void addViewControllers(ViewControllerRegistry registry) {
//未认证的请求
registry.addViewController("/login.jsp").setViewName("noauthe");
}
也可以不要设计一个错误的提示页面, 未认证就调转到登录页即可
# 也可以直接设置为跳转到登录页
shiro.loginUrl=/
14, 认证的完整代码
(1), shiro配置类
@Configuration
public class ShiroConfig {
/**
* 自定义Realm, 用来编写认证与授权代码的地方.
*/
@Bean
public Realm realm(){
MyRealm realm = new MyRealm();
//添加一个凭证匹配器,设置了加密方式为SHA-256, 哈希迭代数为1, 存储格式为Hex16进制
realm.setCredentialsMatcher(new HashedCredentialsMatcher("SHA-256"));
return realm;
}
/**
* 拦截器设置,设置哪些该拦截, 哪些不该拦截
*/
@Bean
public ShiroFilterChainDefinition shiroFilterChainDefinition(){
DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
definition.addPathDefinition("/", "anon");
definition.addPathDefinition("/login", "anon");
definition.addPathDefinition("/logout", "anon");
//登录成功后跳转的页面
definition.addPathDefinition("/login-success", "anon");
definition.addPathDefinition("/static/**", "anon");
//网页上面的图标
definition.addPathDefinition("/favicon.ico", "anon");
definition.addPathDefinition("/error", "anon");
//其他请求都必须认证才能通过
definition.addPathDefinition("/**", "authc");
return definition;
}
}
(2), 自定义Realm里的代码
public class MyRealm extends AuthorizingRealm {
@Autowired
private SysUserMapper sysUserMapper;
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权");
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
UsernamePasswordToken token1 = (UsernamePasswordToken)token;
String username = token1.getUsername();
SysUser user = sysUserMapper.getUserByUsername(username);
if (user == null) {
throw new UnknownAccountException();
}
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
username,
user.getPwd(),
ByteSource.Util.bytes(user.getSalt()),
getName()
);
return info;
}
}
(3),登录代码
@RequestMapping("/login")
@ResponseBody
public Result login(String username, String password, HttpServletRequest request){
//获取当前的用户
Subject subject = SecurityUtils.getSubject();
//创建一个令牌
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
//登录
try {
subject.login(token);
SysUser user = sysUserService.getUserByUsername(username);
//账号和密码都正确, 则把用户信息存储到会话作用域中
request.getSession().setAttribute("user", user);
//修改登录次数和最后登录时间
sysUserService.updateLoginCount(user.getUid());
} catch (UnknownAccountException e) {
return Result.error("账号或者密码错误!");
} catch (IncorrectCredentialsException e) {
return Result.error("账号或者密码错误!!");
} catch (AuthenticationException e) {
e.printStackTrace();
return Result.error("认证失败");
}
return Result.success();
}
15, 授权
1, 例子1: 固定角色的写法
先学一个注解@RequiresRoles(“”) 基于角色的授权
在自定义Realm里编写授权代码, 给用户一个固定的角色名称
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.addRole("p1");
return info;
}
在控制层的方法上, 加入注解@RequiresRoles(“p1”)来指定必须是p1角色才能访问此方法
@RequestMapping("/user/query")
@RequiresRoles("p1")
public String query(Integer pageNum, ModelMap modelMap, String account,String name){}
在转添加页面的方法上, 加入注解@RequiresRoles(“p2”),来指定必须是p2角色才能访问此方法
@RequiresRoles("p2")
@GetMapping("/user/addpage")
public String addpage(ModelMap modelMap){}
结果测试
访问query方法时, 没有问题, 但是访问addpage方法时,页面报了一个异常
特别注意: 如果加入注解@RequiresRoles后,页面不是500而是404错误, 如下页面
则在shiro配置文件里加入下面的代码即可.
@Bean
@ConditionalOnMissingBean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAdapterRegistry(){
DefaultAdvisorAutoProxyCreator creator = new
DefaultAdvisorAutoProxyCreator();
creator.setProxyTargetClass(true);
return creator;
}
2 例子2, 固定权限字符的写法
在授权里, 给用户设置两个权限
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
Set<String> set = new HashSet<>();
set.add("user:query");
set.add("user:addsave");
info.setStringPermissions(set);
return info;
}
控制层里,给方法添加对应的访问权限
@RequiresPermissions("user:query")
@RequestMapping("/user/query")
public String query(Integer pageNum, ModelMap modelMap, String account,String name){}
@RequiresPermissions("user:addpage")
@GetMapping("/user/addpage")
public String addpage(ModelMap modelMap){}
因为在授权里,没有给用户设置user:addpage的权限, 故此,访问addpage方法时也会报异常
3,查询用户的真实角色和权限字符
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String userName = (String) principals.getPrimaryPrincipal();
//查询角色
Set<String> roles = sysUserMapper.getRoleByUserName(userName);
Set<String> permissions = sysUserMapper.getPermissionByUserName(userName);
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.setRoles(roles);
info.setStringPermissions(permissions);
return info;
}
根据用户查询角色的SQL
select role_name
from sys_role r
inner join sys_user_role ur on r.role_id=ur.role_id
inner join sys_user u on ur.user_id=u.uid
where u.account='zhangfei'
控制层里根据角色访问的写法为
@RequiresRoles("admin")
@RequestMapping("/user/query")
public String query(Integer pageNum, ModelMap modelMap, String account,String name){}
@RequiresRoles(value = {"admin", "accounting"}, logical = Logical.OR)
@RequestMapping("/user/query")
public String query(Integer pageNum, ModelMap modelMap, String account,String name){}
Logical.OR表示前面的两个角色是或者关系, 默认是并且的关系
16,自定义异常解析器
1, 针对普通请求设置的异常解析
@ControllerAdvice
public class MyExceptionResolve {
/**
* 抓取未授权异常,跳转到页面
*/
@ExceptionHandler(UnauthorizedException.class)
public String unauthorized(){
return "error/noautho";
}
}
2, 针对ajax请求设置的异常解析
@ControllerAdvice
public class MyExceptionResolve {
private final static String XHR = "XMLHttpRequest";
/**
* 抓取未授权异常,跳转到页面
*/
@ExceptionHandler(UnauthorizedException.class)
public String unauthorized(HttpServletRequest request, HttpServletResponse response){
String xrw = request.getHeader("X-Requested-With");
//判断是否是ajax请求.
if (XHR.equals(xrw)) {
Result r = Result.error("权限不足");
response.setContentType("html/text; charset=utf-8");
try {
response.getWriter().println(JSON.toJSONString(r));
return null;
} catch (IOException e) {
e.printStackTrace();
}
}
return "error/noautho";
}
}
17, 授权4个方式
1 注解式授权
//基于角色的授权
@RequiresRoles(value = {"admin", "system"},logical = Logical.OR)
@RequiresRoles("admin")
//基于权限字符的授权
@RequiresPermissions("user:query")
这些注解可以放在方法上, 也可以放在类上
放在方法上表示, 运行这个方法必须满足指定的角色或者权限
放在类(控制层)上, 表示这个类中的所有方法都必须满足指定的角色或者权限
注解式授权如果不满足角色或者权限,则抛异常UnauthorizedException
2 编程式授权
Subject subject = SecurityUtils.getSubject();
//1,判断用户是否拥有admin角色
if (!subject.hasRole("admin")) {
//内部转到权限不足提示页面
return "error/noautho";
}
//2,判断用户是否拥有user:add的权限
if (!subject.isPermitted("user:add")) {
return Result.error("权限不足");
}
//3,判断用户是否拥有user:add的权限, 如果没有这个权限,则抛一个异常UnauthorizedException
subject.checkPermission("user:add");
3 拦截器授权
shiro里有一个默认过滤器DefaultFilter的枚举,里面有13个过滤器.
过滤器(拦截)名称 | 解释 |
---|---|
anon | 不拦截,不登录就可以访问 |
authc | 认证拦截 |
roles | 基于角色的拦截 |
perms | 基于权限的拦截 |
port | 基于的端口的拦截 |
ssl | 带加密的请求,SSL拦截器 |
user | 认证或者用了记住我功能的拦截 |
rest | 基于RestFul风格的拦截 |
authcBasic | Basic HTTP 身份验证拦截器 |
logout | 退出拦截器 |
noSessionCreation | 不创建会话拦截器 |
基于拦截器的授权写法
definition.addPathDefinition("/user/query", "roles[admin]");
如果没有权限, 我们可以设置一个未授权的请求路径,跳转到一个友好的提示页面
shiro.unauthorizedUrl=/noautho
缺点: 下面的写法表示必须同时具有两个角色, 如果只觉有期中一个,则被拦截.
definition.addPathDefinition("/user/query", "roles[admin,system]");
基于权限字符的拦截
definition.addPathDefinition("/user/query", "perms[user:query]");
4 标签式授权
能隐藏一些标签, 不让没有权限的人看到
(1), 添加一个shiro标签的方言依赖包()
<!-- 标签式授权依赖包 -->
<dependency>
<groupId>com.github.theborakompanioni</groupId>
<artifactId>thymeleaf-extras-shiro</artifactId>
<version>2.0.0</version>
</dependency>
(2), 在shiro配置文件里, 创建一个方言组件
@Bean
public ShiroDialect shiroDialect() {
return new ShiroDialect();
}
(3),在HTML页面里, 首先给html标签添加一个shiro标签的名字空间(ns=name space)
<html lang="zh" xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
(4),可以使用的shiro标签
标签名 | 解释 |
---|---|
shiro:hasRole=“admin” | 只有角色名称是admin的用户才可以看到对应的标签 |
shiro:lacksRole=“admin” | 与上面正好相反, 拥有admin角色的用户,看不到这个标签 |
shiro:hasPermission=“‘user:add’” | 拥有user:add权限的人, 能看到这个标签 |
shiro:lacksPermission=“‘user:add’” | 与上面相反, 拥有user:add 看不到这个标签 |
shiro:hasAllRoles=“developer, admin” | 验证用户是否满足前面所有角色 |
shiro:hasAnyRoles=“admin, vip, developer” | 验证用户是否属于前面任意一个角色 |
shiro:hasAllPermissions=“‘user:query, user:add’” | 验证用户是有满足前面所有权限 |
shiro:hasAnyPermissions=“‘user:query, user:add’” | 验证用户是否满足前面任意一个权限< |
shiro:authenticated=“” | 已认证通过的用户。不包含已记住的用户 |
shiro:user=“” | 认证通过或已记住的用户 |
shiro:guest=“” | 验证当前用户是否为“访客”,即未认证(包含未记住)的用户 |
shiro:notAuthenticated=“” | 未认证通过用户,与 authenticated 标签相对应。 与 guest 标签的区别是,该标签包含已记住用户 |
欢迎你: <shiro:principal/> 表示输出用户的身份(常用的身份就是账号)
18, 会话管理
shiro也提供了一个session
Session session = subject.getSession();
在shiro-spring-boot-web-starter里, shiro的session和HttpSession做了整合,
用httpSession存储的数据, 可以用shiro的session取值.
//存, 取, 删
Session session = subject.getSession();
session.setAttribute("user", user);
session.getAttribute("user");
session.removeAttribute("user");
19, 缓存
shiro中缓存的重要性: 提高授权的性能
没有缓存之前的现象是, 授权的代码会执行无数次,而添加了缓存后, 授权的代码只执行了一次
shiro里提供了一个基于内存的缓存
注意导包
import org.apache.shiro.cache.CacheManager;
@Bean
public CacheManager cacheManager(){
return new MemoryConstrainedCacheManager();
}
这个缓存实际上是一个Map
有缓存的编程模型如下:
20, shiro配置文件完整代码如下
@Configuration
public class ShiroConfig {
@Bean
@ConditionalOnMissingBean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAdapterRegistry(){
DefaultAdvisorAutoProxyCreator creator = new
DefaultAdvisorAutoProxyCreator();
creator.setProxyTargetClass(true);
return creator;
}
@Bean("authorizer")
public MyRealm myRealm(){
MyRealm realm = new MyRealm();
//添加一个凭证匹配器,设置了加密方式为SHA-256, 哈希迭代数为1, 存储格式为Hex16进制
realm.setCredentialsMatcher(new HashedCredentialsMatcher("SHA-256"));
return realm;
}
/**
* 过滤拦截设置
* @return
*/
@Bean
public ShiroFilterChainDefinition shiroFilterChainDefinition(){
DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
definition.addPathDefinition("/", "anon");
definition.addPathDefinition("/login", "anon");
definition.addPathDefinition("/logout", "anon");
//登录成功后跳转的页面
definition.addPathDefinition("/login-success", "anon");
definition.addPathDefinition("/static/**", "anon");
//网页上面的图标
definition.addPathDefinition("/favicon.ico", "anon");
definition.addPathDefinition("/error", "anon");
definition.addPathDefinition("/unautho", "anon");
//其他请求都必须认证才能通过
definition.addPathDefinition("/**", "authc");
return definition;
}
@Bean
public ShiroDialect shiroDialect() {
return new ShiroDialect();
}
@Bean
public CacheManager cacheManager(){
return new MemoryConstrainedCacheManager();
}
}
pom文件里需要的依赖包
<!-- shiro依赖包 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring-boot-web-starter</artifactId>
<version>1.9.1</version>
</dependency>
<!-- 标签式授权依赖包 -->
<dependency>
<groupId>com.github.theborakompanioni</groupId>
<artifactId>thymeleaf-extras-shiro</artifactId>
<version>2.0.0</version>
</dependency>
自定义Realm里的代码
public class MyRealm extends AuthorizingRealm {
@Resource
private SysUserMapper sysUserMapper;
/**
* 授权
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String username = (String) principals.getPrimaryPrincipal();
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
//查询用户真正的角色
Set<String> roles = sysUserMapper.getRoleNameByUserName(username);
info.setRoles(roles);
//查询用户的权限字符
Set<String > permission=sysUserMapper.getPermissionByUserName(username);
info.setStringPermissions(permission);
return info;
}
/**
* 认证
* @param token
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
UsernamePasswordToken token1 = (UsernamePasswordToken)token;
String username = token1.getUsername();
//判断账号是否正确
SysUser user = sysUserMapper.getUserByUsername(username);
if (user == null) {
throw new UnknownAccountException();
}
//返回认证对象, 将判断密码是否正确的工作交给shiro里的凭证匹配器来完成
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
username,
user.getPwd(),
ByteSource.Util.bytes(user.getSalt()),
getName()
);
return info;
}
}
SQL语句
<!-- 根据用户名查询角色 -->
<select id="getRoleNameByUserName" resultType="java.lang.String">
select role_name
from sys_role r
inner join sys_user_role ur on r.role_id=ur.role_id
inner join sys_user u on ur.user_id=u.uid
where u.account=#{username}
</select>
<!-- 根据用户名查询权限字符-->
<select id="getPermissionByUserName" resultType="java.lang.String">
select m.pstr
from sys_menu m
inner join sys_role_menu rm on m.mid=rm.mid
inner join sys_role r on rm.role_id=r.role_id
inner join sys_user_role ur on r.role_id=ur.role_id
inner join sys_user u on ur.user_id=u.uid
where u.account = #{username}
and m.pstr is not null
</select>
21, 给springboot添加一个ehcache缓存(目的是为了给shiro换缓存)
换一个Ehcache缓存
我们需要把ehcache整合到spring里, 还需要整合到shiro里,所以需要两个依赖包
(1) 添加依赖包
<!-- shiro和ehcache整合包 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>1.9.1</version>
</dependency>
<!-- springboot缓存包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
(2), 添加一个ehcache.xml配置文件
timeToIdleSeconds="120" //空闲时间: 120秒内,只要有查询,则时间重置为120秒.
例子: 米饭需要2分钟就会凉了, 但是2分钟内只要加热一次, 则米饭又需要2分钟才能凉.
timeToLiveSeconds="120" //生存时间, 只有2分钟,时间一到就删除掉.
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--
maxElementsInMemory 内存中存储的最大对象数量
eternal 内存中数据是否永久存储,true:永久,timeToIdleSeconds和timeToLiveSeconds失效.
overflowToDisk 是否可以将超过内存最大数后的对象存储到硬盘里,
timeToIdleSeconds 数据的空闲时间,默认为0,表示一直存在
timeToLiveSeconds 数据的生存时间,
diskPersistent 硬盘里数据是否永久存储
diskExpiryThreadIntervalSeconds 硬盘里数据的生存时间,默认120秒
memoryStoreEvictionPolicy 内存数据达到最大限制时删除策略,LRU:删除最近使用最少的. FIFO:先进先出, LFU:较少使用
-->
<diskStore path="java.io.tmpdir/shiro-ehcache"/>
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="false"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
/>
<cache name="userCache"
maxElementsInMemory="2000"
eternal="false"
timeToIdleSeconds="60"
timeToLiveSeconds="0"
overflowToDisk="false"
></cache>
</ehcache>
(3),在springboot的application.properties里加载ehcache的配置文件
spring.cache.ehcache.config=classpath:/ehcache.xml
22, 给shiro换缓存
import net.sf.ehcache.CacheManager;
import org.apache.shiro.cache.ehcache.EhCacheManager;
@Bean
public EhCacheManager ehCacheManager(CacheManager cacheManager){
EhCacheManager ehCacheManager = new EhCacheManager();
ehCacheManager.setCacheManager(cacheManager);
return ehCacheManager;
}
23, springboot项目里怎么使用缓存
(1),开启缓存
@EnableCaching
(2),在springboot里怎么使用这个缓存呢?
第一步,注入缓存管理器, 注意导包 import org.springframework.cache.CacheManager;
@Autowired
private CacheManager cacheManager;
第二步, 按照缓存使用原则的编程模型,开始编写代码
queryWrapper.orderByDesc("uid");
//=====================开始=========================
Cache cache = cacheManager.getCache("userCache");
String key = "user-"+pageNum;
PageInfo<SysUser> pageInfo = cache.get(key, PageInfo.class);
if (pageInfo == null) {
PageHelper.startPage(pageNum, 10);
List<SysUser> list = sysUserService.list(queryWrapper);
pageInfo = new PageInfo<>(list);
cache.put(key, pageInfo);
}
//=====================结束============================
modelMap.put("pageInfo", pageInfo);
modelMap.put("account", account);
modelMap.put("name", name);
第三步, 缓存和数据库同步问题,
我们再进行添加, 修改,删除时, 应该清空缓存
@PostMapping("/user/addsave")
@ResponseBody
public Result addsave(SysUser user, Integer[] roleIds){
boolean bj = sysUserService.addsave(user, roleIds);
//======================开始========================
if (bj) {
Cache cache = cacheManager.getCache("userCache");
cache.clear();
}
//======================结束========================
return Result.out(bj, "添加失败", user);
}