shiro学习五：使用springboot整合shiro。在前面学习四的基础上，增加shiro的缓存机制，源码讲解：认证缓存、授权缓存。

embedded/2025/2/2 15:02:47/

文章目录

  • 前言
  • 1. 直接上代码最后在讲解
    • 1.1 新增的pom依赖
    • 1.2 RedisCache.java
    • 1.3 RedisCacheManager.java
    • 1.4 jwt的三个类
    • 1.5 ShiroConfig.java新增Bean
  • 2. 源码讲解。
    • 2.1 shiro 缓存的代码流程。
    • 2.2 缓存流程
      • 2.2.1 认证和授权简述
      • 2.2.2 AuthenticatingRealm.getAuthenticationInfo() 认证缓存。
      • 2.2.3 AuthorizingRealm.getAuthorizationInfo() 授权缓存。
    • 2.3 redis缓存的设置入口（个人认为是重点）
  • 3. 问题解决
    • 3.1 授权的流程是怎么做的
    • 3.2 @RequiresPermissions("sys:user:list")是如何工作的
      • **1. 基本原理**
      • **2. 具体流程**
        • **1. 用户登录阶段**
        • **2. 调用 `listUsers` 方法时**
        • **3. 匹配机制**

前言

  • shiro学习一：了解shiro，学习执行shiro的流程。使用springboot的测试模块学习shiro单应用（demo 6个）

  • shiro学习二：shiro的加密认证详解，加盐与不加盐两个版本。

  • shiro学习三：shiro的源码分析

  • 密码专辑：对密码加盐加密，对密码进行md5加密，封装成密码工具类

  • shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。

  • 代码所在地：https://github.com/fengfanli/springboot-shiro 记得给个星哦。

  • 本文详细介绍了在Java Spring Boot项目中使用Apache Shiro进行权限管理的实现方式。通过整合Redis作为缓存管理器，实现了用户权限的缓存，提高了权限验证的效率。文章还解析了@RequiresPermissions注解的工作原理，说明了如何通过AOP机制拦截方法，并进行权限字符串的匹配校验，确保只有具备相应权限的用户能够访问受保护的方法。整体上，文章为Shiro在Spring Boot项目中的应用提供了全面的技术指导。

1. 直接上代码最后在讲解

1.1 新增的pom依赖

<!--JWT--><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId><version>0.9.1</version></dependency>

1.2 RedisCache.java

