SpringBoot集成Shiro 实现动态加载权限

Bertha 。 2023-08-17 16:57 144阅读 0赞

### 一、前言 ###

本文小编将基于 **SpringBoot** 集成 **Shiro** 实现动态uri权限，由前端vue在页面配置uri，Java后端动态刷新权限，不用重启项目，以及在页面分配给用户 **角色** 、 **按钮** 、**uri** 权限后，后端动态分配权限，用户无需在页面重新登录才能获取最新权限，一切权限动态加载，灵活配置

##### 基本环境 #####

1.  spring-boot 2.1.7
2.  mybatis-plus 2.1.0
3.  mysql 5.7.24
4.  redis 5.0.5

> **温馨小提示**：案例demo源码附文章末尾，有需要的小伙伴们可参考哦 ~

### 二、SpringBoot集成Shiro ###

#### 1、引入相关maven依赖 ####

<properties>
        <shiro-spring.version>1.4.0</shiro-spring.version>
        <shiro-redis.version>3.1.0</shiro-redis.version>
    </properties>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>${shiro-spring.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>${shiro-redis.version}</version>
        </dependency>
    </dependencies>

#### 2、自定义Realm ####

1.  `doGetAuthenticationInfo`：身份认证 （主要是在登录时的逻辑处理）
2.  `doGetAuthorizationInfo`：登陆认证成功后的处理 ex: 赋予角色和权限  
    `【 注：用户进行权限验证时 Shiro会去缓存中找,如果查不到数据,会执行doGetAuthorizationInfo这个方法去查权限,并放入缓存中 】` \-> 因此我们在前端页面分配用户权限时 执行清除shiro缓存的方法即可实现动态分配用户权限

@Slf4j
    public class ShiroRealm extends AuthorizingRealm {
    
        @Autowired
        private UserMapper userMapper;
        @Autowired
        private MenuMapper menuMapper;
        @Autowired
        private RoleMapper roleMapper;
    
        @Override
        public String getName() {
            return "shiroRealm";
        }
    
        /**
         * 赋予角色和权限:用户进行权限验证时 Shiro会去缓存中找,如果查不到数据,会执行这个方法去查权限,并放入缓存中
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
            // 获取用户
            User user = (User) principalCollection.getPrimaryPrincipal();
            Integer userId =user.getId();
            // 这里可以进行授权和处理
            Set<String> rolesSet = new HashSet<>();
            Set<String> permsSet = new HashSet<>();
            // 获取当前用户对应的权限(这里根据业务自行查询)
            List<Role> roleList = roleMapper.selectRoleByUserId( userId );
            for (Role role:roleList) {
                rolesSet.add( role.getCode() );
                List<Menu> menuList = menuMapper.selectMenuByRoleId( role.getId() );
                for (Menu menu :menuList) {
                    permsSet.add( menu.getResources() );
                }
            }
            //将查到的权限和角色分别传入authorizationInfo中
            authorizationInfo.setStringPermissions(permsSet);
            authorizationInfo.setRoles(rolesSet);
            log.info("--------------- 赋予角色和权限成功！ ---------------");
            return authorizationInfo;
        }
    
        /**
         * 身份认证 - 之后走上面的 授权
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
            UsernamePasswordToken tokenInfo = (UsernamePasswordToken)authenticationToken;
            // 获取用户输入的账号
            String username = tokenInfo.getUsername();
            // 获取用户输入的密码
            String password = String.valueOf( tokenInfo.getPassword() );
    
            // 通过username从数据库中查找 User对象，如果找到进行验证
            // 实际项目中,这里可以根据实际情况做缓存,如果不做,Shiro自己也是有时间间隔机制,2分钟内不会重复执行该方法
            User user = userMapper.selectUserByUsername(username);
            // 判断账号是否存在
            if (user == null) {
                //返回null -> shiro就会知道这是用户不存在的异常
                return null;
            }
            // 验证密码 【注：这里不采用shiro自身密码验证 ， 采用的话会导致用户登录密码错误时，已登录的账号也会自动下线！  如果采用，移除下面的清除缓存到登录处 处理】
            if ( !password.equals( user.getPwd() ) ){
                throw new IncorrectCredentialsException("用户名或者密码错误");
            }
    
            // 判断账号是否被冻结
            if (user.getFlag()==null|| "0".equals(user.getFlag())){
                throw new LockedAccountException();
            }
            /**
             * 进行验证 -> 注：shiro会自动验证密码
             * 参数1：principal -> 放对象就可以在页面任意地方拿到该对象里面的值
             * 参数2：hashedCredentials -> 密码
             * 参数3：credentialsSalt -> 设置盐值
             * 参数4：realmName -> 自定义的Realm
             */
            SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), getName());
            // 验证成功开始踢人(清除缓存和Session)
            ShiroUtils.deleteCache(username,true);
    
            // 认证成功后更新token
            String token = ShiroUtils.getSession().getId().toString();
            user.setToken( token );
            userMapper.updateById(user);
            return authenticationInfo;
        }
    
    }

