ruoyi-cloud认证-token改造为双token

最新推荐文章于 2024-10-11 10:53:59 发布
最新推荐文章于 2024-10-11 10:53:59 发布
阅读量1.3k 收藏 9
点赞数 1
分类专栏： java 文章标签： java redis 开发语言 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/r562253897/article/details/126033296
版权

文章目录

ruoyi-cloud认证-token改造为双token

前言

Token在计算机身份认证中是令牌（临时）的意思，在词法分析中是标记的意思。一般作为邀请、登录系统使用。

什么是双token

双token一般是指：access_token和refresh_token。

access_token是一种JWT（json web token），有效时间通常较短，用户在获取资源的时候需要携带access_token，当access_token过期后，如果是活跃用户，就需要使用refresh_token获取一个新的access_token，这样就避免了用户使用正high被踢出去，重新登录，那估计摔手机都有可能。但是对于登录上去，长时间不操作的用户呢，一般会设置超时时间，比如：设置5分钟超时时间，那连续5分钟没有任何操作就会被认为是超时，就会被请下去，需要重新登录，获取新的token。

ruoyi-cloud的token机制简述

  1. 在登录成功后，创建token。
    首先创建UUID，作为userKey，以该key为主键存储用户信息到redis，设置过期时间。
    其次，使用userKey及用户部分信息生成JWT token。而该JWT token即为对客户端暴漏的用户token。
  2. 在业务调用期间，由Gateway的com.ruoyi.gateway.filter.AuthFilter对token的合法性进行校验。上面说到，JWT token中包含userKey信息，则解析JWT token后，即可通过userKey从redis中获取到用户信息。当redis中该信息不存在，则意味着用户token失效。
  3. 那么ruoyi-cloud是怎么对token延期的呢？在com.ruoyi.common.security.interceptor.HeaderInterceptor中可以看到，在每次请求中都调用方法com.ruoyi.common.security.auth.AuthUtil.verifyLoginUserExpire(loginUser)，该方法最终执行逻辑如下：
public void verifyToken(LoginUser loginUser)
    {
        long expireTime = loginUser.getExpireTime();
        long currentTime = System.currentTimeMillis();
        if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
        {
            refreshToken(loginUser);
        }
    }

即当过期时间减去当前时间小于某一固定时间时，则刷新token。实际是做了token延期处理。

以上，即为ruoyi-cloud的token机制。

存在的问题

  1. 一个token可无限延期下去，过期时间越长，则安全性越低；
  2. token延期的机制，取决于用户请求的时间点、token过期时长、及MILLIS_MINUTE_TEN的取值。比如：token有效时长30分钟，MILLIS_MINUTE_TEN的取值为15分钟，那么在登录后的前15分钟，不会刷新token，即不会延长token。这样就形成了，我在第14分钟还在操作，本身人为要到第44分钟token才会过期，结果在第30分钟token就过期了。（😊有点绕）

如何改造

主要流程见下图：
双token认证机制

主要处理逻辑

  1. 用户登录验证通过，则分别生成accessToken、refreshToken，并将它们对应的过期时间一并返回给客户端；
  2. 客户端存储信息，在每次业务交互时，验证本地的token过期时间；
  3. 如果accessToken未过期，则携带accessToken调用业务接口；
  4. 如果accessToken已过期，refreshToken未过期，则携带refreshToken调用/auth/refresh接口，获取新的accessToken；
  5. 如果accessToken已过期，refreshToken已过期，则跳转要求重新登录。

实现关键代码

登录token创建
public Map<String, Object> createAllToken(LoginUser loginUser)
    {
        String token = IdUtils.fastUUID();
        String refToken = IdUtils.fastUUID();
        Long userId = loginUser.getSysUser().getUserId();
        Long deptId = loginUser.getSysUser().getDeptId();
        String userName = loginUser.getSysUser().getUserName();
        long currentTimeMillis = System.currentTimeMillis();
        long expires_time = currentTimeMillis+ expireTime * MILLIS_MINUTE;
        long refresh_expires_time = currentTimeMillis + refreshExpireTime * MILLIS_MINUTE;

        loginUser.setUserid(userId);
        loginUser.setUsername(userName);
        loginUser.setDeptId(deptId);
        loginUser.setIpaddr(IpUtils.getIpAddr(ServletUtils.getRequest()));
        loginUser.setLoginTime(System.currentTimeMillis());
        loginUser.setToken(token);
        loginUser.setRefToken(refToken);
        loginUser.setExpireTime(expires_time);
        loginUser.setRefExpireTime(refresh_expires_time);

        cacheAllToken(loginUser);
        // Jwt存储信息
        Map<String, Object> claimsMap = new HashMap<>();
        claimsMap.put(SecurityConstants.USER_KEY, token);
        claimsMap.put(SecurityConstants.DETAILS_USER_ID, userId);
        claimsMap.put(SecurityConstants.DETAILS_DEPT_ID, deptId);
        claimsMap.put(SecurityConstants.DETAILS_USERNAME, userName);
        claimsMap.put(SecurityConstants.TOKEN_TYPE, SecurityConstants.TOKEN_TYPE_ACCESS);
        String accToken = JwtUtils.createToken(claimsMap);
        // Jwt ref token
        claimsMap.put(SecurityConstants.USER_KEY, refToken);
        claimsMap.put(SecurityConstants.TOKEN_TYPE, SecurityConstants.TOKEN_TYPE_REFRESH);
        String refreshToken = JwtUtils.createToken(claimsMap);
        // 接口返回信息
        Map<String, Object> rspMap = new HashMap<String, Object>();
        rspMap.put("access_token", accToken);
        rspMap.put("expires_in", expireTime);
        rspMap.put("expires_time", expires_time);
        rspMap.put("refresh_token", refreshToken);
        rspMap.put("refresh_expires_in", refreshExpireTime);
        rspMap.put("refresh_expires_time", refresh_expires_time);

        return rspMap;
    }