package com.feng.shiro;import com.alibaba.fastjson.JSON;
import com.feng.constant.Constant;
import com.feng.jwt.JwtTokenUtil;
import com.feng.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.util.CollectionUtils;import java.util.*;
import java.util.concurrent.TimeUnit;/*** @ClassName: RedisCache* @Description： 缓存工具类* @createTime: 2020/2/9 20:42* @Author: 冯凡利* @UpdateUser: 冯凡利* @Version: 0.0.1*//*** 这里的 RedisUtils 不能注入** @param <K>* @param <V>*/
@Slf4j
public class RedisCache<K, V> implements Cache<K, V> {private final static String PREFIX = "shiro-cache:";private String cacheKey;private long expire = 24;  // 24 小时private RedisUtil redisUtil;public RedisCache(String name, RedisUtil redisUtil) {
//        this.cacheKey=PREFIX+name+":";this.cacheKey = Constant.IDENTIFY_CACHE_KEY;this.redisUtil = redisUtil;}/*** 根据 key 值 获取 权限信息** @param key  jwt* @return* @throws CacheException*/@Overridepublic V get(K key) throws CacheException {log.info("Shiro 从缓存中获取数据 KEY 值[{}]", key);if (key == null) {return null;}try {String redisCacheKey = getRedisCacheKey(key);Object rawValue = redisUtil.get(redisCacheKey);  // 根据key 获取 数据if (rawValue == null) {return null;}SimpleAuthorizationInfo info = JSON.parseObject(rawValue.toString(), SimpleAuthorizationInfo.class);V value = (V) info;return value;} catch (Exception e) {throw new CacheException(e);}}/*** 存值** @param key jwt* @param value* @return* @throws CacheException*/@Overridepublic V put(K key, V value) throws CacheException {log.info("put key [{}]", key);if (key == null) {log.warn("Saving a null key is meaningless, return value directly without call Redis.");return value;}try {String redisCacheKey = getRedisCacheKey(key); // cacheKey + userIdredisUtil.set(redisCacheKey, value != null ? value : null, expire, TimeUnit.HOURS);return value;} catch (Exception e) {throw new CacheException(e);}}/*** 根据 key 值 删除缓存的值** @param key* @return* @throws CacheException*/@Overridepublic V remove(K key) throws CacheException {log.info("remove key [{}]", key);if (key == null) {return null;}try {String redisCacheKey = getRedisCacheKey(key);Object rawValue = redisUtil.get(redisCacheKey);V previous = (V) rawValue;redisUtil.delete(redisCacheKey);return previous;} catch (Exception e) {throw new CacheException(e);}}/*** 清除 所有的值** @throws CacheException*/@Overridepublic void clear() throws CacheException {log.debug("clear cache");Set<String> keys = null;try {keys = redisUtil.keys(this.cacheKey + "*");} catch (Exception e) {log.error("get keys error", e);}if (keys == null || keys.size() == 0) {return;}for (String key : keys) {redisUtil.delete(key);}}/*** 获取 redis 所存的 缓存数的大小** @return*/@Overridepublic int size() {int result = 0;try {result = redisUtil.keys(this.cacheKey + "*").size();} catch (Exception e) {log.error("get keys error", e);}return result;}/*** 获取key值** @return*/@SuppressWarnings("unchecked")@Overridepublic Set<K> keys() {Set<String> keys = null;try {keys = redisUtil.keys(this.cacheKey + "*");} catch (Exception e) {log.error("get keys error", e);return Collections.emptySet();}if (CollectionUtils.isEmpty(keys)) {return Collections.emptySet();}Set<K> convertedKeys = new HashSet<>();for (String key : keys) {try {convertedKeys.add((K) key);} catch (Exception e) {log.error("deserialize keys error", e);}}return convertedKeys;}/*** 获取 value值** @return*/@Overridepublic Collection<V> values() {Set<String> keys = null;try {keys = redisUtil.keys(this.cacheKey + "*");} catch (Exception e) {log.error("get values error", e);return Collections.emptySet();}if (CollectionUtils.isEmpty(keys)) {return Collections.emptySet();}List<V> values = new ArrayList<V>(keys.size());for (String key : keys) {V value = null;try {value = (V) redisUtil.get(key);} catch (Exception e) {log.error("deserialize values= error", e);}if (value != null) {values.add(value);}}return Collections.unmodifiableList(values);}/*** 获取 redis 中的 缓存 key  ,很重要，** @param key* @return*/private String getRedisCacheKey(K key) {if (null == key) {return null;} else {return this.cacheKey + JwtTokenUtil.getUserId(key.toString());}}
}

1.3 RedisCacheManager.java

package com.feng.shiro;import com.feng.utils.RedisUtil;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.springframework.beans.factory.annotation.Autowired;/*** @ClassName: RedisCacheManager* @Description： 描述* @createTime: 2020/2/9 21:14* @Author: 冯凡利* @UpdateUser: 冯凡利* @Version: 0.0.1*/
public class RedisCacheManager implements CacheManager {@Autowiredprivate RedisUtil redisUtil;@Overridepublic <K, V> Cache<K, V> getCache(String s) throws CacheException {return new RedisCache<>(s, redisUtil);}
}

1.4 jwt的三个类

我不贴了，不是核心代码，可直接看GitHub。
四个部分：

  1. JwtTokenUtil.java：jwt的工具类
  2. JwtPropertiesConfig.java：application.properties 中的jwt的属性读取类
  3. InitializerJwtPropertiesConfig.java：将 JwtPropertiesConfig.java进行注入。
  4. application.properties 中的jwt的自定义属性配置。

1.5 ShiroConfig.java新增Bean

