自定义Realm

doGetAuthenticationInfo
身份验证，主要是在登录时的逻辑处理。
doGetAuthorizationInfo
登录认证成功后，赋予用户角色与权限。
用户进行权限验证时，shiro会去缓存中找，如果查不到数据，会执行 doGetAuthorizationInfo 这个方法去查权限，并放入缓存中。

Shiro配置类

基础配置

自定义过滤器，并存入 filterMap 

  1. // 自定义过滤器
  2. Map<String, Filter> filtersMap = new LinkedHashMap<>();
  3. // 定义过滤器名称 【注：map里面key值对于的value要为authc才能使用自定义的过滤器】
  4. filtersMap.put( "zqPerms", new MyPermissionsAuthorizationFilter() );
  5. filtersMap.put( "zqRoles", new MyRolesAuthorizationFilter() );
  6. filtersMap.put( "token", new TokenCheckFilter() );
  7. shiroFilterFactoryBean.setFilters(filtersMap);

身份验证器

新建自定义Realm对象，并通过 @Bean 注入Spring容器，交由Spring容器管理。

  1. /**
  2. * 身份验证器
  3. */
  4. @Bean
  5. public ShiroRealm shiroRealm() {
  6.     ShiroRealm shiroRealm = new ShiroRealm();
  7.     shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
  8.     return shiroRealm;
  9. }

安全管理器

自定义session管理、自定义Cache管理、自定义Realm验证

  1. /**
  2. * 安全管理器
  3. */
  4. @Bean
  5. public SecurityManager securityManager() {
  6.     DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  7.     // 自定义session管理
  8.     securityManager.setSessionManager(sessionManager());
  9.     // 自定义Cache实现缓存管理
  10.     securityManager.setCacheManager(cacheManager());
  11.     // 自定义Realm验证
  12.     securityManager.setRealm(shiroRealm());
  13.     return securityManager;
  14. }

自定义Realm加密规则

  1. /**
  2. *  自定义Realm的加密规则 -> 
  3. *  凭证匹配器：将密码校验交给Shiro的SimpleAuthenticationInfo进行处理,在这里做匹配配置
  4. */
  5. @Bean
  6. public HashedCredentialsMatcher hashedCredentialsMatcher() {
  7.     HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
  8.     // 散列算法:这里使用SHA256算法;
  9.     shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
  10.     // 散列的次数，比如散列两次，相当于 md5(md5(""));
  11.     shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
  12.     return shaCredentialsMatcher;
  13. }