#### 3、Shiro配置类 ####

@Configuration
    public class ShiroConfig {
    
        private final String CACHE_KEY = "shiro:cache:";
        private final String SESSION_KEY = "shiro:session:";
        /**
         * 默认过期时间30分钟，即在30分钟内不进行操作则清空缓存信息，页面即会提醒重新登录
         */
        private final int EXPIRE = 1800;
    
        /**
         *  Redis配置
         */
        @Value("${spring.redis.host}")
        private String host;
        @Value("${spring.redis.port}")
        private int port;
        @Value("${spring.redis.timeout}")
        private int timeout;
    //    @Value("${spring.redis.password}")
    //    private String password;
    
        /**
         * 开启Shiro-aop注解支持：使用代理方式所以需要开启代码支持
         */
        @Bean
        public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
            AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
            authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
            return authorizationAttributeSourceAdvisor;
        }
    
        /**
         * Shiro基础配置
         */
        @Bean
        public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager, ShiroServiceImpl shiroConfig){
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager(securityManager);
    
            // 自定义过滤器
            Map<String, Filter> filtersMap = new LinkedHashMap<>();
            // 定义过滤器名称 【注：map里面key值对于的value要为authc才能使用自定义的过滤器】
            filtersMap.put( "zqPerms", new MyPermissionsAuthorizationFilter() );
            filtersMap.put( "zqRoles", new MyRolesAuthorizationFilter() );
            filtersMap.put( "token", new TokenCheckFilter() );
            shiroFilterFactoryBean.setFilters(filtersMap);
    
            // 登录的路径: 如果你没有登录则会跳到这个页面中 - 如果没有设置值则会默认跳转到工程根目录下的"/login.jsp"页面 或 "/login" 映射
            shiroFilterFactoryBean.setLoginUrl("/api/auth/unLogin");
            // 登录成功后跳转的主页面 （这里没用，前端vue控制了跳转）
    //        shiroFilterFactoryBean.setSuccessUrl("/index");
            // 设置没有权限时跳转的url
            shiroFilterFactoryBean.setUnauthorizedUrl("/api/auth/unauth");
    
            shiroFilterFactoryBean.setFilterChainDefinitionMap( shiroConfig.loadFilterChainDefinitionMap() );
            return shiroFilterFactoryBean;
        }
    
        /**
         * 安全管理器
         */
        @Bean
        public SecurityManager securityManager() {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            // 自定义session管理
            securityManager.setSessionManager(sessionManager());
            // 自定义Cache实现缓存管理
            securityManager.setCacheManager(cacheManager());
            // 自定义Realm验证
            securityManager.setRealm(shiroRealm());
            return securityManager;
        }
    
        /**
         * 身份验证器
         */
        @Bean
        public ShiroRealm shiroRealm() {
            ShiroRealm shiroRealm = new ShiroRealm();
            shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
            return shiroRealm;
        }
    
        /**
         *  自定义Realm的加密规则 -> 凭证匹配器：将密码校验交给Shiro的SimpleAuthenticationInfo进行处理,在这里做匹配配置
         */
        @Bean
        public HashedCredentialsMatcher hashedCredentialsMatcher() {
            HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
            // 散列算法:这里使用SHA256算法;
            shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
            // 散列的次数，比如散列两次，相当于 md5(md5(""));
            shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
            return shaCredentialsMatcher;
        }
    
        /**
         * 配置Redis管理器：使用的是shiro-redis开源插件
         */
        @Bean
        public RedisManager redisManager() {
            RedisManager redisManager = new RedisManager();
            redisManager.setHost(host);
            redisManager.setPort(port);
            redisManager.setTimeout(timeout);
    //        redisManager.setPassword(password);
            return redisManager;
        }
    
        /**
         * 配置Cache管理器：用于往Redis存储权限和角色标识  (使用的是shiro-redis开源插件)
         */
        @Bean
        public RedisCacheManager cacheManager() {
            RedisCacheManager redisCacheManager = new RedisCacheManager();
            redisCacheManager.setRedisManager(redisManager());
            redisCacheManager.setKeyPrefix(CACHE_KEY);
            // 配置缓存的话要求放在session里面的实体类必须有个id标识 注：这里id为用户表中的主键，否-> 报：User must has getter for field: xx
            redisCacheManager.setPrincipalIdFieldName("id");
            return redisCacheManager;
        }
    
        /**
         * SessionID生成器
         */
        @Bean
        public ShiroSessionIdGenerator sessionIdGenerator(){
            return new ShiroSessionIdGenerator();
        }
    
        /**
         * 配置RedisSessionDAO (使用的是shiro-redis开源插件)
         */
        @Bean
        public RedisSessionDAO redisSessionDAO() {
            RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
            redisSessionDAO.setRedisManager(redisManager());
            redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
            redisSessionDAO.setKeyPrefix(SESSION_KEY);
            redisSessionDAO.setExpire(EXPIRE);
            return redisSessionDAO;
        }
    
        /**
         * 配置Session管理器
         */
        @Bean
        public SessionManager sessionManager() {
            ShiroSessionManager shiroSessionManager = new ShiroSessionManager();
            shiroSessionManager.setSessionDAO(redisSessionDAO());
            return shiroSessionManager;
        }
    
    }

