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

一、前言

本文小编将基于 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>
    <!-- AOP 依赖, 一定要加, 否则权限拦截验证不生效【注：系统日记也需要此依赖】-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
    </dependency>
    <!-- Shiro 核心依赖 -->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring</artifactId>
        <version>${shiro-spring.version}</version>
    </dependency>
    <!-- Shiro-redis 插件 -->
    <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]")

   1. updatePermission：动态刷新加载数据库中的 uri 权限 -> 页面在新增 uri 路径到数据库中，也就是配置新的权限时就可以调用此方法实现动态加载 uri 权限
   2. 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 地址

https://github.com/zhengqingy…

码云地址

https://gitee.com/zhengqingya…