可以看到，创建两个token，并返回。且两个token的信息中，仅userKey、过期时间不一致，其余信息都一致。两个token都作为userKey，存储用户信息到redis。refreshToken的过期时间长与accessToken的过期时间。

token刷新

根据refreshToken获取到用户信息

String userkey = JwtUtils.getUserKey(refreshToken);
return redisService.getCacheObject(getRefTokenKey(userkey));

从refreshToken中解析出userKey，然后取出登录用户信息。

创建accessToken，并建立新的accessToken与refreshToken的映射关系

public Map<String, Object> createAccessToken(LoginUser loginUser)
    {
        // 在创建新的accessToken前，判断之前的token是否存在，如果存在则删除
        String oldToken = loginUser.getToken();
        delAccessToken(oldToken);
        String token = IdUtils.fastUUID();
        long currentTimeMillis = System.currentTimeMillis();
        long expires_time = currentTimeMillis+ expireTime * MILLIS_MINUTE;

        loginUser.setIpaddr(IpUtils.getIpAddr(ServletUtils.getRequest()));
        loginUser.setLoginTime(System.currentTimeMillis());
        loginUser.setToken(token);
        loginUser.setExpireTime(expires_time);

        cacheAccessToken(loginUser);
        // Jwt存储信息
        Map<String, Object> claimsMap = new HashMap<>();
        claimsMap.put(SecurityConstants.USER_KEY, token);
        claimsMap.put(SecurityConstants.DETAILS_USER_ID, loginUser.getUserid());
        claimsMap.put(SecurityConstants.DETAILS_DEPT_ID, loginUser.getDeptId());
        claimsMap.put(SecurityConstants.DETAILS_USERNAME, loginUser.getUsername());
        claimsMap.put(SecurityConstants.TOKEN_TYPE, SecurityConstants.TOKEN_TYPE_ACCESS);
        String accToken = JwtUtils.createToken(claimsMap);
        // 接口返回信息
        Map<String, Object> rspMap = new HashMap<String, Object>();
        rspMap.put("access_token", accToken);
        rspMap.put("expires_in", expireTime);
        rspMap.put("expires_time", expires_time);
        return rspMap;
    }

token的刷新，实际我这里仅创建了新的accessToken，这里就要求将refreshToken的超时时间设置的足够长。这个需要根据业务实际需要综合考虑。实际也可以通过延长refreshToken的过期时间解决。

token的验证
    private static final String REFRESH_PATH = "/auth/refresh";
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpRequest.Builder mutate = request.mutate();

        String url = request.getURI().getPath();
        // 跳过不需要验证的路径
        if (StringUtils.matches(url, ignoreWhite.getWhites())) {
            return chain.filter(exchange);
        }
        String token = getToken(request);
        if (StringUtils.isEmpty(token)) {
            return unauthorizedResponse(exchange, "令牌不能为空");
        }
        Claims claims = JwtUtils.parseToken(token);
        if (claims == null) {
            return unauthorizedResponse(exchange, "令牌已过期或验证不正确！");
        }
        String userkey = JwtUtils.getUserKey(claims);
        String tokenType = JwtUtils.getTokenType(claims);
        boolean isLogin;
        if(SecurityConstants.TOKEN_TYPE_ACCESS.equalsIgnoreCase(tokenType)){
            isLogin = redisService.hasKey(getTokenKey(userkey));
        }else{
            // 如果时refreshToken，则url只能是刷新接口。
            if(!REFRESH_PATH.equalsIgnoreCase(url)){
                return unauthorizedResponse(exchange, "令牌验证失败");
            }
            isLogin = redisService.hasKey(getRefTokenKey(userkey));
        }
        if (!isLogin) {
            return accUnauthorizedResponse(exchange, "登录状态已过期");
        }
        String userid = JwtUtils.getUserId(claims);
        String username = JwtUtils.getUserName(claims);
        String deptId = JwtUtils.getDeptId(claims);
        if (StringUtils.isEmpty(userid) || StringUtils.isEmpty(username)) {
            return unauthorizedResponse(exchange, "令牌验证失败");
        }

        // 设置用户信息到请求
        addHeader(mutate, SecurityConstants.USER_KEY, userkey);
        addHeader(mutate, SecurityConstants.DETAILS_USER_ID, userid);
        addHeader(mutate, SecurityConstants.DETAILS_DEPT_ID, deptId);
        addHeader(mutate, SecurityConstants.DETAILS_USERNAME, username);
        // 内部请求来源参数清除
        removeHeader(mutate, SecurityConstants.FROM_SOURCE);
        return chain.filter(exchange.mutate().request(mutate.build()).build());
    }