完整代码

  1. @Configuration
  2. public class ShiroConfig {
  4.     private final String CACHE_KEY = "shiro:cache:";
  5.     private final String SESSION_KEY = "shiro:session:";
  6.     /**
  7.      * 默认过期时间30分钟，即在30分钟内不进行操作则清空缓存信息，页面即会提醒重新登录
  8.      */
  9.     private final int EXPIRE = 1800;
  11.     /**
  12.      *  Redis配置
  13.      */
  14.     @Value("${redis.host}")
  15.     private String host;
  16.     @Value("${redis.port}")
  17.     private int port;
  18.     @Value("${redis.password}")
  19.     private String password;
  21.     /**
  22.      * 开启Shiro-aop注解支持：使用代理方式所以需要开启代码支持
  23.      */
  24.     @Bean
  25.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
  26.         AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
  27.         authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
  28.         return authorizationAttributeSourceAdvisor;
  29.     }
  31.     /**
  32.      * Shiro生命周期处理器
  33.      * 此方法需要用static作为修饰词，否则无法通过@Value()注解的方式获取配置文件的值
  34.      *
  35.      */
  36.     @Bean
  37.     public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
  38.         return new LifecycleBeanPostProcessor();
  39.     }
  41.     /**
  42.      * Shiro基础配置
  43.      */
  44.     @Bean
  45.     public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager, ShiroServiceImpl shiroService){
  46.         ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
  47.         shiroFilterFactoryBean.setSecurityManager(securityManager);
  49.         // 自定义过滤器
  50.         Map<String, Filter> filtersMap = new LinkedHashMap<>();
  51.         // 定义过滤器名称 【注：map里面key值对应的value要有authc才能使用自定义的过滤器】
  52.         filtersMap.put( "zqPerms", new CustomizePermissionsAuthFilter() );
  53.         filtersMap.put( "zqRoles", new CustomizeRolesAuthFilter() );
  54. //        filtersMap.put( "token", new TokenCheckFilter() );
  55.         shiroFilterFactoryBean.setFilters(filtersMap);
  57.         // 登录成功后跳转的主页面 （这里没用，前端vue控制了跳转）
  58.         // shiroFilterFactoryBean.setSuccessUrl("/index");
  60.         // 登录的路径: 如果你没有登录则会跳到这个页面中
  61.         // 如果没有设置值则会默认跳转到工程根目录下的"/login.jsp"页面 或 "/login" 映射
  62.         shiroFilterFactoryBean.setLoginUrl(Constants.LOGIN_URL);
  63.         // 设置没有权限时跳转的url
  64.         shiroFilterFactoryBean.setUnauthorizedUrl(Constants.UN_AUTH_URL);
  66.         shiroFilterFactoryBean.setFilterChainDefinitionMap( shiroService.loadFilterChainDefinitionMap() );
  67.         return shiroFilterFactoryBean;
  68.     }
  70.     /**
  71.      * 配置Redis管理器：使用的是shiro-redis开源插件
  72.      */
  73.     @Bean
  74.     public RedisManager redisManager() {
  75.         RedisManager redisManager = new RedisManager();
  76.         redisManager.setHost(host + ":" + port);
  77.         redisManager.setTimeout(6000);
  78.         redisManager.setPassword(password);
  79.         return redisManager;
  80.     }
  82.     /**
  83.      * 配置Cache管理器：用于往Redis存储权限和角色标识  (使用的是shiro-redis开源插件)
  84.      */
  85.     @Bean
  86.     public RedisCacheManager cacheManager() {
  87.         RedisCacheManager redisCacheManager = new RedisCacheManager();
  88.         redisCacheManager.setRedisManager(redisManager());
  89.         redisCacheManager.setKeyPrefix(CACHE_KEY);
  90.         // 配置缓存的话要求放在session里面的实体类必须有个id标识 注：这里id为用户表中的主键，否-> 报：User must has getter for field: xx
  91.         redisCacheManager.setPrincipalIdFieldName("userId");
  92.         return redisCacheManager;
  93.     }
  95.     /**
  96.      * SessionID生成器
  97.      */
  98.     @Bean
  99.     public ShiroSessionIdGenerator sessionIdGenerator(){
  100.         return new ShiroSessionIdGenerator();
  101.     }
  103.     /**
  104.      * 配置RedisSessionDAO (使用的是shiro-redis开源插件)
  105.      */
  106.     @Bean
  107.     public RedisSessionDAO redisSessionDAO() {
  108.         RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
  109.         redisSessionDAO.setRedisManager(redisManager());
  110.         redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
  111.         redisSessionDAO.setKeyPrefix(SESSION_KEY);
  112.         redisSessionDAO.setExpire(EXPIRE);
  113.         return redisSessionDAO;
  114.     }
  116.     /**
  117.      * 配置Session管理器
  118.      */
  119.     @Bean
  120.     public SessionManager sessionManager() {
  121.         SimpleCookie simpleCookie = new SimpleCookie(Constants.SHIRO_TOKEN);
  122.         simpleCookie.setPath("/");
  123.         simpleCookie.setHttpOnly(false);
  125.         ShiroSessionManager shiroSessionManager = new ShiroSessionManager();
  126.         shiroSessionManager.setSessionDAO(redisSessionDAO());
  127.         return shiroSessionManager;
  128.     }
  129. }

shiro动态权限处理方法