新增了redisCacheManager bean，然后再 getShiroRealm() 函数中 ，通过 Realm（ShiroRealm） 进行设置 缓存。

    /*** shiro 的 缓存管理器* 需要在 ShiroRealm bean 中进行设置* @return*/@Bean(name = "redisCacheManager")public RedisCacheManager redisCacheManager() {return new RedisCacheManager();}/*** 登录的 认证域** @param hashedCredentialsMatcher* @return*/@Bean(name = "shiroRealm")public ShiroRealm getShiroRealm(@Qualifier("shiroHashedCredentialsMatcher") HashedCredentialsMatcher hashedCredentialsMatcher,@Qualifier("redisCacheManager") RedisCacheManager redisCacheManager) {ShiroRealm shiroRealm = new ShiroRealm();// 自定义 处理 token 过滤shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);// 自定义 缓存管理器shiroRealm.setCacheManager(redisCacheManager);return shiroRealm;}

shiro 新增的 shiro 缓存 代码到此结束。
其他代码没有展示，是因为 shiro 缓存的代码只有这些。

2. 源码讲解。

2.1 shiro 缓存的代码流程。

  1. 首先编写 RedisCache.java：实现 Cache 接口，再这里重写redis的一些操作函数
  2. 编写RedisCacheManager.java 类：实现 CacheManager 接口，将RedisCache.java 类加入到 缓存管理中。
  3. 编写ShiroConfig.java 类：将RedisCacheManager注入生Bean，然后再Realm（本案例是ShiroRealm）中设置 缓存管理，同时也是设置 资格匹配 的地方。

2.2 缓存流程

shiro的核心是再 数据域中，也就是Realm，本案例的是ShiroRealm，继承 AuthorizingRealm 授权域， 授权域 继承了 AuthenticatingRealm 认证域，认证域 又继承了 CachingRealm 缓存域。这三个类是shiro 认证、授权、缓存 三个最重要的类。

2.2.1 认证和授权简述

继承了 AuthorizingRealm 授权域，就要重写两个最重要的方法

  1. 认证函数 doGetAuthenticationInfo()，既然认证，重写的就是 AuthenticatingRealm 认证域 中的函数。在函数getAuthenticationInfo() 中。源码截图如下：
    在这里插入图片描述

  2. 授权函数 doGetAuthorizationInfo()，既然授权，重写的就是 AuthorizingRealm 授权域 中的函数。在函数 getAuthorizationInfo() 中,源码截图如下：
    在这里插入图片描述

在 Shiro 中，认证缓存（authentication cache） 和 授权缓存（authorization cache） 是两个不同的缓存，它们用于不同的目的：

  • 认证缓存 (authenticationCache)：用于缓存用户的认证信息（如，用户是否存在，凭证是否正确等）。这通常是一个比较频繁更新的缓存，因为用户登录的凭证（如密码）是动态变化的，可能会变得无效。
  • 授权缓存 (authorizationCache)：用于缓存用户的授权信息（如，用户的角色、权限等）。授权信息通常不太会频繁变动，因此可以缓存很长时间。它一般是用于存储用户的角色和权限信息，以减少每次请求时对数据库或外部系统的查询。

2.2.2 AuthenticatingRealm.getAuthenticationInfo() 认证缓存。

该函数的第一句就是：AuthenticationInfo info = this.getCachedAuthenticationInfo(token); 该函数就是从缓存中获取认证信息。
先说答案：shiro不推荐、默认不支持 认证从缓存中获取。

代码中可以看到 在AuthenticatingRealm类属性 this.authenticationCachingEnabled = false; 在构造函数中 默认为 false，不开启缓存。

究其原因：用于缓存用户的认证信息（如，用户是否存在，凭证是否正确等）。这通常是一个比较频繁更新的缓存，因为用户登录的凭证（如密码）是动态变化的，可能会变得无效。

所以不推荐缓存，通过debug，也可以看到。

2.2.3 AuthorizingRealm.getAuthorizationInfo() 授权缓存。

授权缓存 在shiro 中是支持的。因为 AuthorizingRealm 授权域类中的 类属性 this.authorizationCachingEnabled = true; 在构造函数中默认为true的。

getAuthorizationInfo() 函数就是从缓存中进行获取的，没有获取到在 进入 到 doGetAuthorizationInfo() 函数中进行获取、授权。

可以通过debug的方式一点点去查看。

如果没有设置redis作为缓存管理，默认可以配置缓存，但是shiro并没有帮我指定缓存，估计是怕默认指定之后怕内存使用过高，需要自行设定，接下来讲解。

2.3 redis缓存的设置入口（个人认为是重点）

前边讲的都是逻辑流程，如何从缓存中获取。我在读源码的时候我就很好奇，那设置redis作为缓存的地方在哪里呢？默认是用内存作为缓存的设置又在哪里呢？抱着这些疑问继续走。

答案：入口就在ShiroConfig中 Realm 的配置中。

     ShiroRealm shiroRealm = new ShiroRealm();// 自定义 处理 token 过滤shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);// 自定义 缓存管理器shiroRealm.setCacheManager(redisCacheManager);

new ShiroRealm()时 ;会执行 AuthorizingRealm、AuthenticatingRealm的构造函数。构造函数中会设置 缓存启动情况、缓存的配置情况。

  • 其中 AuthenticatingRealm 认证域的构造函数中，会默认指定 SimpleCredentialsMatcher 作为 凭证匹配器 的 类，shiro还提供了 HashedCredentialsMatcher 作为 凭证匹配器 类（具体有几个，看 CredentialsMatcher 类的实现类有几个即可，下图所示）。后面我们自定义了 凭证匹配器 类 CustomHashedCredentialsMatcher，其中的 doCredentialsMatch（） 函数就是默认 认证的最核心的函数。
    在这里插入图片描述

  • AuthorizingRealm 授权域的构造函数中，会默认指定 缓存管理（在CachingRealm 类中）、凭证匹配器（认证域类中） 的初始化，默认都是null。

  • shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);：调用 认证域类 中的方法设置 凭证匹配器 。

  • shiroRealm.setCacheManager(redisCacheManager);：调用 缓存域类 中的方法设置缓存管理器 以及 实现缓存的方式（第二行语句），该方法是个接口，有两个实现方法：一个是 认证域，一个是授权域。往下走。在这里插入图片描述

  • 这里就是 授权域 中的 afterCacheManagerSet() 函数，

    • 第一个函数调用父类也就是认证域上的函数，会继续调用 this.getAvailableAuthenticationCache()。认证域前边说了，认证缓存shiro默认是关闭的，debug走一边流程就明白了；重点就是授权域了。
    • 在第二个函数上，先判断是否有缓存，为null，然后再看 授权域 是否支持 授权缓存（默认支持，前边说了）；然后进入懒加载缓存（下面第二张图）；到获取缓存的地方，缓存管理不为null，是redis的，接着从158行，获取缓存，158行往下debug，就是上面的1.3小节的 RedisCacheManager.java，将redis返回。
      在这里插入图片描述
      在这里插入图片描述

  • 我又来问题了，如果没有redis，走的是哪个呢?首先我也不知道，得先把redis缓存管理给去掉。看看使用的哪个。CacheManager.java 是接口，其实现类截图如下，第一个是我实现的，其余三个都是shiro自带的（第二个应该不是，看源码）。

  • 通过源码查看，shiro并没有默认使用缓存配置，仅仅是打开了缓存配置，可以供我们使用，如果想用使用缓存需要自行配置缓存，想上面配置 redis一样，将下面的第二个或者第四个配置到缓存管理中去。
    在这里插入图片描述

