• JEECG shiro验证实现分析

    jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/ShiroRealm.java

    1. package org.jeecg.config.shiro;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.apache.shiro.authc.AuthenticationException;
    5. import org.apache.shiro.authc.AuthenticationInfo;
    6. import org.apache.shiro.authc.AuthenticationToken;
    7. import org.apache.shiro.authc.SimpleAuthenticationInfo;
    8. import org.apache.shiro.authz.AuthorizationInfo;
    9. import org.apache.shiro.authz.SimpleAuthorizationInfo;
    10. import org.apache.shiro.realm.AuthorizingRealm;
    11. import org.apache.shiro.subject.PrincipalCollection;
    12. import org.jeecg.common.api.CommonAPI;
    13. import org.jeecg.common.config.TenantContext;
    14. import org.jeecg.common.constant.CacheConstant;
    15. import org.jeecg.common.constant.CommonConstant;
    16. import org.jeecg.common.system.util.JwtUtil;
    17. import org.jeecg.common.system.vo.LoginUser;
    18. import org.jeecg.common.util.RedisUtil;
    19. import org.jeecg.common.util.SpringContextUtils;
    20. import org.jeecg.common.util.TokenUtils;
    21. import org.jeecg.common.util.oConvertUtils;
    22. import org.springframework.context.annotation.Lazy;
    23. import org.springframework.stereotype.Component;
    24.  
    25. import javax.annotation.Resource;
    26. import javax.servlet.http.HttpServletRequest;
    27. import java.util.Set;
    28.  
    29. /**
    30.  * @Description: 用户登录鉴权和获取用户授权
    31.  * @Author: Scott
    32.  * @Date: 2019-4-23 8:13
    33.  * @Version: 1.1
    34.  */
    35. @Component
    36. @Slf4j
    37. public class ShiroRealm extends AuthorizingRealm {
    38. 	@Lazy
    39.     @Resource
    40.     private CommonAPI commonApi;
    41.  
    42.     @Lazy
    43.     @Resource
    44.     private RedisUtil redisUtil;
    45.  
    46.     /**
    47.      * 必须重写此方法，不然Shiro会报错
    48.      */
    49.     @Override
    50.     public boolean supports(AuthenticationToken token) {
    51.         return token instanceof JwtToken;
    52.     }
    53.  
    54.     /**
    55.      * 权限信息认证(包括角色以及权限)是用户访问controller的时候才进行验证(redis存储的此处权限信息)
    56.      * 触发检测用户权限时才会调用此方法，例如checkRole,checkPermission
    57.      *
    58.      * @param principals 身份信息
    59.      * @return AuthorizationInfo 权限信息
    60.      */
    61.     @Override
    62.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    63.         log.debug("===============Shiro权限认证开始============ [ roles、permissions]==========");
    64.         String username = null;
    65.         if (principals != null) {
    66.             LoginUser sysUser = (LoginUser) principals.getPrimaryPrincipal();
    67.             username = sysUser.getUsername();
    68.         }
    69.         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    70.  
    71.         // 设置用户拥有的角色集合，比如“admin,test”
    72.         Set roleSet = commonApi.queryUserRoles(username);
    73.         //System.out.println(roleSet.toString());
    74.         info.setRoles(roleSet);
    75.  
    76.         // 设置用户拥有的权限集合，比如“sys:role:add,sys:user:add”
    77.         Set permissionSet = commonApi.queryUserAuths(username);
    78.         info.addStringPermissions(permissionSet);
    79.         //System.out.println(permissionSet);
    80.         log.info("===============Shiro权限认证成功==============");
    81.         return info;
    82.     }
    83.  
    84.     /**
    85.      * 用户信息认证是在用户进行登录的时候进行验证(不存redis)
    86.      * 也就是说验证用户输入的账号和密码是否正确，错误抛出异常
    87.      *
    88.      * @param auth 用户登录的账号密码信息
    89.      * @return 返回封装了用户信息的 AuthenticationInfo 实例
    90.      * @throws AuthenticationException
    91.      */
    92.     @Override
    93.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
    94.         log.debug("===============Shiro身份认证开始============doGetAuthenticationInfo==========");
    95.         String token = (String) auth.getCredentials();
    96.         if (token == null) {
    97.             HttpServletRequest req = SpringContextUtils.getHttpServletRequest();
    98.             log.info("————————身份认证失败——————————IP地址:  "+ oConvertUtils.getIpAddrByRequest(req) +"，URL:"+req.getRequestURI());
    99.             throw new AuthenticationException("token为空!");
    100.         }
    101.         // 校验token有效性
    102.         LoginUser loginUser = null;
    103.         try {
    104.             loginUser = this.checkUserTokenIsEffect(token);
    105.         } catch (AuthenticationException e) {
    106.             JwtUtil.responseError(SpringContextUtils.getHttpServletResponse(),401,e.getMessage());
    107.             e.printStackTrace();
    108.             return null;
    109.         }
    110.         return new SimpleAuthenticationInfo(loginUser, token, getName());
    111.     }
    112.  
    113.     /**
    114.      * 校验token的有效性
    115.      *
    116.      * @param token
    117.      */
    118.     public LoginUser checkUserTokenIsEffect(String token) throws AuthenticationException {
    119.         // 解密获得username，用于和数据库进行对比
    120.         String username = JwtUtil.getUsername(token);
    121.         if (username == null) {
    122.             throw new AuthenticationException("token非法无效!");
    123.         }
    124.  
    125.         // 查询用户信息
    126.         log.debug("———校验token是否有效————checkUserTokenIsEffect——————— "+ token);
    127.         LoginUser loginUser = TokenUtils.getLoginUser(username, commonApi, redisUtil);
    128.         //LoginUser loginUser = commonApi.getUserByName(username);
    129.         if (loginUser == null) {
    130.             throw new AuthenticationException("用户不存在!");
    131.         }
    132.         // 判断用户状态
    133.         if (loginUser.getStatus() != 1) {
    134.             throw new AuthenticationException("账号已被锁定,请联系管理员!");
    135.         }
    136.         // 校验token是否超时失效 & 或者账号密码是否错误
    137.         if (!jwtTokenRefresh(token, username, loginUser.getPassword())) {
    138.             throw new AuthenticationException(CommonConstant.TOKEN_IS_INVALID_MSG);
    139.         }
    140.         //update-begin-author:taoyan date:20210609 for:校验用户的tenant_id和前端传过来的是否一致
    141.         String userTenantIds = loginUser.getRelTenantIds();
    142.         if(oConvertUtils.isNotEmpty(userTenantIds)){
    143.             String contextTenantId = TenantContext.getTenant();
    144.             log.debug("登录租户：" + contextTenantId);
    145.             log.debug("用户拥有那些租户：" + userTenantIds);
    146.              //登录用户无租户，前端header中租户ID值为 0
    147.             String str ="0";
    148.             if(oConvertUtils.isNotEmpty(contextTenantId) && !str.equals(contextTenantId)){
    149.                 //update-begin-author:taoyan date:20211227 for: /issues/I4O14W 用户租户信息变更判断漏洞
    150.                 String[] arr = userTenantIds.split(",");
    151.                 if(!oConvertUtils.isIn(contextTenantId, arr)){
    152.                     boolean isAuthorization = false;
    153.                     //========================================================================
    154.                     // 查询用户信息（如果租户不匹配从数据库中重新查询一次用户信息）
    155.                     String loginUserKey = CacheConstant.SYS_USERS_CACHE + "::" + username;
    156.                     redisUtil.del(loginUserKey);
    157.                     LoginUser loginUserFromDb = commonApi.getUserByName(username);
    158.                     if (oConvertUtils.isNotEmpty(loginUserFromDb.getRelTenantIds())) {
    159.                         String[] newArray = loginUserFromDb.getRelTenantIds().split(",");
    160.                         if (oConvertUtils.isIn(contextTenantId, newArray)) { 
    161.                             isAuthorization = true;
    162.                         }
    163.                     }
    164.                     //========================================================================
    165.  
    166.                     //*********************************************
    167.                     if(!isAuthorization){
    168.                         log.info("租户异常——登录租户：" + contextTenantId);
    169.                         log.info("租户异常——用户拥有租户组：" + userTenantIds);
    170.                         throw new AuthenticationException("登录租户授权变更，请重新登陆!");
    171.                     }
    172.                     //*********************************************
    173.                 }
    174.                 //update-end-author:taoyan date:20211227 for: /issues/I4O14W 用户租户信息变更判断漏洞
    175.             }
    176.         }
    177.         //update-end-author:taoyan date:20210609 for:校验用户的tenant_id和前端传过来的是否一致
    178.         return loginUser;
    179.     }
    180.  
    181.     /**
    182.      * JWTToken刷新生命周期 （实现： 用户在线操作不掉线功能）
    183.      * 1、登录成功后将用户的JWT生成的Token作为k、v存储到cache缓存里面(这时候k、v值一样)，缓存有效期设置为Jwt有效时间的2倍
    184.      * 2、当该用户再次请求时，通过JWTFilter层层校验之后会进入到doGetAuthenticationInfo进行身份验证
    185.      * 3、当该用户这次请求jwt生成的token值已经超时，但该token对应cache中的k还是存在，则表示该用户一直在操作只是JWT的token失效了，程序会给token对应的k映射的v值重新生成JWTToken并覆盖v值，该缓存生命周期重新计算
    186.      * 4、当该用户这次请求jwt在生成的token值已经超时，并在cache中不存在对应的k，则表示该用户账户空闲超时，返回用户信息已失效，请重新登录。
    187.      * 注意： 前端请求Header中设置Authorization保持不变，校验有效性以缓存中的token为准。
    188.      *       用户过期时间 = Jwt有效时间 * 2。
    189.      *
    190.      * @param userName
    191.      * @param passWord
    192.      * @return
    193.      */
    194.     public boolean jwtTokenRefresh(String token, String userName, String passWord) {
    195.         String cacheToken = String.valueOf(redisUtil.get(CommonConstant.PREFIX_USER_TOKEN + token));
    196.         if (oConvertUtils.isNotEmpty(cacheToken)) {
    197.             // 校验token有效性
    198.             if (!JwtUtil.verify(cacheToken, userName, passWord)) {
    199.                 String newAuthorization = JwtUtil.sign(userName, passWord);
    200.                 // 设置超时时间
    201.                 redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, newAuthorization);
    202.                 redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME *2 / 1000);
    203.                 log.debug("——————————用户在线操作，更新token保证不掉线—————————jwtTokenRefresh——————— "+ token);
    204.             }
    205.             //update-begin--Author:scott  Date:20191005  for：解决每次请求，都重写redis中 token缓存问题
    206. //			else {
    207. //				// 设置超时时间
    208. //				redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, cacheToken);
    209. //				redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME / 1000);
    210. //			}
    211.             //update-end--Author:scott  Date:20191005   for：解决每次请求，都重写redis中 token缓存问题
    212.             return true;
    213.         }
    214.  
    215.         //redis中不存在此TOEKN，说明token非法返回false
    216.         return false;
    217.     }
    218.  
    219.     /**
    220.      * 清除当前用户的权限认证缓存
    221.      *
    222.      * @param principals 权限信息
    223.      */
    224.     @Override
    225.     public void clearCache(PrincipalCollection principals) {
    226.         super.clearCache(principals);
    227.     }
    228.  
    229. }
    ShiroRealm是用户认证时调用的关键判断逻辑，这部分代码不是shiro库中的公共代码，而是项目开发者自己实现的。

    可以通过debug的代码栈窗口，查看调用流程。

    把debug断点设在org.jeecg.modules.system.service.impl.SysUserServiceImpl#getEncodeUserInfo方法内，运行到断点处停止，可以看到代码栈窗口显示了以往调用的方法，从下至上排列，最先调用的方法在最下方，最后调用的方法在最上方，其中通过接口调用的方法（比如org.jeecg.modules.system.service.ISysUserService#getEncodeUserInfo），还夹着invoke方法，盲猜是在执行注释，执行invoke后redis中出现了相应的缓存数据。

    @Cacheable(cacheNames=CacheConstant.SYS_USERS_CACHE, key="#username")

    流程顺序为：

    1、从org.jeecg.config.shiro.ShiroRealm#doGetAuthenticationInfo调用

    this.checkUserTokenIsEffect(token)

    2、从org.jeecg.config.shiro.ShiroRealm#checkUserTokenIsEffect调用

    TokenUtils.getLoginUser(username, commonApi, redisUtil)

    3、从org.jeecg.common.util.TokenUtils#getLoginUser调用

    commonApi.getUserByName(username)

    4、从org.jeecg.modules.system.service.impl.SysBaseApiImpl#getUserByName调用

    sysUserService.getEncodeUserInfo(username)

    5、从org.jeecg.modules.system.service.impl.SysUserServiceImpl#getEncodeUserInfo调用

    userMapper.getUserByName(username)

    一、用户登录时，经过一系列前期流程，shiro最终调用开发者自定义的ShiroRealm的org.jeecg.config.shiro.ShiroRealm#doGetAuthenticationInfo方法。

    该方法的执行流程是：

    1、调用同一文件下的checkUserTokenIsEffect（）具体进行用户验证。

    loginUser = this.checkUserTokenIsEffect(token);

    2、验证成功时返回SimpleAuthenticationInfo对象，失败则抛异常或返回null。

    二、org.jeecg.config.shiro.ShiroRealm#checkUserTokenIsEffect内部流程：

    1、先通过token解密出用户名：