1、初始化权限信息
loadFilterChainDefinitionMap
在shiro基础配置里 shiroFilterFactory 方法里，需要调用此方法从数据库中配置所有uri权限全部加载进去，以及放行的接口和配置权限过滤器等。
2、动态刷新加载数据库中的uri权限
updatePermission
页面在新增uri路径到数据库中，也就是在配置新的权限时就可以调用此方法实现动态加载uri权限。
3、shiro动态权限加载
updatePermissionByRoleId
在分配给指定用户权限时，可以调用此方法删除shiro缓存，重新执行 doAuthizationInfo 方法授权角色和权限。

  1. @Slf4j
  2. @Service
  3. public class ShiroServiceImpl implements ShiroService {
  5.     @Autowired
  6.     private PermMenuService permMenuService;
  8.     @Autowired
  9.     private RoleService roleService;
  11.     @Autowired
  12.     private UserService userService;
  14.     private static final String ANONYMOUS = "anon";
  16.     @Override
  17.     public Map<String, String> loadFilterChainDefinitionMap() {
  18.         // 权限控制map
  19.         Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
  22.         // 配置过滤： 不会被拦截的链接
  23.         // --------------- 放行 start ---------------
  24.         // 放行Swagger2页面
  25.         filterChainDefinitionMap.put("/doc.html", ANONYMOUS);
  26.         filterChainDefinitionMap.put("/api-docs-ext", ANONYMOUS);
  27.         filterChainDefinitionMap.put("/api-docs", ANONYMOUS);
  28.         filterChainDefinitionMap.put("/swagger-ui.html", ANONYMOUS);
  29.         filterChainDefinitionMap.put("/swagger/**", ANONYMOUS);
  30.         filterChainDefinitionMap.put("/webjars/**", ANONYMOUS);
  31.         filterChainDefinitionMap.put("/swagger-resources/**", ANONYMOUS);
  32.         filterChainDefinitionMap.put("/v2/**", ANONYMOUS);
  33.         filterChainDefinitionMap.put("/static/**", ANONYMOUS);
  36.         // 登录
  37.         filterChainDefinitionMap.put("/open/auth/api/**", ANONYMOUS);
  38.         // 退出
  39.         filterChainDefinitionMap.put(Constants.LOGIN_URL, ANONYMOUS);
  40.         // 放行未授权接口，重定向使用
  41.         filterChainDefinitionMap.put(Constants.UN_AUTH_URL, ANONYMOUS);
  42.         // token过期接口
  43.         filterChainDefinitionMap.put(Constants.TOKEN_EXPIRED_URL, ANONYMOUS);
  44.         // 被挤下线
  45.         filterChainDefinitionMap.put(Constants.DOWN_LINE_URL, ANONYMOUS);
  46.         // --------------- 放行 end --------------------
  49.         // 从数据库或缓存中查找出来的url与resources对应则不会被拦截，放行
  50.         List<PermMenuPo> permList = permMenuService.selectList(null);
  51.         if (!CollectionUtils.isEmpty(permList)) {
  52.             permList.forEach(perm -> {
  53.                 if (StringUtils.isNotBlank(perm.getApiPath())) {
  54.                     // 根据url查询相关联的角色名，拼接自定义的角色权限
  55.                     List<RoleVo> roleList = roleService.queryByPermId(perm.getPermId());
  56.                     StringJoiner zqRoles = new StringJoiner(",", "zqRoles[", "]");
  57.                     if (!CollectionUtils.isEmpty(roleList)) {
  58.                         roleList.forEach(role -> {
  59.                             zqRoles.add(role.getRoleId());
  60.                         });
  61.                     }
  63.                     // 注意过滤器配置顺序不能颠倒
  64.                     // (1) 认证登录
  65.                     // (2) 认证自定义的token过滤器 - 判断token是否有效
  66.                     // (3) 角色权限 zqRoles： 自定义的只需要满足其中一个角色即可访问
  67.                     //     roles[admin, guest] : 默认需要每个参数满足才算通过，相当于hasAllRoles()方法
  68.                     // (4) 操作权限 zqPerms: 认证自定义的url过滤器拦截权限
  69. //                    filterChainDefinitionMap.put(perm.getApiPath(), "authc,token," + zqRoles.toString() + ",zqPerms[" + perm.getPermId() + "]");
  70.                     filterChainDefinitionMap.put(perm.getApiPath(), "authc," + zqRoles.toString() + ",zqPerms[" + perm.getResource() + "]");
  71.                     // filterChainDefinitionMap.put("/api/system/user/listPage", "authc,token,zqPerms[user1]"); // 写死的一种用法
  72.                 }
  73.             });
  74.         }
  75.         // （5） 认证登录
  76.         filterChainDefinitionMap.put("/**", "authc");
  77.         return filterChainDefinitionMap;
  78.     }
  80.     @Override
  81.     public void updatePermission(ShiroFilterFactoryBean shiroFilterFactoryBean, String roleId, Boolean isRemoveSession) {
  82.         synchronized (this) {
  83.             AbstractShiroFilter shiroFilter;
  84.             try {
  85.                 shiroFilter = (AbstractShiroFilter) shiroFilterFactoryBean.getObject();
  86.             } catch (Exception e) {
  87.                 e.printStackTrace();
  88.                 log.error("get ShiroFilter from shiroFilterFactoryBean error!");
  89.                 return;
  90.             }
  91.             PathMatchingFilterChainResolver filterChainResolver = (PathMatchingFilterChainResolver) shiroFilter.getFilterChainResolver();
  92.             DefaultFilterChainManager manager = (DefaultFilterChainManager) filterChainResolver.getFilterChainManager();
  93.             // 清空拦截管理器中的存储
  94.             manager.getFilterChains().clear();
  95.             // 清空拦截工厂中的存储,如果不清空这里,还会把之前的带进去
  96.             // ps:如果仅仅是更新的话,可以根据这里的 map 遍历数据修改,重新整理好权限再一起添加
  97.             shiroFilterFactoryBean.getFilterChainDefinitionMap().clear();
  98.             // 动态查询数据库中所有权限
  99.             shiroFilterFactoryBean.setFilterChainDefinitionMap(loadFilterChainDefinitionMap());
  100.             // 重新构建生成拦截
  101.             Map<String, String> chains = shiroFilterFactoryBean.getFilterChainDefinitionMap();
  102.             for (Map.Entry<String, String> entry : chains.entrySet()) {
  103.                 manager.createChain(entry.getKey(), entry.getValue());
  104.             }
  105.             log.info("--------------- 动态生成url权限成功！------------------");
  106.             // 动态更新该角色关联的用户shiro权限
  107.             if (roleId != null) {
  108.                 updatePermissionByRoleId(roleId, isRemoveSession);
  109.             }
  110.         }
  111.     }
  113.     @Override
  114.     public void updatePermissionByRoleId(String roleId, Boolean isRemoveSession) {
  115.         // 查询当前角色的shiro缓存信息 -> 实现动态权限
  116.         List<UserVo> userList = userService.queryByRoleId(roleId);
  117.         // 删除当前角色关联的用户缓存信息，用户再次访问接口时会重新授权， isRemoveSession为true时删除Session->即强制用户退出
  118.         if (!CollectionUtils.isEmpty(userList)) {
  119.             for (UserVo user : userList) {
  120.                 ShiroUtils.deleteCache(user.getUserAccount(), isRemoveSession);
  121.             }
  122.         }
  123.         log.info("------------------ 动态修改用户权限成功! ------------------");
  124.     }
  126.     @Override
  127.     public void updatePermissionByUserId(String userId, Boolean isRemoveSession) {
  128.         UserPo userPo = userService.selectById(userId);
  129.         ShiroUtils.deleteCache(userPo.getUserAccount(), isRemoveSession);
  130.         log.info("------------------ 动态修改用户权限成功! ------------------");
  131.     }
  133.     @Override
  134.     public void updatePermissionByUserId(List<String> userIdList, Boolean isRemoveSession) {
  135.         List<UserPo> userPoList = userService.selectBatchIds(userIdList);
  136.         if (!userPoList.isEmpty()) {
  137.             for (UserPo userPo : userPoList) {
  138.                 ShiroUtils.deleteCache(userPo.getUserAccount(), isRemoveSession);
  139.             }
  140.         }
  141.         log.info("------------------ 动态修改用户权限成功! ------------------");
  142.     }
  143. }