### 三、shiro动态加载权限处理方法 ###

1.  `loadFilterChainDefinitionMap`：初始化权限  
    ex: 在上面Shiro配置类`ShiroConfig`中的Shiro基础配置`shiroFilterFactory`方法中我们就需要调用此方法将数据库中配置的所有uri权限全部加载进去，以及放行接口和配置权限过滤器等  
    `【注：过滤器配置顺序不能颠倒，多个过滤器用`,`分割】`  
    ex: `filterChainDefinitionMap.put("/api/system/user/list", "authc,token,zqPerms[user1]")`
2.  `updatePermission`：动态刷新加载数据库中的uri权限 -> 页面在新增uri路径到数据库中，也就是配置新的权限时就可以调用此方法实现动态加载uri权限
3.  `updatePermissionByRoleId`：shiro动态权限加载 -> 即分配指定用户权限时可调用此方法删除shiro缓存，重新执行`doGetAuthorizationInfo`方法授权角色和权限

public interface ShiroService {
    
        /**
         * 初始化权限 -> 拿全部权限
         *
         * @param :
         * @return: java.util.Map<java.lang.String,java.lang.String>
         */
        Map<String, String> loadFilterChainDefinitionMap();
    
        /**
         * 在对uri权限进行增删改操作时，需要调用此方法进行动态刷新加载数据库中的uri权限
         *
         * @param shiroFilterFactoryBean
         * @param roleId
         * @param isRemoveSession:
         * @return: void
         */
        void updatePermission(ShiroFilterFactoryBean shiroFilterFactoryBean, Integer roleId, Boolean isRemoveSession);
    
        /**
         * shiro动态权限加载 -> 原理：删除shiro缓存，重新执行doGetAuthorizationInfo方法授权角色和权限
         *
         * @param roleId
         * @param isRemoveSession:
         * @return: void
         */
        void updatePermissionByRoleId(Integer roleId, Boolean isRemoveSession);
    
    }