String username = JwtUtil.getUsername(token);

    2、再通过用户名从redis或mysql获取用户信息（优先查redis，redis速度快）：

    LoginUser loginUser = TokenUtils.getLoginUser(username, commonApi, redisUtil);

    3、调用jwtTokenRefresh(token, username, loginUser.getPassword())校验用户

    4、最后校验用户的tenant_id和前端传过来的是否一致，关于这部分的作用，可能属于saas功能，有待进一步学习。

    三、org.jeecg.common.util.TokenUtils#getLoginUser涉及redis缓存的使用，第一次通过token（解密出来的用户名）查询用户信息时，redis未缓存该用户信息，需要去数据库中查询，查询后返回的结果直接缓存到redis中

    1.     public static LoginUser getLoginUser(String username, CommonAPI commonApi, RedisUtil redisUtil) {
    2.         LoginUser loginUser = null;
    3.         String loginUserKey = CacheConstant.SYS_USERS_CACHE + "::" + username;
    4.         //【重要】此处通过redis原生获取缓存用户，是为了解决微服务下system服务挂了，其他服务互调不通问题---
    5.         if (redisUtil.hasKey(loginUserKey)) {
    6.             try {
    7.                 loginUser = (LoginUser) redisUtil.get(loginUserKey);
    8.                 //解密用户
    9.                 SensitiveInfoUtil.handlerObject(loginUser, false);
    10.             } catch (IllegalAccessException e) {
    11.                 e.printStackTrace();
    12.             }
    13.         } else {
    14.             // 查询用户信息
    15.             loginUser = commonApi.getUserByName(username);
    16.         }
    17.         return loginUser;
    18.     }

    在执行commonApi.getUserByName(username);（org.jeecg.modules.system.service.impl.SysBaseApiImpl#getUserByName）之前，redis中不存在key为sys:cache:encrypt:user::admin的键值对，执行后出现了，继续深入getUserByName内：

    1. 	@Override
    2. 	//@SensitiveDecode
    3. 	public LoginUser getUserByName(String username) {
    4. 		//update-begin-author:taoyan date:2022-6-6 for: VUEN-1276 【v3流程图】测试bug 1、通过我发起的流程或者流程实例，查看历史，流程图预览问题
    5. 		if (oConvertUtils.isEmpty(username)) {
    6. 			return null;
    7. 		}
    8. 		//update-end-author:taoyan date:2022-6-6 for: VUEN-1276 【v3流程图】测试bug 1、通过我发起的流程或者流程实例，查看历史，流程图预览问题
    9. 		LoginUser user = sysUserService.getEncodeUserInfo(username);
    10.  
    11. 		//相同类中方法间调用时脱敏解密 Aop会失效，获取用户信息太重要，此处采用原生解密方法，不采用@SensitiveDecodeAble注解方式
    12. 		try {
    13. 			SensitiveInfoUtil.handlerObject(user, false);
    14. 		} catch (IllegalAccessException e) {
    15. 			e.printStackTrace();
    16. 		}
    17.  
    18. 		return user;
    19. 	}

    getUserByName（）的主要功能代码是调用

    sysUserService.getEncodeUserInfo(username);

    （org.jeecg.modules.system.service.impl.SysUserServiceImpl#getEncodeUserInfo）

    1. 	@Override
    2. 	@Cacheable(cacheNames=CacheConstant.SYS_USERS_CACHE, key="#username")
    3. 	@SensitiveEncode
    4. 	public LoginUser getEncodeUserInfo(String username){
    5. 		if(oConvertUtils.isEmpty(username)) {
    6. 			return null;
    7. 		}
    8. 		LoginUser loginUser = new LoginUser();
    9. 		SysUser sysUser = userMapper.getUserByName(username);
    10. 		//查询用户的租户ids
    11. 		this.setUserTenantIds(sysUser);
    12. 		if(sysUser==null) {
    13. 			return null;
    14. 		}
    15. 		BeanUtils.copyProperties(sysUser, loginUser);
    16. 		return loginUser;
    17. 	}

      在getEncodeUserInfo（）方法上有一个注释：

    @Cacheable(cacheNames=CacheConstant.SYS_USERS_CACHE, key="#username")

    正式创建缓存的关键代码，@Cacheable 注解在方法上，表示该方法的返回结果是可以缓存的。也就是说，该方法的返回结果会放在缓存中，以便于以后使用相同的参数调用该方法时，会返回缓存中的值，而不会实际执行该方法。
    在没有看到这个代码前，我是想不到@Cacheable的作用的，但是我知道redis中这一类键值对都是以CacheConstant.SYS_USERS_CACHE（"sys:cache:encrypt:user"）为key的开头的，通过ctrl+鼠标左键一键定位到SYS_USERS_CACHE定义处，能看到它有24个用法：

    点击“24个用法”挨个查看：

     就能发现一些规律，@CacheEvict注释是删除相应的redis缓存数据，打开前五个代码中的用法，发现也是在删除redis缓存数据。一一排除删除的用法，就剩下了@Cacheable用法，这时我小心假设它是创建缓存的方法，并通过百度印证了猜想。

  • 相关阅读:
    【Purple Pi OH RK3566鸿蒙开发板】OpenHarmony音频播放应用，真实体验感爆棚！
    【mid】sdp解析：奇怪的vector 引用
    九、iOS原生应用（宿主App）与uni小程序间的通讯
    C语言 牛客网习题 10.20 day2
    Android security知识点总结
    基于Java的磁盘调度模拟系统
    PyTorch实战-实现神经网络图像分类基础Tensor最全操作详解(一)
    vie的刷新机制
    C/C++ 11/14/17 有栈式协同程式的基础框架类库【关于】
    cdk&java | 实现化学反应中的片段分组
  • 原文地址：https://blog.csdn.net/qq_27361945/article/details/133803465