这里为了严格控制，实际对accessToken、refreshToken增加了tokenType字段。限定refreshToken只能在访问/auth/refresh接口时访问。

以上步骤即完成了双token的改造。

最后

至于为什么改造为双token，以及双token有哪些好处？我在这里就不一一阐述了。
大家有兴趣可以看下这篇文章：http://www.mobiletrain.org/about/BBS/77900.html

独家de记忆
关注
专栏目录
双token校验机制
marko_zheng的博客
11-15 1万+
双token校验机制 什么是token token是客户端登陆的时候由服务端生成，之后每次请求都需要携带token进行请求。校验用户身份呢的作用 为什么使用token 减少敏感信息的传递 可以校验用户身份的准确性以及有效期 单token登录流程以及请求校验流程 注意 token是使用base64的形式进行加密的 是有一部分存储在客户端中，所以，token中不建议存放敏感信息 双token校验机制 场景设想： ​ 用户正在app或者应用中操作 token突然过期，此时用户不得不返回登陆界面，重新进行一
双Token校验机制
swk1300524046的博客
10-17 847
双Toekn机制，token
若依 ruoyi 单体双token（url区分）
yangziqi098的博客
08-11 402
若依单体工程，双token，主逻辑不动，放行全部自定义拦截接口，再单独拦截自定义url，登录、获取登录用户信息
若依登录流程及如何处理token刷新
weixin_44315397的博客
10-11 544
若依的登录流程，以及Token刷新流程
山东大学项目实训（二十五）—— 结合请求拦截和响应拦截实现双token机制
long99920的博客
05-08 1292
实现双token，解决token过期存在的并发请求问题
【Vue3项目】登录注册--双Token机制
aDiaoYa_的博客
08-12 2176
最近同项目的伙伴告诉我们一个“新词汇”——双Token登录机制，emmmmm，确实没了解过，据说是在实现token长期有效的同时，防止token被第三方盗用，提高用户信息的安全性。于是，在了解了大概之后，我找了很多篇文章去学习双Token的实现过程，总结如下。一般我们实现用户登录是：用户登录向服务端发送账号密码信息，登录失败返回客户端重新填写并发送用户信息；登录成功服务端生成token并返回token给客户端，客户端将token存本地。那么问题来了，token的有效期应该是多久呢？
ruoyi-cloud项目的上云 关于kubesphere的使用细节
05-23
《ruoyi-cloud项目上云：Kubernetes与KubeSphere实战》 在现代云计算环境中，ruoyi-cloud项目上云的实现通常涉及到容器化技术，如Kubernetes（K8S）以及云原生平台KubeSphere。本文将深入探讨如何通过KubeSphere...
RuoYi-Cloud-Plus 微服务通用权限管理系统 重写 RuoYi-Cloud 全方位升级(不兼容原框架)
最新发布
11-17
微服务管理系统 重写RuoYi-Cloud所有功能 整合 SpringCloudAlibaba、Dubbo3.0、Sa-Token、Mybatis-Plus、MQ、Flowable、ES、Docker 全方位升级
RuoYi-Cloud-Plus 微服务通用权限管理系统， 重写RuoYi-Cloud所有功能
05-20
微服务管理系统 重写RuoYi-Cloud所有功能 整合 SpringCloudAlibaba Dubbo3.0 Sa-Token Mybatis-Plus MQ OSS ES Xxl-Job Docker 全方位升级
RuoYi-Cloud
xinyi_java的博客
09-27 3819
目录 介绍 快速了解 环境部署 项目介绍 后台手册 前端手册 功能组件 模板引擎 组件文档 插件集成 介绍 基于Spring Boot、Spring Cloud & Alibaba的微服务的权限管理系统。 RuoYi-Cloud 是一个 Java EE 分布式微服务架构平台，基于经典技术组合（Spring Boot、Spring Cloud & Alibaba、Vue、Element），内置模块如：部门管理、角色用户、菜单及按钮授权、数据权限、系统参
双token方案
奔跑的菜鸡
08-24 434
双token方案
双token实现token超时策略示例
09-04
用于restful的app应用无状态无sesion登录示例,需要的朋友可以参考下
山东大学项目实训（二）—— 请求封装和双TOKEN机制
long99920的博客
04-04 2693
山东大学项目实训
双Token方案实现Token自动续期（基于springboot+vue前后端分离项目）
qq_44286009的博客
06-10 2867
jwt理论介绍springboot+vue项目中使用jwt实现登录认证本篇文章的代码是在springboot+vue项目中使用jwt实现登录认证的基础上实现的Token自动续期的功能。双token解决方案是一种用于增强用户登录安全性和提升用户体验的认证机制。它主要涉及两个令牌：访问令牌（accessToken）和刷新令牌（refreshToken）。
双 Token 无感刷新机制实现
Hhzzy99的博客
07-07 1277
基于vue Java实现双token的无感刷新
基于spring security实现vue2前后端分离的双token刷新机制（完整代码详解，含金量拉满！）
qq_60614034的博客
03-27 3948
网上许多博主，放张图片讲讲双token原理就发出来，没有含金量，还耽误大伙的时间。但是我不一样，我将会把代码的每一步骤都讲明白，并把详细代码放出来，让每一位看到的人都能跟着一步步自己搞，弄明白每一步的执行流程。要是觉得我跟那些博主一样，也是水文章，互相抄袭，请在评论区直接开骂。如果是第一次接触security请看这篇spring security单token前后端分离详细配置。
JWT双令牌（双token）实现登录验证
weixin_43973161的博客
09-23 6786
就是在登陆操作之后由服务端返回两个token：accessToken和refreshToken，在之后的验证登录态的操作中使用这两个token进行验证，其中accessToken的过期时间相当短，refreshToken的过期时间相对于accessToken而言相当长，且会不断的刷新。我们除了access token也就是这个接入token啊。或者说资源访问的这个之外，我们加一个这个刷新token，那么这个刷新token它的有效时长一般会比我们的接入token的时间长很多。就比如说刚才说到了这个接入tok
token机制
qq_41818857的博客
09-25 691
1、token的定义： Token是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Token并返回给客户端，以后客户端向服务器发送请求时，带上Token即可，无需再次带上用户名和密码。 2、为什么要用token？ 产生背景: 试想下如果有人知道了你的请求接口，如果他在不登录的情况下，恶意调用你的删除接口，随意删除你的数据，这样是不是会给你造成很大的麻烦，所以每次你调用接口时后台需要验证你是否登录，这就是token产生的背景。 Token是在客户端频繁向服务端请求数据，服
模仿某B长期登录有效之双Token机制
weixin_53690059的博客
03-15 1170
如需demo案例请私信我。小程序地址：https://github.com/CaseOfShe/school演示地址：https://www.bilibili.com/video/BV1q3411g71P。
ruoyi-cloud部署docker
04-26
Ruoyi-Cloud是一个基于Spring Cloud的微服务框架，可以使用Docker进行部署。下面是Ruoyi-Cloud部署Docker的步骤： 1. 首先，确保你已经安装了Docker和Docker Compose。如果没有安装，可以参考Docker官方文档进行安装。 2. 下载Ruoyi-Cloud的代码，可以从GitHub上找到Ruoyi-Cloud的仓库并下载代码。 3. 在项目根目录下创建一个名为`docker-compose.yml`的文件，并在该文件中定义Docker容器的配置。以下是一个示例的`docker-compose.yml`文件： ```yaml version: '3' services: ruoyi-cloud: image: openjdk:8-jdk-alpine ports: - 8080:8080 volumes: - ./ruoyi-cloud:/app command: java -jar /app/ruoyi-cloud.jar depends_on: - mysql mysql: image: mysql:5.7 ports: - 3306:3306 environment: - MYSQL_ROOT_PASSWORD=root - MYSQL_DATABASE=ruoyi_cloud ``` 在上面的示例中，我们定义了两个服务：`ruoyi-cloud`和`mysql`。`ruoyi-cloud`服务使用了OpenJDK 8的镜像，并将容器的8080端口映射到主机的8080端口。`mysql`服务使用了MySQL 5.7的镜像，并将容器的3306端口映射到主机的3306端口。 4. 在项目根目录下执行以下命令启动Docker容器： ``` docker-compose up -d ``` 这将会启动Ruoyi-Cloud和MySQL的容器，并在后台运行。 5. 等待一段时间，当容器启动完成后，你可以通过访问`http://localhost:8080`来访问Ruoyi-Cloud的应用程序。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值