@Slf4j
    @Service
    public class ShiroServiceImpl implements ShiroService {
    
        @Autowired
        private MenuMapper menuMapper;
        @Autowired
        private UserMapper userMapper;
        @Autowired
        private RoleMapper roleMapper;
    
        @Override
        public Map<String, String> loadFilterChainDefinitionMap() {
            // 权限控制map
            Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
            // 配置过滤:不会被拦截的链接 -> 放行 start ----------------------------------------------------------
            // 放行Swagger2页面，需要放行这些
            filterChainDefinitionMap.put("/swagger-ui.html","anon");
            filterChainDefinitionMap.put("/swagger/**","anon");
            filterChainDefinitionMap.put("/webjars/**", "anon");
            filterChainDefinitionMap.put("/swagger-resources/**","anon");
            filterChainDefinitionMap.put("/v2/**","anon");
            filterChainDefinitionMap.put("/static/**", "anon");
    
            // 登陆
            filterChainDefinitionMap.put("/api/auth/login/**", "anon");
            // 三方登录
            filterChainDefinitionMap.put("/api/auth/loginByQQ", "anon");
            filterChainDefinitionMap.put("/api/auth/afterlogin.do", "anon");
            // 退出
            filterChainDefinitionMap.put("/api/auth/logout", "anon");
            // 放行未授权接口，重定向使用
            filterChainDefinitionMap.put("/api/auth/unauth", "anon");
            // token过期接口
            filterChainDefinitionMap.put("/api/auth/tokenExpired", "anon");
            // 被挤下线
            filterChainDefinitionMap.put("/api/auth/downline", "anon");
            // 放行 end ----------------------------------------------------------
    
            // 从数据库或缓存中查取出来的url与resources对应则不会被拦截 放行
            List<Menu> permissionList = menuMapper.selectList( null );
            if ( !CollectionUtils.isEmpty( permissionList ) ) {
                permissionList.forEach( e -> {
                    if ( StringUtils.isNotBlank( e.getUrl() ) ) {
                        // 根据url查询相关联的角色名,拼接自定义的角色权限
                        List<Role> roleList = roleMapper.selectRoleByMenuId( e.getId() );
                        StringJoiner zqRoles = new StringJoiner(",", "zqRoles[", "]");
                        if ( !CollectionUtils.isEmpty( roleList ) ){
                            roleList.forEach( f -> {
                                zqRoles.add( f.getCode() );
                            });
                        }
    
                        // 注意过滤器配置顺序不能颠倒
                        // ① 认证登录
                        // ② 认证自定义的token过滤器 - 判断token是否有效
                        // ③ 角色权限 zqRoles：自定义的只需要满足其中一个角色即可访问  ;  roles[admin,guest] : 默认需要每个参数满足才算通过，相当于hasAllRoles()方法
                        // ④ zqPerms:认证自定义的url过滤器拦截权限  【注：多个过滤器用 , 分割】
    //                    filterChainDefinitionMap.put( "/api" + e.getUrl(),"authc,token,roles[admin,guest],zqPerms[" + e.getResources() + "]" );
                        filterChainDefinitionMap.put( "/api" + e.getUrl(),"authc,token,"+ zqRoles.toString() +",zqPerms[" + e.getResources() + "]" );
    //                        filterChainDefinitionMap.put("/api/system/user/listPage", "authc,token,zqPerms[user1]"); // 写死的一种用法
                    }
                });
            }
            // ⑤ 认证登录  【注：map不能存放相同key】
            filterChainDefinitionMap.put("/**", "authc");
            return filterChainDefinitionMap;
        }
    
        @Override
        public void updatePermission(ShiroFilterFactoryBean shiroFilterFactoryBean, Integer roleId, Boolean isRemoveSession) {
            synchronized (this) {
                AbstractShiroFilter shiroFilter;
                try {
                    shiroFilter = (AbstractShiroFilter) shiroFilterFactoryBean.getObject();
                } catch (Exception e) {
                    throw new MyException("get ShiroFilter from shiroFilterFactoryBean error!");
                }
                PathMatchingFilterChainResolver filterChainResolver = (PathMatchingFilterChainResolver) shiroFilter.getFilterChainResolver();
                DefaultFilterChainManager manager = (DefaultFilterChainManager) filterChainResolver.getFilterChainManager();
    
                // 清空拦截管理器中的存储
                manager.getFilterChains().clear();
                // 清空拦截工厂中的存储,如果不清空这里,还会把之前的带进去
                //            ps:如果仅仅是更新的话,可以根据这里的 map 遍历数据修改,重新整理好权限再一起添加
                shiroFilterFactoryBean.getFilterChainDefinitionMap().clear();
                // 动态查询数据库中所有权限
                shiroFilterFactoryBean.setFilterChainDefinitionMap(loadFilterChainDefinitionMap());
                // 重新构建生成拦截
                Map<String, String> chains = shiroFilterFactoryBean.getFilterChainDefinitionMap();
                for (Map.Entry<String, String> entry : chains.entrySet()) {
                    manager.createChain(entry.getKey(), entry.getValue());
                }
                log.info("--------------- 动态生成url权限成功！ ---------------");
    
                // 动态更新该角色相关联的用户shiro权限
                if(roleId != null){
                    updatePermissionByRoleId(roleId,isRemoveSession);
                }
            }
        }
    
        @Override
        public void updatePermissionByRoleId(Integer roleId, Boolean isRemoveSession) {
            // 查询当前角色的用户shiro缓存信息 -> 实现动态权限
            List<User> userList = userMapper.selectUserByRoleId(roleId);
            // 删除当前角色关联的用户缓存信息,用户再次访问接口时会重新授权 ; isRemoveSession为true时删除Session -> 即强制用户退出
            if ( !CollectionUtils.isEmpty( userList ) ) {
                for (User user : userList) {
                    ShiroUtils.deleteCache(user.getUsername(), isRemoveSession);
                }
            }
            log.info("--------------- 动态修改用户权限成功！ ---------------");
        }
    
    }