到这里为止源码讲解完啦。

3. 问题解决

3.1 授权的流程是怎么做的

这个需要有背景的。
我基于这个项目来说一下
前端 LayUI+thymeleaf
后端使用springboot、shiro作为权限管理。
根据请求 /api/users，进行举例。
前端发请求后，会先认证，此处略。
然后会先从前端标签获取 权限字符串 sys:user:list，这里使用到了 thymeleaf，然后 通过 doGetAuthorizationInfo()获取所有权限字符串和角色，然后与从前端拿到的 权限字符串 sys:user:list进行对比，若包含，这通过。否则失败

3.2 @RequiresPermissions(“sys:user:list”)是如何工作的

1. 基本原理

@RequiresPermissions("sys:user:list") 是 Apache Shiro 提供的权限控制注解，用于声明访问某个方法或类需要的特定权限。

它的工作机制如下：

  1. 拦截注解：

    • Shiro 提供了 AuthorizationAttributeSourceAdvisor 和 AOP（切面编程）机制来拦截被注解标记的类或方法。
    • 当调用被标记的方法时，Shiro 拦截并执行权限校验。

  2. 获取当前用户的权限：

    • Shiro 从当前登录用户的 Subject（主体）中获取用户的权限信息（通常是一组权限字符串）。

  3. 权限字符串匹配：

    • Shiro 将注解中的权限字符串（如 "sys:user:list"）与当前用户的权限列表进行比对。
    • 如果用户的权限列表中包含注解指定的权限字符串，则校验通过；否则抛出 AuthorizationException，拒绝访问。

2. 具体流程

假设你有以下代码：

@RequiresPermissions("sys:user:list")
public void listUsers() {// 获取用户列表逻辑
}
1. 用户登录阶段
  • 用户通过登录接口认证成功后，Shiro 会根据用户身份（如用户名）从数据库或缓存中加载用户的所有权限，并存储在 Subject 中。
  • 示例权限列表：
    ["sys:user:list", "sys:user:edit", "sys:user:delete"]
