前言
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
{@Autowiredprivate ISysUserService userService;@Autowiredprivate 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);@Autowiredprivate ISysMenuService menuService;@Autowiredprivate ISysRoleService roleService;@Autowiredprivate SysLoginService loginService;/*** 授权*/@Overrideprotected 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;}/*** 登录认证*/@Overrideprotected 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、获取subjectSubject 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 {@Overridepublic void setName(String name) {super.setName("customReaml");// 名称一般用类名,也可以自定义}// 进行数据库查询@Autowiredprivate UserService userService;/*** 授权:* 操作时,判断用户是否具有相应的权限* 先认证 -- 安全数据* 在授权 -- 根据安全数据获取用户具有的所有操作权限*** @param principalCollection* @return*/@Overrideprotected 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*/@Overrideprotected 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@Beanpublic CustomReaml getRealm(){return new CustomReaml(); //CustomReaml ==》自定义 customReaml}// 2、创建安全管理器@Beanpublic SecurityManager securityManager(CustomReaml reaml){DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();securityManager.setRealm(reaml);return securityManager;}// 3、配置 shiro 的过滤器工厂/*** 在 web 程序中,shiro 进行权限控制全部是通过一组过滤器集合进行控制* @param securityManager* @return*/@Beanpublic 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注解支持@Beanpublic 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实现*/@Beanpublic 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*/@Beanpublic UserRealm userRealm(EhCacheManager cacheManager){UserRealm userRealm = new UserRealm();userRealm.setAuthorizationCacheName(Constants.SYS_AUTH_CACHE);userRealm.setCacheManager(cacheManager);return userRealm;}/*** 自定义sessionDAO会话*/@Beanpublic OnlineSessionDAO sessionDAO(){OnlineSessionDAO sessionDAO = new OnlineSessionDAO();return sessionDAO;}/*** 自定义sessionFactory会话*/@Beanpublic OnlineSessionFactory sessionFactory(){OnlineSessionFactory sessionFactory = new OnlineSessionFactory();return sessionFactory;}/*** 会话管理器*/@Beanpublic OnlineWebSessionManager sessionManager(){OnlineWebSessionManager manager = new OnlineWebSessionManager();// 加入缓存管理器manager.setCacheManager(getEhCacheManager());// 删除过期的sessionmanager.setDeleteInvalidSessions(true);// 设置全局session超时时间manager.setGlobalSessionTimeout(expireTime * 60 * 1000);// 去掉 JSESSIONIDmanager.setSessionIdUrlRewritingEnabled(false);// 定义要使用的无效的Session定时调度器manager.setSessionValidationScheduler(SpringUtils.getBean(SpringSessionValidationScheduler.class));// 是否定时检查sessionmanager.setSessionValidationSchedulerEnabled(true);// 自定义SessionDaomanager.setSessionDAO(sessionDAO());// 自定义sessionFactorymanager.setSessionFactory(sessionFactory());return manager;}/*** 安全管理器*/@Beanpublic 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过滤器配置*/@Beanpublic 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去清除sessionfilterChainDefinitionMap.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框架的整合*/@Beanpublic ShiroDialect shiroDialect(){return new ShiroDialect();}/*** 开启Shiro注解通知器*/@Beanpublic 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@Beanpublic CustomReaml getRealm(){return new CustomReaml(); //CustomReaml ==》自定义 customReaml}// 2、创建安全管理器@Beanpublic SecurityManager securityManager(CustomReaml reaml){DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();securityManager.setRealm(reaml);return securityManager;}// 3、配置 shiro 的过滤器工厂/*** 在 web 程序中,shiro 进行权限控制全部是通过一组过滤器集合进行控制* @param securityManager* @return*/@Beanpublic 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注解支持@Beanpublic 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)){// 如果没有携带,生成新的sessionreturn 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@Beanpublic CustomReaml getRealm(){return new CustomReaml(); //CustomReaml ==》自定义 customReaml}// 2、创建安全管理器@Beanpublic 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*/@Beanpublic 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注解支持@Beanpublic AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();advisor.setSecurityManager(securityManager);return advisor;}}