### 四、shiro中自定义角色、权限过滤器 ###

#### 1、自定义uri权限过滤器 `zqPerms` ####

@Slf4j
    public class MyPermissionsAuthorizationFilter extends PermissionsAuthorizationFilter {
    
        @Override
        protected boolean onAccessDenied(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            String requestUrl = httpRequest.getServletPath();
            log.info("请求的url:  " + requestUrl);
    
            // 检查是否拥有访问权限
            Subject subject = this.getSubject(request, response);
            if (subject.getPrincipal() == null) {
                this.saveRequestAndRedirectToLogin(request, response);
            } else {
                // 转换成http的请求和响应
                HttpServletRequest req = (HttpServletRequest) request;
                HttpServletResponse resp = (HttpServletResponse) response;
    
                // 获取请求头的值
                String header = req.getHeader("X-Requested-With");
                // ajax 的请求头里有X-Requested-With: XMLHttpRequest      正常请求没有
                if (header!=null && "XMLHttpRequest".equals(header)){
                    resp.setContentType("text/json,charset=UTF-8");
                    resp.getWriter().print("{\"success\":false,\"msg\":\"没有权限操作！\"}");
                }else {  //正常请求
                    String unauthorizedUrl = this.getUnauthorizedUrl();
                    if (StringUtils.hasText(unauthorizedUrl)) {
                        WebUtils.issueRedirect(request, response, unauthorizedUrl);
                    } else {
                        WebUtils.toHttp(response).sendError(401);
                    }
                }
    
            }
            return false;
        }
        
    }

#### 2、自定义角色权限过滤器 `zqRoles` ####

shiro原生的角色过滤器RolesAuthorizationFilter 默认是必须同时满足`roles[admin,guest]`才有权限，而自定义的`zqRoles` 只满足其中一个即可访问  
ex: `zqRoles[admin,guest]`

public class MyRolesAuthorizationFilter extends AuthorizationFilter {
    
        @Override
        protected boolean isAccessAllowed(ServletRequest req, ServletResponse resp, Object mappedValue) throws Exception {
            Subject subject = getSubject(req, resp);
            String[] rolesArray = (String[]) mappedValue;
            // 没有角色限制，有权限访问
            if (rolesArray == null || rolesArray.length == 0) {
                return true;
            }
            for (int i = 0; i < rolesArray.length; i++) {
                //若当前用户是rolesArray中的任何一个，则有权限访问
                if (subject.hasRole(rolesArray[i])) {
                    return true;
                }
            }
            return false;
        }
    
    }

#### 3、自定义token过滤器 `token` \-> 判断token是否过期失效等 ####

@Slf4j
    public class TokenCheckFilter extends UserFilter {
    
        /**
         * token过期、失效
         */
        private static final String TOKEN_EXPIRED_URL = "/api/auth/tokenExpired";
    
        /**
         * 判断是否拥有权限 true:认证成功  false:认证失败
         * mappedValue 访问该url时需要的权限
         * subject.isPermitted 判断访问的用户是否拥有mappedValue权限
         */
        @Override
        public boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            // 根据请求头拿到token
            String token = WebUtils.toHttp(request).getHeader(Constants.REQUEST_HEADER);
            log.info("浏览器token：" + token );
            User userInfo = ShiroUtils.getUserInfo();
            String userToken = userInfo.getToken();
            // 检查token是否过期
            if ( !token.equals(userToken) ){
                return false;
            }
            return true;
        }
    
        /**
         * 认证失败回调的方法: 如果登录实体为null就保存请求和跳转登录页面,否则就跳转无权限配置页面
         */
        @Override
        protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
            User userInfo = ShiroUtils.getUserInfo();
            // 重定向错误提示处理 - 前后端分离情况下
            WebUtils.issueRedirect(request, response, TOKEN_EXPIRED_URL);
            return false;
        }
    
    }

### 五、项目中会用到的一些工具类、常量等 ###