Shiro工具类

  1. public class ShiroUtils {
  3.     /** 私有构造器 **/
  4.     private ShiroUtils(){ }
  6.     private static RedisSessionDAO redisSessionDAO = SpringUtil.getBean(RedisSessionDAO.class);
  8.     /**
  9.      * 获取当前用户Session
  10.      * @Return SysUserEntity 用户信息
  11.      */
  12.     public static Session getSession() {
  13.         return SecurityUtils.getSubject().getSession();
  14.     }
  16.     /**
  17.      * 用户登出
  18.      */
  19.     public static void logout() {
  20.         SecurityUtils.getSubject().logout();
  21.     }
  23.     /**
  24.      * 获取当前用户信息
  25.      * @Return SysUserEntity 用户信息
  26.      */
  27.     public static User getUserInfo() {
  28.         return (User) SecurityUtils.getSubject().getPrincipal();
  29.     }
  31.     /**
  32.      * 删除用户缓存信息
  33.      * @Param  username  用户名称
  34.      * @Param  isRemoveSession 是否删除Session，删除后用户需重新登录
  35.      */
  36.     public static void deleteCache(String username, boolean isRemoveSession){
  37.         //从缓存中获取Session
  38.         Session session = null;
  39.         // 获取当前已登录的用户session列表
  40.         Collection<Session> sessions = redisSessionDAO.getActiveSessions();
  41.         User sysUserEntity;
  42.         Object attribute = null;
  43.         // 遍历Session,找到该用户名称对应的Session
  44.         for(Session sessionInfo : sessions){
  45.             attribute = sessionInfo.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
  46.             if (attribute == null) {
  47.                 continue;
  48.             }
  49.             sysUserEntity = (User) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
  50.             if (sysUserEntity == null) {
  51.                 continue;
  52.             }
  53.             if (Objects.equals(sysUserEntity.getUsername(), username)) {
  54.                 session=sessionInfo;
  55.                 // 清除该用户以前登录时保存的session，强制退出  -> 单用户登录处理
  56.                 if (isRemoveSession) {
  57.                     redisSessionDAO.delete(session);
  58.                 }
  59.             }
  60.         }
  62.         if (session == null||attribute == null) {
  63.             return;
  64.         }
  65.         //删除session
  66.         if (isRemoveSession) {
  67.             redisSessionDAO.delete(session);
  68.         }
  69.         //删除Cache，再访问受限接口时会重新授权
  70.         DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager) SecurityUtils.getSecurityManager();
  71.         Authenticator authc = securityManager.getAuthenticator();
  72.         ((LogoutAware) authc).onLogout((SimplePrincipalCollection) attribute);
  73.     }
  75.     /**
  76.      * 从缓存中获取指定用户名的Session
  77.      * @param username
  78.      */
  79.     private static Session getSessionByUsername(String username){
  80.         // 获取当前已登录的用户session列表
  81.         Collection<Session> sessions = redisSessionDAO.getActiveSessions();
  82.         User user;
  83.         Object attribute;
  84.         // 遍历Session,找到该用户名称对应的Session
  85.         for(Session session : sessions){
  86.             attribute = session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
  87.             if (attribute == null) {
  88.                 continue;
  89.             }
  90.             user = (User) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
  91.             if (user == null) {
  92.                 continue;
  93.             }
  94.             if (Objects.equals(user.getUsername(), username)) {
  95.                 return session;
  96.             }
  97.         }
  98.         return null;
  99.     }
  101. }