前言
Apache Shiro 是一个强大且容易使用的Java安全矿建，执行身份验证，授权，密码和会话管理。使用Shiro的易于理解的API您可以快速轻松的获得任何应用程序直到大的项目。
一丶什么是Shiro
1.Shiro是什么
Apache Shiro是一个强大且易于使用的Java安全框架，执行身份验证，授权，密码和会话管理。主要的好处是易于理解。
- 验证用户来核实他们的身份
- 对用户执行访问控制
- 判断用户是否被分配了一个确定的安全角色
- 判断用户是否被允许做某事
- 在任何环境下使用SessionAPI，即使没有Web容器
- 在身份验证，访问控制期间或在会话的生命周期，对事件做出反应
- 聚集一个或多个用户安全数据的数据源，并且作为一个单一的复合用户视图
- 启动单点登录（SSO）功能
- 为没有关联到登录的用户做Remember Me服务
2.Shiro的功能模块
shiro可以非常容易开发出足够好用的应用，其不仅可以再JaveSE环境，也可以在JavaEE环境。Shiro可以帮助我们完成：认证授权加密会话管理，与WEB集成，缓存等。也可以与springboot集成快速开发
- Authentication：身份认证/登录，验证用户是不是拥有相应的身份。
- Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情。
- Session Management：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的。
- Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储。
- Web Support：Shiro 的 web 支持的 API 能够轻松地帮助保护 Web 应用程序。
- Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率。
- Concurrency：Apache Shiro 利用它的并发特性来支持多线程应用程序。
- Testing：测试支持的存在来帮助你编写单元测试和集成测试，并确保你的能够如预期的一样安全。
- "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
- "Remember Me"：记住我。
二丶Shiro的内部结构
- Subject：主体，是任何可以与应用交互的 “技术用户”
- Security Manager:相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；他管理着所有的Subject，负责进行认证，授权，会话，缓存和管理
- Authenticator:认证器，负责主体认证的，这是一个扩展点，如果用具觉得默认不好，可以自定义实现。需要认证策略，即认证通过的情况
- Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作
- Realm:可以有一个或多个Realm，可以认为是安全实体的数据源，即用于获取安全实体的，可以是JDBC实现，也可以是L:DAP实现，或者内存实现等等。由用户提供，注意：Shiro不知道你的用户/权限存储在哪，以及以何种形式存储；所有我们一般在应用中都需要实现自己的Realm；
- sessionManager：SessionManager是管理Session会话域生命周期的组件。而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；
- SessionDAO：数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；
- CacheManager：缓存控制器，来管理如用户，角色，权限等的缓存；因为这些数据基本上很少去改变，放到缓存中提高访问性能
- Crayptography：密码模块，Shiro提高了一些常见的加密组件用于如密码的加密和解密
三丶应用程序使用Shiro
一个简单的Shiro应用最少应该如下：
1.应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；
2.我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限判断
总而言之：Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入。
四丶Shiro的入门
1.搭建基于ini的运行环境
创建工程导入shiro坐标
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.xidida</groupId>
<artifactId>shiro_demo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.3.2</version>
</dependency>
<!-- 测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.3</version>
</dependency>
</dependencies>
</project>
2.用户认证
认证：身份认证/登录，验证用户是否拥有相应的身份，基于Shiro的认证，是通过subject的login方法完成用户认证的工作
2.1在resource目录下创建爱你shiro的ini配置文件构造模拟数据（shiro_config,ini）
2.2用户授权：
/**
* 设置角色权限
*
* @param user 用户信息
*/
public void setRolePermission(SysUser user)
{
List<SysRole> roles = user.getRoles();
if (!roles.isEmpty() && roles.size() > 1)
{
// 多角色设置permissions属性，以便数据权限匹配权限
for (SysRole role : roles)
{
Set<String> rolePerms = menuService.selectPermsByRoleId(role.getRoleId());
role.setPermissions(rolePerms);
}
}
}2.3登录权限校验
@Component public class SysLoginService { @Autowired //密码 private SysPasswordService passwordService; @Autowired //用户 private ISysUserService userService; @Autowired //访问列表 private ISysMenuService menuService; @Autowired //配置 private ISysConfigService configService; /** * 登录 */ public SysUser login(String username, String password) { // 验证码校验 if (ShiroConstants.CAPTCHA_ERROR.equals(ServletUtils.getRequest().getAttribute(ShiroConstants.CURRENT_CAPTCHA))) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error"))); throw new CaptchaException(); } // 用户名或密码为空 错误 if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("not.null"))); throw new UserNotExistsException(); } // 密码如果不在指定范围内 错误 if (password.length() < UserConstants.PASSWORD_MIN_LENGTH || password.length() > UserConstants.PASSWORD_MAX_LENGTH) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match"))); throw new UserPasswordNotMatchException(); } // 用户名不在指定范围内 错误 if (username.length() < UserConstants.USERNAME_MIN_LENGTH || username.length() > UserConstants.USERNAME_MAX_LENGTH) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match"))); throw new UserPasswordNotMatchException(); } // IP黑名单校验 String blackStr = configService.selectConfigByKey("sys.login.blackIPList"); if (IpUtils.isMatchedIp(blackStr, ShiroUtils.getIp())) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("login.blocked"))); throw new BlackListException(); } // 查询用户信息 SysUser user = userService.selectUserByLoginName(username); if (user == null) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.not.exists"))); throw new UserNotExistsException(); } if (UserStatus.DELETED.getCode().equals(user.getDelFlag())) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.delete"))); throw new UserDeleteException(); } if (UserStatus.DISABLE.getCode().equals(user.getStatus())) { AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.blocked"))); throw new UserBlockedException(); } passwordService.validate(user, password); AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success"))); setRolePermission(user); recordLoginInfo(user.getUserId()); return user; }
2.4注册校验
@Component
public class SysRegisterService
{
@Autowired
private ISysUserService userService;
@Autowired
private SysPasswordService passwordService;
/**
* 注册
*/
public String register(SysUser user)
{
String msg = "", loginName = user.getLoginName(), password = user.getPassword();
if (ShiroConstants.CAPTCHA_ERROR.equals(ServletUtils.getRequest().getAttribute(ShiroConstants.CURRENT_CAPTCHA)))
{
msg = "验证码错误";
}
else if (StringUtils.isEmpty(loginName))
{
msg = "用户名不能为空";
}
else if (StringUtils.isEmpty(password))
{
msg = "用户密码不能为空";
}
else if (password.length() < UserConstants.PASSWORD_MIN_LENGTH
|| password.length() > UserConstants.PASSWORD_MAX_LENGTH)
{
msg = "密码长度必须在5到20个字符之间";
}
else if (loginName.length() < UserConstants.USERNAME_MIN_LENGTH
|| loginName.length() > UserConstants.USERNAME_MAX_LENGTH)
{
msg = "账户长度必须在2到20个字符之间";
}
else if (!userService.checkLoginNameUnique(user))
{
msg = "保存用户'" + loginName + "'失败，注册账号已存在";
}
else
{
user.setPwdUpdateDate(DateUtils.getNowDate());
user.setUserName(loginName);
user.setSalt(ShiroUtils.randomSalt());
user.setPassword(passwordService.encryptPassword(loginName, password, user.getSalt()));
boolean regFlag = userService.registerUser(user);
if (!regFlag)
{
msg = "注册失败,请联系系统管理人员";
}
else
{
AsyncManager.me().execute(AsyncFactory.recordLogininfor(loginName, Constants.REGISTER, MessageUtils.message("user.register.success")));
}
}
return msg;
}
}2.5自定义Realm
Realm域：Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源
/**
* 自定义Realm 处理登录 权限
*
* @author ruoyi
*/
public class UserRealm extends AuthorizingRealm
{
private static final Logger log = LoggerFactory.getLogger(UserRealm.class);
@Autowired
private ISysMenuService menuService;
@Autowired
private ISysRoleService roleService;
@Autowired
private SysLoginService loginService;
/**
* 授权
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0)
{
SysUser user = ShiroUtils.getSysUser();
// 角色列表
Set<String> roles = new HashSet<String>();
// 功能列表
Set<String> menus = new HashSet<String>();
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
// 管理员拥有所有权限
if (user.isAdmin())
{
info.addRole("admin");
info.addStringPermission("*:*:*");
}
else
{
roles = roleService.selectRoleKeys(user.getUserId());
menus = menuService.selectPermsByUserId(user.getUserId());
// 角色加入AuthorizationInfo认证对象
info.setRoles(roles);
// 权限加入AuthorizationInfo认证对象
info.setStringPermissions(menus);
}
return info;
}
/**
* 登录认证
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException
{
UsernamePasswordToken upToken = (UsernamePasswordToken) token;
String username = upToken.getUsername();
String password = "";
if (upToken.getPassword() != null)
{
password = new String(upToken.getPassword());
}
SysUser user = null;
try
{
user = loginService.login(username, password);
}
catch (CaptchaException e)
{
throw new AuthenticationException(e.getMessage(), e);
}
catch (UserNotExistsException e)
{
throw new UnknownAccountException(e.getMessage(), e);
}
catch (UserPasswordNotMatchException e)
{
throw new IncorrectCredentialsException(e.getMessage(), e);
}
catch (UserPasswordRetryLimitExceedException e)
{
throw new ExcessiveAttemptsException(e.getMessage(), e);
}
catch (UserBlockedException e)
{
throw new LockedAccountException(e.getMessage(), e);
}
catch (RoleBlockedException e)
{
throw new LockedAccountException(e.getMessage(), e);
}
catch (Exception e)
{
log.info("对用户[" + username + "]进行登录验证..验证未通过{}", e.getMessage());
throw new AuthenticationException(e.getMessage(), e);
}
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, password, getName());
return info;
}
/**
* 清理指定用户授权信息缓存
*/
public void clearCachedAuthorizationInfo(Object principal)
{
SimplePrincipalCollection principals = new SimplePrincipalCollection(principal, getName());
this.clearCachedAuthorizationInfo(principals);
}
/**
* 清理所有用户授权信息缓存
*/
public void clearAllCachedAuthorizationInfo()
{
Cache<Object, AuthorizationInfo> cache = getAuthorizationCache();
if (cache != null)
{
for (Object key : cache.keys())
{
cache.remove(key);
}
}
}
}
2.6认证与授权的执行流程分析
（1）认证流程
- 首先调用Subject .login(token)进行登录，其会自动委托给SuecrityManager，调用之前必须通过SecurityUtils.setSecurityManager()设置。
- SecurityManager负责真正的身份验证逻辑；他会委托给Authenticator进行身份验证
- Authenticator才是真正的身份验证者，ShiroAPI中核心的身份认证入口，此处插入自己的实现
-
Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证，默认ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证，
-
Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。
（2）授权流程
- 首先调用Subject.jsPermitted/hasRole接口,其会委托给SecurityManager，而SecurityManager接着委托给Authorize
- Authorizer是真正的授权者，如果我们调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例；
- 在真正授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限；Authorize会判断Realm的角色/权限是否和传入的相匹配，如果有多个Realm，则会委托给MoudlarRealmAuthorizer进行循环判断，如果匹配如isPermitted/hasRole会返回true，否则返回授权失败
五丶Shiro在SpringBoot中的使用
1.案例说明
使用Springboot构建应用程序，整合shiro矿建完成用户认证与授权
1.1整合依赖
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.3.2</version>
</dependency>1.2自定义登录方法
@RequestMapping(value="/login")
public String login(String username,String password) {
/**
* 密码加密：
* shiro 提供了默认的密码加密 =》 Md5Hash
* Md5Hash():
* 参数1：加密内容
* 参数2：盐（加密混淆字符串）（密码+混淆字符串）==>一般是随机字符串，到时候会存入数据库中
* 参数3：加密次数
*
*/
try {
// 加密
password = new Md5Hash(password, username, 3).toString();
// 构造登录令牌
UsernamePasswordToken token = new UsernamePasswordToken(username,password);
//1、获取subject
Subject subject = SecurityUtils.getSubject();
// 2、调用 subject 进行登陆
subject.login(token);
return "登录成功";
}catch (Exception e){
return "用户名或密码错误";
}
}1.3自定义realm
import cn.itcast.shiro.domain.Permission;
import cn.itcast.shiro.domain.Role;
import cn.itcast.shiro.domain.User;
import cn.itcast.shiro.service.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* @author YJC
* @e-mail xiaochun235@qq.com
* @Date 2022/12/8 20:05
* @notes shiro 中自定义 realm 域
*/
public class CustomReaml extends AuthorizingRealm {
@Override
public void setName(String name) {
super.setName("customReaml");// 名称一般用类名，也可以自定义
}
// 进行数据库查询
@Autowired
private UserService userService;
/**
* 授权：
* 操作时，判断用户是否具有相应的权限
* 先认证 -- 安全数据
* 在授权 -- 根据安全数据获取用户具有的所有操作权限
*
*
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
// 1、获取已认证的用户数据
User user = (User) principalCollection.getPrimaryPrincipal();// 获取安全数据
// 2、根据用户数据获取用户的权限信息，（所有角色，所有权限）
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
Set<String> roles = new HashSet<>();
Set<String> perms = new HashSet<>();
for(Role role:user.getRoles()){
roles.add(role.getName());// 暂时存储 role 的名称
for (Permission permission : role.getPermissions()){
perms.add(permission.getCode());
}
}
info.setRoles(roles);
info.setStringPermissions(perms);
// 返回授权
return info;
}
/**
* 认证：
* 参数：用户名密码
*
*
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
// 1、获取用户名密码（token）
UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
String username = token.getUsername();
String password = new String( token.getPassword() );// token.getPassword() 返回的是一个 char数组
// 2、根据用户名查询数据库
User user = userService.findByName(username);
// 3、判断用户是否存在或者密码是否一致
if (user!=null && user.getPassword().equals(password)){
// 4、如果一致返回安全数据
// 构造方法：安全数据；密码，realm 域
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
return info;
}
// 5、不一致，返回 null(抛出异常)
return null;
}
}1.4Shiro的配置
SecurityManager 是 Shiro 架构的心脏，用于协调内部的多个组件完成全部认证授权的过程。例如通过调用realm完成认证与登录。使用基于springboot的配置方式完成SecurityManager，Realm的装配
无redis 配置：
package cn.itcast.shiro;
import cn.itcast.shiro.reaml.CustomReaml;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
/**
* @author YJC
* @e-mail xiaochun235@qq.com
* @Date 2022/12/8 20:34
* @notes shiro 配置
*/
@Configuration
public class ShiroConfig {
// 1、创建 realm
@Bean
public CustomReaml getRealm(){
return new CustomReaml(); //CustomReaml ==》自定义 customReaml
}
// 2、创建安全管理器
@Bean
public SecurityManager securityManager(CustomReaml reaml){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(reaml);
return securityManager;
}
// 3、配置 shiro 的过滤器工厂
/**
* 在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
* @param securityManager
* @return
*/
@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
// 1、创建过滤器工厂
ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
// 2、设置安全管理器
filterFactory.setSecurityManager(securityManager);
// 3、通过配置（跳转登陆页面，为授权跳转的页面）
filterFactory.setLoginUrl("/longinerror");// 跳转到url 路径 （没有登陆跳转）
filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
// 4、设置过滤器集合
/**
* 设置所有的过滤器：map
* key=拦截的 url 地址
* value=过滤器类型
* 可以选择有序的 map 集合==》LinkedHashMap
*/
Map<String,String> filterMap = new LinkedHashMap<>();
//当前请求地址可以匿名访问
filterMap.put("/user/home","anon");
// swagger 访问地址开放地址
filterMap.put("/doc.htm**","anon");
filterMap.put("/webjars/**","anon");
filterMap.put("/swagger**","anon");
filterMap.put("/v2/**","anon");
// 登陆接口
filterMap.put("/login","anon");
// 当前请求地址必须认证之后才可以访问
filterMap.put("/**","authc");
filterFactory.setFilterChainDefinitionMap(filterMap);
return filterFactory;
}
// 4、开启shiro 注解的支持
//配置shiro注解支持
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
}redis配置，注：以下配置并不是本人项目配置，考虑到功能的完整性，以下配置是开源项目若依的shiro相关跑配置
package com.ruoyi.framework.config;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.servlet.Filter;
import org.apache.commons.io.IOUtils;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.codec.Base64;
import org.apache.shiro.config.ConfigurationException;
import org.apache.shiro.io.ResourceUtils;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.CipherUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.shiro.realm.UserRealm;
import com.ruoyi.framework.shiro.session.OnlineSessionDAO;
import com.ruoyi.framework.shiro.session.OnlineSessionFactory;
import com.ruoyi.framework.shiro.web.CustomShiroFilterFactoryBean;
import com.ruoyi.framework.shiro.web.filter.LogoutFilter;
import com.ruoyi.framework.shiro.web.filter.captcha.CaptchaValidateFilter;
import com.ruoyi.framework.shiro.web.filter.kickout.KickoutSessionFilter;
import com.ruoyi.framework.shiro.web.filter.online.OnlineSessionFilter;
import com.ruoyi.framework.shiro.web.filter.sync.SyncOnlineSessionFilter;
import com.ruoyi.framework.shiro.web.session.OnlineWebSessionManager;
import com.ruoyi.framework.shiro.web.session.SpringSessionValidationScheduler;
import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
/**
* 权限配置加载
*
* @author ruoyi
*/
@Configuration
public class ShiroConfig
{
/**
* Session超时时间，单位为毫秒（默认30分钟）
*/
@Value("${shiro.session.expireTime}")
private int expireTime;
/**
* 相隔多久检查一次session的有效性，单位毫秒，默认就是10分钟
*/
@Value("${shiro.session.validationInterval}")
private int validationInterval;
/**
* 同一个用户最大会话数
*/
@Value("${shiro.session.maxSession}")
private int maxSession;
/**
* 踢出之前登录的/之后登录的用户，默认踢出之前登录的用户
*/
@Value("${shiro.session.kickoutAfter}")
private boolean kickoutAfter;
/**
* 验证码开关
*/
@Value("${shiro.user.captchaEnabled}")
private boolean captchaEnabled;
/**
* 验证码类型
*/
@Value("${shiro.user.captchaType}")
private String captchaType;
/**
* 设置Cookie的域名
*/
@Value("${shiro.cookie.domain}")
private String domain;
/**
* 设置cookie的有效访问路径
*/
@Value("${shiro.cookie.path}")
private String path;
/**
* 设置HttpOnly属性
*/
@Value("${shiro.cookie.httpOnly}")
private boolean httpOnly;
/**
* 设置Cookie的过期时间，秒为单位
*/
@Value("${shiro.cookie.maxAge}")
private int maxAge;
/**
* 设置cipherKey密钥
*/
@Value("${shiro.cookie.cipherKey}")
private String cipherKey;
/**
* 登录地址
*/
@Value("${shiro.user.loginUrl}")
private String loginUrl;
/**
* 权限认证失败地址
*/
@Value("${shiro.user.unauthorizedUrl}")
private String unauthorizedUrl;
/**
* 是否开启记住我功能
*/
@Value("${shiro.rememberMe.enabled: false}")
private boolean rememberMe;
/**
* 缓存管理器 使用Ehcache实现
*/
@Bean
public EhCacheManager getEhCacheManager()
{
net.sf.ehcache.CacheManager cacheManager = net.sf.ehcache.CacheManager.getCacheManager("ruoyi");
EhCacheManager em = new EhCacheManager();
if (StringUtils.isNull(cacheManager))
{
em.setCacheManager(new net.sf.ehcache.CacheManager(getCacheManagerConfigFileInputStream()));
return em;
}
else
{
em.setCacheManager(cacheManager);
return em;
}
}
/**
* 返回配置文件流 避免ehcache配置文件一直被占用，无法完全销毁项目重新部署
*/
protected InputStream getCacheManagerConfigFileInputStream()
{
String configFile = "classpath:ehcache/ehcache-shiro.xml";
InputStream inputStream = null;
try
{
inputStream = ResourceUtils.getInputStreamForPath(configFile);
byte[] b = IOUtils.toByteArray(inputStream);
InputStream in = new ByteArrayInputStream(b);
return in;
}
catch (IOException e)
{
throw new ConfigurationException(
"Unable to obtain input stream for cacheManagerConfigFile [" + configFile + "]", e);
}
finally
{
IOUtils.closeQuietly(inputStream);
}
}
/**
* 自定义Realm
*/
@Bean
public UserRealm userRealm(EhCacheManager cacheManager)
{
UserRealm userRealm = new UserRealm();
userRealm.setAuthorizationCacheName(Constants.SYS_AUTH_CACHE);
userRealm.setCacheManager(cacheManager);
return userRealm;
}
/**
* 自定义sessionDAO会话
*/
@Bean
public OnlineSessionDAO sessionDAO()
{
OnlineSessionDAO sessionDAO = new OnlineSessionDAO();
return sessionDAO;
}
/**
* 自定义sessionFactory会话
*/
@Bean
public OnlineSessionFactory sessionFactory()
{
OnlineSessionFactory sessionFactory = new OnlineSessionFactory();
return sessionFactory;
}
/**
* 会话管理器
*/
@Bean
public OnlineWebSessionManager sessionManager()
{
OnlineWebSessionManager manager = new OnlineWebSessionManager();
// 加入缓存管理器
manager.setCacheManager(getEhCacheManager());
// 删除过期的session
manager.setDeleteInvalidSessions(true);
// 设置全局session超时时间
manager.setGlobalSessionTimeout(expireTime * 60 * 1000);
// 去掉 JSESSIONID
manager.setSessionIdUrlRewritingEnabled(false);
// 定义要使用的无效的Session定时调度器
manager.setSessionValidationScheduler(SpringUtils.getBean(SpringSessionValidationScheduler.class));
// 是否定时检查session
manager.setSessionValidationSchedulerEnabled(true);
// 自定义SessionDao
manager.setSessionDAO(sessionDAO());
// 自定义sessionFactory
manager.setSessionFactory(sessionFactory());
return manager;
}
/**
* 安全管理器
*/
@Bean
public SecurityManager securityManager(UserRealm userRealm)
{
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
// 设置realm.
securityManager.setRealm(userRealm);
// 记住我
securityManager.setRememberMeManager(rememberMe ? rememberMeManager() : null);
// 注入缓存管理器;
securityManager.setCacheManager(getEhCacheManager());
// session管理器
securityManager.setSessionManager(sessionManager());
return securityManager;
}
/**
* 退出过滤器
*/
public LogoutFilter logoutFilter()
{
LogoutFilter logoutFilter = new LogoutFilter();
logoutFilter.setLoginUrl(loginUrl);
return logoutFilter;
}
/**
* Shiro过滤器配置
*/
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager)
{
CustomShiroFilterFactoryBean shiroFilterFactoryBean = new CustomShiroFilterFactoryBean();
// Shiro的核心安全接口,这个属性是必须的
shiroFilterFactoryBean.setSecurityManager(securityManager);
// 身份认证失败，则跳转到登录页面的配置
shiroFilterFactoryBean.setLoginUrl(loginUrl);
// 权限认证失败，则跳转到指定页面
shiroFilterFactoryBean.setUnauthorizedUrl(unauthorizedUrl);
// Shiro连接约束配置，即过滤链的定义
LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
// 对静态资源设置匿名访问
filterChainDefinitionMap.put("/favicon.ico**", "anon");
filterChainDefinitionMap.put("/ruoyi.png**", "anon");
filterChainDefinitionMap.put("/html/**", "anon");
filterChainDefinitionMap.put("/css/**", "anon");
filterChainDefinitionMap.put("/docs/**", "anon");
filterChainDefinitionMap.put("/fonts/**", "anon");
filterChainDefinitionMap.put("/img/**", "anon");
filterChainDefinitionMap.put("/ajax/**", "anon");
filterChainDefinitionMap.put("/js/**", "anon");
filterChainDefinitionMap.put("/ruoyi/**", "anon");
filterChainDefinitionMap.put("/captcha/captchaImage**", "anon");
// 退出 logout地址，shiro去清除session
filterChainDefinitionMap.put("/logout", "logout");
// 不需要拦截的访问
filterChainDefinitionMap.put("/login", "anon,captchaValidate");
// 注册相关
filterChainDefinitionMap.put("/register", "anon,captchaValidate");
// 系统权限列表
// filterChainDefinitionMap.putAll(SpringUtils.getBean(IMenuService.class).selectPermsAll());
Map<String, Filter> filters = new LinkedHashMap<String, Filter>();
filters.put("onlineSession", onlineSessionFilter());
filters.put("syncOnlineSession", syncOnlineSessionFilter());
filters.put("captchaValidate", captchaValidateFilter());
filters.put("kickout", kickoutSessionFilter());
// 注销成功，则跳转到指定页面
filters.put("logout", logoutFilter());
shiroFilterFactoryBean.setFilters(filters);
// 所有请求需要认证
filterChainDefinitionMap.put("/**", "user,kickout,onlineSession,syncOnlineSession");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilterFactoryBean;
}
/**
* 自定义在线用户处理过滤器
*/
public OnlineSessionFilter onlineSessionFilter()
{
OnlineSessionFilter onlineSessionFilter = new OnlineSessionFilter();
onlineSessionFilter.setLoginUrl(loginUrl);
onlineSessionFilter.setOnlineSessionDAO(sessionDAO());
return onlineSessionFilter;
}
/**
* 自定义在线用户同步过滤器
*/
public SyncOnlineSessionFilter syncOnlineSessionFilter()
{
SyncOnlineSessionFilter syncOnlineSessionFilter = new SyncOnlineSessionFilter();
syncOnlineSessionFilter.setOnlineSessionDAO(sessionDAO());
return syncOnlineSessionFilter;
}
/**
* 自定义验证码过滤器
*/
public CaptchaValidateFilter captchaValidateFilter()
{
CaptchaValidateFilter captchaValidateFilter = new CaptchaValidateFilter();
captchaValidateFilter.setCaptchaEnabled(captchaEnabled);
captchaValidateFilter.setCaptchaType(captchaType);
return captchaValidateFilter;
}
/**
* cookie 属性设置
*/
public SimpleCookie rememberMeCookie()
{
SimpleCookie cookie = new SimpleCookie("rememberMe");
cookie.setDomain(domain);
cookie.setPath(path);
cookie.setHttpOnly(httpOnly);
cookie.setMaxAge(maxAge * 24 * 60 * 60);
return cookie;
}
/**
* 记住我
*/
public CookieRememberMeManager rememberMeManager()
{
CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
cookieRememberMeManager.setCookie(rememberMeCookie());
if (StringUtils.isNotEmpty(cipherKey))
{
cookieRememberMeManager.setCipherKey(Base64.decode(cipherKey));
}
else
{
cookieRememberMeManager.setCipherKey(CipherUtils.generateNewKey(128, "AES").getEncoded());
}
return cookieRememberMeManager;
}
/**
* 同一个用户多设备登录限制
*/
public KickoutSessionFilter kickoutSessionFilter()
{
KickoutSessionFilter kickoutSessionFilter = new KickoutSessionFilter();
kickoutSessionFilter.setCacheManager(getEhCacheManager());
kickoutSessionFilter.setSessionManager(sessionManager());
// 同一个用户最大的会话数，默认-1无限制；比如2的意思是同一个用户允许最多同时两个人登录
kickoutSessionFilter.setMaxSession(maxSession);
// 是否踢出后来登录的，默认是false；即后者登录的用户踢出前者登录的用户；踢出顺序
kickoutSessionFilter.setKickoutAfter(kickoutAfter);
// 被踢出后重定向到的地址；
kickoutSessionFilter.setKickoutUrl("/login?kickout=1");
return kickoutSessionFilter;
}
/**
* thymeleaf模板引擎和shiro框架的整合
*/
@Bean
public ShiroDialect shiroDialect()
{
return new ShiroDialect();
}
/**
* 开启Shiro注解通知器
*/
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(
@Qualifier("securityManager") SecurityManager securityManager)
{
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
}
}
1.5基于注解的授权
package cn.itcast.shiro;
import cn.itcast.shiro.reaml.CustomReaml;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
/**
* @author YJC
* @e-mail xiaochun235@qq.com
* @Date 2022/12/8 20:34
* @notes shiro 配置
*/
@Configuration
public class ShiroConfig {
// 1、创建 realm
@Bean
public CustomReaml getRealm(){
return new CustomReaml(); //CustomReaml ==》自定义 customReaml
}
// 2、创建安全管理器
@Bean
public SecurityManager securityManager(CustomReaml reaml){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(reaml);
return securityManager;
}
// 3、配置 shiro 的过滤器工厂
/**
* 在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
* @param securityManager
* @return
*/
@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
// 1、创建过滤器工厂
ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
// 2、设置安全管理器
filterFactory.setSecurityManager(securityManager);
// 3、通过配置（跳转登陆页面，为授权跳转的页面）
filterFactory.setLoginUrl("/longinerror");// 跳转到url 路径 （没有登陆跳转）
filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
// 4、设置过滤器集合
/**
* 设置所有的过滤器：map
* key=拦截的 url 地址
* value=过滤器类型
* 可以选择有序的 map 集合==》LinkedHashMap
*/
Map<String,String> filterMap = new LinkedHashMap<>();
// 不需要登录 即可访问
//当前请求地址可以匿名访问
filterMap.put("/user/home","anon");
// 当前请求地址可以匿名访问 swagger 访问地址开放地址
filterMap.put("/doc.htm**","anon");
filterMap.put("/webjars/**","anon");
filterMap.put("/swagger**","anon");
filterMap.put("/v2/**","anon");
// 登陆接口
filterMap.put("/login","anon");
// 当前请求地址必须认证之后才可以访问 需要登录才能访问
filterMap.put("/user**","authc");
filterMap.put("/test","authc");
// 使用 过滤器 的形式来配置 权限
// 需要当前用户 拥有 该角色 才能访问 role.getName() 在 realm 中的授权存入内容的
// filterMap.put("/user/list","roles[系统管理员]");
// 需要有权限才能访问
// 具有 某种权限才能访问 查询用户 当有 user-find 该权限才能访问该接口
// 也可以使用 注解的形式来配置 权限 user-find ==》为 permission.getCode() 在 realm 中的授权存入内容的
// filterMap.put("/user/list","perms[user-list]");// 如果不具有这个权限则就跳转到 setUnauthorizedUrl 改接口
filterFactory.setFilterChainDefinitionMap(filterMap);
return filterFactory;
}
// 4、开启shiro 注解的支持
//配置shiro注解支持
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
}1.6controller
/**
* import org.apache.shiro.authz.annotation.RequiresRoles;
* import org.apache.shiro.authz.annotation.RequiresPermissions;
* 使用 shiro 注解的形式实现 角色 及其 权限 授权
* @RequiresPermissions() ：访问当前方法必须具备的权限
* @RequiresRoles() ： 访问当前方法所具备的角色
* @return
* 1、过滤器：如果权限信息不匹配 则会运行改方法 setUnauthorizedUrl("/autherror");
* 2、注解：如果没有权限则会 抛出异常 ：AuthorizationException
* @RequiresPermissions("user-list")
* @RequiresRoles("系统管理员")
*/
@RequiresPermissions("user-list")
// @RequiresRoles()
@ApiOperation("查询用户")
@RequestMapping(value = "/user/list",method = RequestMethod.GET)
public String find() {
return "查询用户成功";
}
1.7异常处理
package com.ruoyi.framework.web.exception;
import javax.servlet.http.HttpServletRequest;
import org.apache.shiro.authz.AuthorizationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.BindException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.servlet.ModelAndView;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.exception.DemoModeException;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.security.PermissionUtils;
/**
* 全局异常处理器
*
* @author ruoyi
*/
@RestControllerAdvice
public class GlobalExceptionHandler
{
private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
/**
* 权限校验异常（ajax请求返回json，redirect请求跳转页面）
*/
@ExceptionHandler(AuthorizationException.class)
public Object handleAuthorizationException(AuthorizationException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',权限校验失败'{}'", requestURI, e.getMessage());
if (ServletUtils.isAjaxRequest(request))
{
return AjaxResult.error(PermissionUtils.getMsg(e.getMessage()));
}
else
{
return new ModelAndView("error/unauth");
}
}
/**
* 请求方式不支持
*/
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public AjaxResult handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e,
HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod());
return AjaxResult.error(e.getMessage());
}
/**
* 拦截未知的运行时异常
*/
@ExceptionHandler(RuntimeException.class)
public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生未知异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
/**
* 系统异常
*/
@ExceptionHandler(Exception.class)
public AjaxResult handleException(Exception e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
/**
* 业务异常
*/
@ExceptionHandler(ServiceException.class)
public Object handleServiceException(ServiceException e, HttpServletRequest request)
{
log.error(e.getMessage(), e);
if (ServletUtils.isAjaxRequest(request))
{
return AjaxResult.error(e.getMessage());
}
else
{
return new ModelAndView("error/service", "errorMessage", e.getMessage());
}
}
/**
* 请求路径中缺少必需的路径变量
*/
@ExceptionHandler(MissingPathVariableException.class)
public AjaxResult handleMissingPathVariableException(MissingPathVariableException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求路径中缺少必需的路径变量'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(String.format("请求路径中缺少必需的路径变量[%s]", e.getVariableName()));
}
/**
* 请求参数类型不匹配
*/
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
public AjaxResult handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e,
HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求参数类型不匹配'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(String.format("请求参数类型不匹配，参数[%s]要求类型为：'%s'，但输入值为：'%s'", e.getName(), e.getRequiredType().getName(), e.getValue()));
}
/**
* 自定义验证异常
*/
@ExceptionHandler(BindException.class)
public AjaxResult handleBindException(BindException e)
{
log.error(e.getMessage(), e);
String message = e.getAllErrors().get(0).getDefaultMessage();
return AjaxResult.error(message);
}
/**
* 演示模式异常
*/
@ExceptionHandler(DemoModeException.class)
public AjaxResult handleDemoModeException(DemoModeException e)
{
return AjaxResult.error("演示模式，不允许操作");
}
}
六丶Shiro中会话管理
在shiro中所有的用户的会话信息都回由Shiro来进行控制，Shiro提供的会话可以用JavaSE/JavaEE环境，不依赖于任何底层容器，可以独立使用，是完整的会话模块。通过Shiro的会话管理器（SessionManager）进行统一的会话管理
1.什么是shiro会话管理
SessionManager（会话管理器）：管理所有Subject的session包括创建，维护，删除，失效，验证等工作。SessionManager是顶层组件，由SecurityManager管理shiro提供了说那个默认实现：
1.DefaultSessionManager：用于JavaSE环境
2.ServletContainerSessionManager：用于Web环境，直接使用servlet容器的会话。
3.DefaultWebSessionManager:用于web环境，自己维护会话（相当于直接舍弃了Servlet容器的会话管理）。
在web程序中，通过shiro的Subject.login()方法登录成功后，用户的认证信息实际上是保存在HttpSession中的通过如下代码验证。
//登录成功后，打印所有session内容
@ApiOperation("查看session中存储的shiro信息")
@RequestMapping(value="/show",method = RequestMethod.GET)
public String show(HttpSession session) {
// 获取session中所有的键值
Enumeration<?> enumeration = session.getAttributeNames();
// 遍历enumeration中的
while (enumeration.hasMoreElements()) {
// 获取session键值
String name = enumeration.nextElement().toString();
// 根据键值取session中的值
Object value = session.getAttribute(name);
// 打印结果
System.out.println("<B>" + name + "</B>=" + value + "<br>/n");
}
return "查看session成功";
}
如果是分布式分布式系统或者微服务架构，简单的web session域已经不能实现功能，都是通过统一的认证中心尽显用户认证。如果使用默认的会话管理，用户信息只会保存到一台服务器上。那么其他的服务器就要进行会话同步。
会话管理器可以指定sessionId的生成以及获取方式。
通过sessionDao完成模拟session存入，取出等操作
Shiro结合redis的统一会话管理
1.流程分析：
2. 整合redis：
<dependency>
<groupId>org.crazycake</groupId>
<artifactId>shiro-redis</artifactId>
<version>3.0.0</version>
</dependency>3. 在springboot配置文件中添加redis配置
4.自定义shiro会话管理器
import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.util.StringUtils;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;
/**
* @author YJC
* @e-mail xiaochun235@qq.com
* @Date 2022/12/12 22:58
* @notes 自定义 Manager
*/
public class CustomSessionManager extends DefaultWebSessionManager {
/**
* 头信息中具有sessionId
* 请求头：Authorization: sessionid
*
*
* 指定sessionId的一个方法
*/
protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
//获取请求头中的信息
String sessionId = WebUtils.toHttp(request).getHeader("Authorization");
if (StringUtils.isEmpty(sessionId)){
// 如果没有携带，生成新的session
return super.getSessionId(request,response);
}else {
// 返回 sessionId
// 将 sessionId 放到请求头中
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
// 当前 sessionid 具体是什么
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, sessionId);
//该sessionId是否需要验证
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
return sessionId;
}
}
}5.总配置
package cn.itcast.shiro;
import cn.itcast.shiro.reaml.CustomReaml;
import cn.itcast.shiro.session.CustomSessionManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
/**
* @author YJC
* @e-mail xiaochun235@qq.com
* @Date 2022/12/8 20:34
* @notes shiro 配置
*/
@Configuration
public class ShiroConfig {
// 1、创建 realm
@Bean
public CustomReaml getRealm(){
return new CustomReaml(); //CustomReaml ==》自定义 customReaml
}
// 2、创建安全管理器
@Bean
public SecurityManager securityManager(CustomReaml reaml){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(reaml);
//redis 将自定义的会话管理器注册到安全管理器中
securityManager.setSessionManager(sessionManager());
// redis 将自定义的 redis 缓存管理器注册到安全管理器中
securityManager.setCacheManager(cacheManager());
return securityManager;
}
// 3、配置 shiro 的过滤器工厂
/**
* 在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
* @param securityManager
* @return
*/
@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
// 1、创建过滤器工厂
ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
// 2、设置安全管理器
filterFactory.setSecurityManager(securityManager);
// 3、通过配置（跳转登陆页面，为授权跳转的页面）
filterFactory.setLoginUrl("/longinerror");// 跳转到url 路径 （没有登陆跳转）
filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
// 4、设置过滤器集合
/**
* 设置所有的过滤器：map
* key=拦截的 url 地址
* value=过滤器类型
* 可以选择有序的 map 集合==》LinkedHashMap
*/
Map<String,String> filterMap = new LinkedHashMap<>();
// 不需要登录 即可访问
//当前请求地址可以匿名访问
filterMap.put("/user/home","anon");
// 当前请求地址可以匿名访问 swagger 访问地址开放地址
filterMap.put("/doc.htm**","anon");
filterMap.put("/webjars/**","anon");
filterMap.put("/swagger**","anon");
filterMap.put("/v2/**","anon");
// 登陆接口
filterMap.put("/login","anon");
// 当前请求地址必须认证之后才可以访问 需要登录才能访问
filterMap.put("/user**","authc");
filterMap.put("/test","authc");
// 使用 过滤器 的形式来配置 权限
// 需要当前用户 拥有 该角色 才能访问 role.getName() 在 realm 中的授权存入内容的
// filterMap.put("/user/list","roles[系统管理员]");
// 需要有权限才能访问
// 具有 某种权限才能访问 查询用户 当有 user-find 该权限才能访问该接口
// 也可以使用 注解的形式来配置 权限 user-find ==》为 permission.getCode() 在 realm 中的授权存入内容的
// filterMap.put("/user/list","perms[user-list]");// 如果不具有这个权限则就跳转到 setUnauthorizedUrl 改接口
filterFactory.setFilterChainDefinitionMap(filterMap);
return filterFactory;
}
// 获取redis 配置
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.password}")
private String password;
/**
*1、redis 配置 控制器
*/
public RedisManager redisManager(){
RedisManager redisManager = new RedisManager();
redisManager.setPort(port);
redisManager.setHost(host);
redisManager.setPassword(password);
return redisManager;
}
/**
* 2、redis SessionDao
* @return
*/
public RedisSessionDAO redisSessionDAO(){
RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
redisSessionDAO.setRedisManager(redisManager());
return redisSessionDAO;
}
/**
* 3、redis 配置自定义会话管理器
* @return
*/
public DefaultWebSessionManager sessionManager(){
CustomSessionManager customSessionManager = new CustomSessionManager();
customSessionManager.setSessionDAO(redisSessionDAO());
// 禁用 cookie (可写)
customSessionManager.setSessionIdCookieEnabled(false);
// 禁用 url 重写 url;jsessionid=id (可写)
customSessionManager.setSessionIdUrlRewritingEnabled(false);
return customSessionManager;
}
/**
* 4、Redis 缓存管理器
* @return
*/
public RedisCacheManager cacheManager(){
RedisCacheManager redisCacheManager = new RedisCacheManager();
redisCacheManager.setRedisManager(redisManager());
return redisCacheManager;
}
// 4、开启shiro 注解的支持
//配置shiro注解支持
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
}
![[docker] Docker的数据卷、数据卷容器，容器互联](https://img-blog.csdnimg.cn/direct/949eb2609ca342ea83b4b33353918954.png)