> **温馨小提示**：这里只是部分，详情可参考文章末尾给出的案例demo源码

#### 1、Shiro工具类 ####

public class ShiroUtils {
    
        /** 私有构造器 **/
        private ShiroUtils(){ }
    
        private static RedisSessionDAO redisSessionDAO = SpringUtil.getBean(RedisSessionDAO.class);
    
        /**
         * 获取当前用户Session
         * @Return SysUserEntity 用户信息
         */
        public static Session getSession() {
            return SecurityUtils.getSubject().getSession();
        }
    
        /**
         * 用户登出
         */
        public static void logout() {
            SecurityUtils.getSubject().logout();
        }
    
        /**
         * 获取当前用户信息
         * @Return SysUserEntity 用户信息
         */
        public static User getUserInfo() {
            return (User) SecurityUtils.getSubject().getPrincipal();
        }
    
        /**
         * 删除用户缓存信息
         * @Param  username  用户名称
         * @Param  isRemoveSession 是否删除Session，删除后用户需重新登录
         */
        public static void deleteCache(String username, boolean isRemoveSession){
            //从缓存中获取Session
            Session session = null;
            // 获取当前已登录的用户session列表
            Collection<Session> sessions = redisSessionDAO.getActiveSessions();
            User sysUserEntity;
            Object attribute = null;
            // 遍历Session,找到该用户名称对应的Session
            for(Session sessionInfo : sessions){
                attribute = sessionInfo.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
                if (attribute == null) {
                    continue;
                }
                sysUserEntity = (User) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
                if (sysUserEntity == null) {
                    continue;
                }
                if (Objects.equals(sysUserEntity.getUsername(), username)) {
                    session=sessionInfo;
                    // 清除该用户以前登录时保存的session，强制退出  -> 单用户登录处理
                    if (isRemoveSession) {
                        redisSessionDAO.delete(session);
                    }
                }
            }
    
            if (session == null||attribute == null) {
                return;
            }
            //删除session
            if (isRemoveSession) {
                redisSessionDAO.delete(session);
            }
            //删除Cache，再访问受限接口时会重新授权
            DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager) SecurityUtils.getSecurityManager();
            Authenticator authc = securityManager.getAuthenticator();
            ((LogoutAware) authc).onLogout((SimplePrincipalCollection) attribute);
        }
    
        /**
         * 从缓存中获取指定用户名的Session
         * @param username
         */
        private static Session getSessionByUsername(String username){
            // 获取当前已登录的用户session列表
            Collection<Session> sessions = redisSessionDAO.getActiveSessions();
            User user;
            Object attribute;
            // 遍历Session,找到该用户名称对应的Session
            for(Session session : sessions){
                attribute = session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
                if (attribute == null) {
                    continue;
                }
                user = (User) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
                if (user == null) {
                    continue;
                }
                if (Objects.equals(user.getUsername(), username)) {
                    return session;
                }
            }
            return null;
        }
    
    }

#### 2、Redis常量类 ####

public interface RedisConstant {
        /**
         * TOKEN前缀
         */
        String REDIS_PREFIX_LOGIN = "code-generator_token_%s";
    }

#### 3、Spring上下文工具类 ####

@Component
    public class SpringUtil implements ApplicationContextAware {
        private static ApplicationContext context;
        /**
         * Spring在bean初始化后会判断是不是ApplicationContextAware的子类
         * 如果该类是,setApplicationContext()方法,会将容器中ApplicationContext作为参数传入进去
         */
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            context = applicationContext;
        }
        /**
         * 通过Name返回指定的Bean
         */
        public static <T> T getBean(Class<T> beanClass) {
            return context.getBean(beanClass);
        }
    }

### 六、案例demo源码 ###

###### [GitHub地址][GitHub] ######

> https://github.com/zhengqingya/code-generator/tree/master/code-generator-api/src/main/java/com/zhengqing/modules/shiro

###### [码云地址][Link 1] ######

> https://gitee.com/zhengqingya/code-generator/blob/master/code-generator-api/src/main/java/com/zhengqing/modules/shiro

转载于:https://www.cnblogs.com/zhengqing/p/11603824.html

[GitHub]: https://github.com/zhengqingya/code-generator/tree/master/code-generator-api/src/main/java/com/zhengqing/modules/shiro
[Link 1]: https://gitee.com/zhengqingya/code-generator/blob/master/code-generator-api/src/main/java/com/zhengqing/modules/shiro