2. 调用 listUsers 方法时
  • Shiro 拦截 @RequiresPermissions 注解，通过当前用户的 Subject 获取权限列表。
  • 调用 Subject.isPermitted("sys:user:list") 方法，具体逻辑如下：
    1. Shiro 将注解中的权限字符串 "sys:user:list" 传递给 AuthorizingRealm 的 doGetAuthorizationInfo 方法。
    2. doGetAuthorizationInfo 返回用户的权限列表。
    3. Shiro 比较 "sys:user:list" 是否存在于用户的权限列表中：
      • 存在：校验通过，继续执行方法。
      • 不存在：抛出异常 AuthorizationException。
3. 匹配机制
  • 权限字符串可以使用通配符（Wildcard）进行匹配：
    • 完全匹配："sys:user:list" 对比 "sys:user:list"，通过。
    • 通配符匹配："sys:user:*" 对比 "sys:user:list"，通过。
    • 多级通配符："sys:*:*" 对比 "sys:user:list"，通过。

http://www.ppmy.cn/embedded/158928.html

相关文章

大模型应用的10个架构挑战

大模型应用的10个架构挑战

[引] 在英国&#xff0c;时差有点乱。拾起年初的文字&#xff0c;迎接新春大吉&#xff01; ChatGPT从正式发布到拥有1亿用户仅仅用了5天的时间&#xff0c;基于大型语言模型&#xff08;简称大模型&#xff0c;或基础模型&#xff09;的应用给软件行业乃至整个社会带来巨大的影…
阅读更多...
Spring JDBC：简化数据库操作的利器

Spring JDBC：简化数据库操作的利器

前言 Spring框架为Java开发者提供了多种技术解决方案&#xff0c;Spring JDBC作为其中的核心模块之一&#xff0c;帮助开发者更加轻松、简洁地进行数据库操作。本文将介绍Spring JDBC的概念、优势、如何使用以及常见的应用场景。 什么是Spring JDBC&#xff1f; Spring JDBC是…
阅读更多...
数据库、数据仓库、数据湖有什么不同

数据库、数据仓库、数据湖有什么不同

数据库、数据仓库和数据湖是三种不同的数据存储和管理技术&#xff0c;它们在用途、设计目标、数据处理方式以及适用场景上存在显著差异。以下将从多个角度详细说明它们之间的区别&#xff1a; 1. 数据结构与存储方式 数据库&#xff1a; 数据库主要用于存储结构化的数据&…
阅读更多...
1.Template Method 模式

1.Template Method 模式

模式定义 定义一个操作中的算法的骨架&#xff08;稳定&#xff09;&#xff0c;而将一些步骤延迟&#xff08;变化)到子类中。Template Method 使得子类可以不改变&#xff08;复用&#xff09;一个算法的结构即可重定义&#xff08;override 重写&#xff09;该算法的某些特…
阅读更多...
租房管理系统实现智能化租赁提升用户体验与运营效率

租房管理系统实现智能化租赁提升用户体验与运营效率

内容概要 在当今快速发展的租赁市场中&#xff0c;租房管理系统的智能化转型显得尤为重要。它不仅帮助房东和租客之间建立更高效的沟通桥梁&#xff0c;还优化了整个租赁流程。通过智能化技术&#xff0c;这套系统能够自动处理资产管理、合同签署、财务管理等所有关键环节。这…
阅读更多...
验证二叉搜索数（98）

验证二叉搜索数（98）

98. 验证二叉搜索树 - 力扣&#xff08;LeetCode&#xff09; 解法&#xff1a; /*** Definition for a binary tree node.* struct TreeNode {* int val;* TreeNode *left;* TreeNode *right;* TreeNode() : val(0), left(nullptr), right(nullptr) {}* …
阅读更多...
rust如何操作oracle

rust如何操作oracle

首先鄙视甲骨文&#xff0c;这么多钱的公司&#xff0c;不做一个rust库&#xff0c;还要社区帮忙。有个开源的rust库&#xff0c;叫oracle&#xff0c;但是并不是甲骨文做的。 我们来看一个从oracle数据库取所有表和视图的示例: // 定义连接字符串let conn_str1 format!(&quo…
阅读更多...
多模态论文笔记——TECO

多模态论文笔记——TECO

大家好&#xff0c;这里是好评笔记&#xff0c;公主号&#xff1a;Goodnote&#xff0c;专栏文章私信限时Free。本文详细解读多模态论文TECO&#xff08;Temporally Consistent Transformer&#xff09;&#xff0c;即时间一致变换器&#xff0c;是一种用于视频生成的创新模型&…
阅读更多...
最新文章

Copyright @ 2022~2023