floraachy/sa-token
1
0
Fork 0
mirror of https://gitee.com/dromara/sa-token.git synced 2024-11-29 18:37:49 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Id-Token 模块更名为 Same-Token

Browse Source
This commit is contained in:
click33 2022-10-24 12:25:22 +08:00
parent 00886066e3
commit 2dc0a44dfe
34 changed files with 564 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
sa-token-core/src/main/java/cn/dev33/satoken/SaManager.java
View File

@ -13,6 +13,7 @@ import cn.dev33.satoken.dao.SaTokenDaoDefaultImpl;
import cn.dev33.satoken.exception.SaTokenException;
import cn.dev33.satoken.json.SaJsonTemplate;
import cn.dev33.satoken.json.SaJsonTemplateDefaultImpl;
import cn.dev33.satoken.same.SaSameTemplate;
import cn.dev33.satoken.sign.SaSignTemplate;
import cn.dev33.satoken.sign.SaSignTemplateDefaultImpl;
import cn.dev33.satoken.stp.StpInterface;
@ -192,6 +193,24 @@ public class SaManager {
return saSignTemplate;
}
/**
* Same-Token Bean
*/
private volatile static SaSameTemplate saSameTemplate;
public static void setSaSameTemplate(SaSameTemplate saSameTemplate) {
SaManager.saSameTemplate = saSameTemplate;
}
public static SaSameTemplate getSaSameTemplate() {
if (saSameTemplate == null) {
synchronized (SaManager.class) {
if (saSameTemplate == null) {
setSaSameTemplate(new SaSameTemplate());
}
}
}
return saSameTemplate;
}
/**
* StpLogic集合, 记录框架所有成功初始化的StpLogic
*/

2
sa-token-core/src/main/java/cn/dev33/satoken/application/SaApplication.java
View File

@ -63,7 +63,7 @@ public class SaApplication implements SaSetValueInterface {
public List<String> keys() {
// 查出来
String prefix = splicingDataKey("");
List<String> list = SaManager.getSaTokenDao().searchData(prefix, "", -1, 0, true);
List<String> list = SaManager.getSaTokenDao().searchData(prefix, "", 0, -1, true);
// 裁减掉固定前缀
int prefixLength = prefix.length();

102
sa-token-core/src/main/java/cn/dev33/satoken/config/SaTokenConfig.java
View File

@ -75,11 +75,6 @@ public class SaTokenConfig implements Serializable {
*/
private String jwtSecretKey;
/**
* Id-Token的有效期 (单位: 秒)
*/
private long idTokenTimeout = 60 * 60 * 24;
/**
* Http Basic 认证的账号和密码
*/
@ -88,8 +83,14 @@ public class SaTokenConfig implements Serializable {
/** 配置当前项目的网络访问地址 */
private String currDomain;
/** 是否校验Id-Token（部分rpc插件有效） */
private Boolean checkIdToken = false;
/**
* Same-Token 的有效期 (单位: 秒)
*/
private long sameTokenTimeout = 60 * 60 * 24;
/** 是否校验Same-Token（部分rpc插件有效） */
private Boolean checkSameToken = false;
/**
* Cookie配置对象
@ -389,22 +390,6 @@ public class SaTokenConfig implements Serializable {
return this;
}
/**
* @return Id-Token的有效期 (单位: 秒)
*/
public long getIdTokenTimeout() {
return idTokenTimeout;
}
/**
* @param idTokenTimeout Id-Token的有效期 (单位: 秒)
* @return 对象自身
*/
public SaTokenConfig setIdTokenTimeout(long idTokenTimeout) {
this.idTokenTimeout = idTokenTimeout;
return this;
}
/**
* @return Http Basic 认证的账号和密码
*/
@ -438,18 +423,34 @@ public class SaTokenConfig implements Serializable {
}
/**
* @return 是否校验Id-Token（部分rpc插件有效）
* @return Same-Token 的有效期 (单位: 秒)
*/
public Boolean getCheckIdToken() {
return checkIdToken;
public long getSameTokenTimeout() {
return sameTokenTimeout;
}
/**
* @param checkIdToken 是否校验Id-Token（部分rpc插件有效）
* @param sameTokenTimeout Same-Token 的有效期 (单位: 秒)
* @return 对象自身
*/
public SaTokenConfig setCheckIdToken(Boolean checkIdToken) {
this.checkIdToken = checkIdToken;
public SaTokenConfig setSameTokenTimeout(long sameTokenTimeout) {
this.sameTokenTimeout = sameTokenTimeout;
return this;
}
/**
* @return 是否校验Same-Token（部分rpc插件有效）
*/
public Boolean getCheckSameToken() {
return checkSameToken;
}
/**
* @param checkSameToken 是否校验Same-Token（部分rpc插件有效）
* @return 对象自身
*/
public SaTokenConfig setCheckSameToken(Boolean checkSameToken) {
this.checkSameToken = checkSameToken;
return this;
}
@ -490,10 +491,10 @@ public class SaTokenConfig implements Serializable {
+ ", isPrint=" + isPrint
+ ", isLog=" + isLog
+ ", jwtSecretKey=" + jwtSecretKey
+ ", idTokenTimeout=" + idTokenTimeout
+ ", basic=" + basic
+ ", currDomain=" + currDomain
+ ", checkIdToken=" + checkIdToken
+ ", sameTokenTimeout=" + sameTokenTimeout
+ ", checkSameToken=" + checkSameToken
+ ", cookie=" + cookie
+ "]";
}
@ -519,5 +520,44 @@ public class SaTokenConfig implements Serializable {
return this;
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 getSameTokenTimeout() ，使用方式保持不变 </h1>
* @return Id-Token的有效期 (单位: 秒)
*/
@Deprecated
public long getIdTokenTimeout() {
return sameTokenTimeout;
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 setSameTokenTimeout() ，使用方式保持不变 </h1>
* @param idTokenTimeout Id-Token的有效期 (单位: 秒)
* @return 对象自身
*/
@Deprecated
public SaTokenConfig setIdTokenTimeout(long idTokenTimeout) {
this.sameTokenTimeout = idTokenTimeout;
return this;
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 getCheckSameToken() ，使用方式保持不变 </h1>
* @return 是否校验Id-Token（部分rpc插件有效）
*/
@Deprecated
public Boolean getCheckIdToken() {
return checkSameToken;
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 setCheckSameToken() ，使用方式保持不变 </h1>
* @param checkIdToken 是否校验Id-Token（部分rpc插件有效）
* @return 对象自身
*/
@Deprecated
public SaTokenConfig setCheckIdToken(Boolean checkIdToken) {
this.checkSameToken = checkIdToken;
return this;
}
}

2
sa-token-core/src/main/java/cn/dev33/satoken/exception/IdTokenInvalidException.java
View File

@ -1,10 +1,12 @@
package cn.dev33.satoken.exception;
/**
* <h1> 本类设计已过时，未来版本可能移除此类，请及时更换为 SameTokenInvalidException ，使用方式保持不变 </h1>
* 一个异常：代表提供的 Id-Token 无效
*
* @author kong
*/
@Deprecated
public class IdTokenInvalidException extends SaTokenException {
/**

24
sa-token-core/src/main/java/cn/dev33/satoken/exception/SameTokenInvalidException.java Normal file
View File

@ -0,0 +1,24 @@
package cn.dev33.satoken.exception;
/**
* 一个异常：代表提供的 Same-Token 无效
*
* @author kong
* @since 2022-10-24
*/
public class SameTokenInvalidException extends SaTokenException {
/**
* 序列化版本号
*/
private static final long serialVersionUID = 6806129545290130144L;
/**
* 一个异常：代表提供的 Same-Token 无效
* @param message 异常描述
*/
public SameTokenInvalidException(String message) {
super(message);
}
}

3
sa-token-core/src/main/java/cn/dev33/satoken/id/SaIdTemplate.java
View File

@ -6,11 +6,14 @@ import cn.dev33.satoken.exception.IdTokenInvalidException;
import cn.dev33.satoken.util.SaFoxUtil;
/**
* <h1> 本类设计已过时，未来版本可能移除此类，请及时更换为 SaSameTemplate ，使用方式保持不变 </h1>
*
* Sa-Token-Id 身份凭证模块
* <p> 身份凭证的获取与校验，可用于微服务内部调用鉴权
* @author kong
*
*/
@Deprecated
public class SaIdTemplate {
/**

3
sa-token-core/src/main/java/cn/dev33/satoken/id/SaIdUtil.java
View File

@ -1,10 +1,13 @@
package cn.dev33.satoken.id;
/**
* <h1> 本类设计已过时，未来版本可能移除此类，请及时更换为 SaSameUtil ，使用方式保持不变 </h1>
*
* Sa-Token-Id 身份凭证模块-工具类
* @author kong
*
*/
@Deprecated
public class SaIdUtil {
private SaIdUtil(){}

174
sa-token-core/src/main/java/cn/dev33/satoken/same/SaSameTemplate.java Normal file
View File

@ -0,0 +1,174 @@
package cn.dev33.satoken.same;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.context.SaHolder;
import cn.dev33.satoken.exception.SameTokenInvalidException;
import cn.dev33.satoken.util.SaFoxUtil;
/**
* Sa Same-Token 同源系统身份认证模块 - 模板方法类
*
* <p> 解决同源系统互相调用时的身份认证校验， 例如：微服务网关请求转发鉴权、微服务RPC调用鉴权
*
* @author kong
* @since 2022-10-24
*/
public class SaSameTemplate {
/**
* 提交 Same-Token 时，建议使用的参数名称
*/
public static final String SAME_TOKEN = "SA-SAME-TOKEN";
// -------------------- 获取 & 校验
/**
* 获取当前 Same-Token, 如果不存在，则立即创建并返回
* @return /
*/
public String getToken() {
String currentToken = getTokenNh();
if(SaFoxUtil.isEmpty(currentToken)) {
// 注意这里的自刷新不能做到高并发可用
currentToken = refreshToken();
}
return currentToken;
}
/**
* 判断一个 Same-Token 是否有效
* @param token /
* @return /
*/
public boolean isValid(String token) {
// 1、 如果传入的 token 为空，则立即返回 false
if(SaFoxUtil.isEmpty(token)) {
return false;
}
// 2、 验证当前 Same-Token 及 Past-Same-Token
return token.equals(getToken()) || token.equals(getPastTokenNh());
}
/**
* 校验一个 Same-Token 是否有效 (如果无效则抛出异常)
* @param token /
*/
public void checkToken(String token) {
if(isValid(token) == false) {
token = (token == null ? "" : token);
throw new SameTokenInvalidException("无效Same-Token：" + token);
}
}
/**
* 校验当前 Request 上下文提供的 Same-Token 是否有效 (如果无效则抛出异常)
*/
public void checkCurrentRequestToken() {
checkToken(SaHolder.getRequest().getHeader(SAME_TOKEN));
}
/**
* 刷新一次 Same-Token (注意集群环境中不要多个服务重复调用)
* @return 刷新后产生的新 Same-Token
*/
public String refreshToken() {
// 1. 先将当前 Same-Token 写入到 Past-Same-Token 中
String sameToken = getTokenNh();
if(SaFoxUtil.isEmpty(sameToken) == false) {
savePastToken(sameToken, getTokenTimeout());
}
// 2. 再刷新当前 Same-Token
String newSameToken = createToken();
saveToken(newSameToken);
// 3. 返回新的 Same-Token
return newSameToken;
}
// ------------------------------ 保存Token
/**
* 保存 Same-Token
* @param token /
*/
public void saveToken(String token) {
if(SaFoxUtil.isEmpty(token)) {
return;
}
SaManager.getSaTokenDao().set(splicingTokenSaveKey(), token, SaManager.getConfig().getSameTokenTimeout());
}
/**
* 保存 Past-Same-Token
* @param token token
* @param timeout 有效期（单位：秒）
*/
public void savePastToken(String token, long timeout){
if(SaFoxUtil.isEmpty(token)) {
return;
}
SaManager.getSaTokenDao().set(splicingPastTokenSaveKey(), token, timeout);
}
// -------------------- 获取Token
/**
* 获取 Same-Token，不做任何处理
* @return /
*/
public String getTokenNh() {
return SaManager.getSaTokenDao().get(splicingTokenSaveKey());
}
/**
* 获取 Past-Same-Token，不做任何处理
* @return /
*/
public String getPastTokenNh() {
return SaManager.getSaTokenDao().get(splicingPastTokenSaveKey());
}
/**
* 获取 Same-Token 的剩余有效期 (单位：秒)
* @return /
*/
public long getTokenTimeout() {
return SaManager.getSaTokenDao().getTimeout(splicingTokenSaveKey());
}
// -------------------- 创建Token
/**
* 创建一个 Same-Token
* @return Token
*/
public String createToken() {
return SaFoxUtil.getRandomString(64);
}
// -------------------- 拼接key
/**
* 拼接key：Same-Token 的存储 key
* @return key
*/
public String splicingTokenSaveKey() {
return SaManager.getConfig().getTokenName() + ":var:same-token";
}
/**
* 拼接key：次级 Same-Token 的存储 key
* @return key
*/
public String splicingPastTokenSaveKey() {
return SaManager.getConfig().getTokenName() + ":var:past-same-token";
}
}

83
sa-token-core/src/main/java/cn/dev33/satoken/same/SaSameUtil.java Normal file
View File

@ -0,0 +1,83 @@
package cn.dev33.satoken.same;
import cn.dev33.satoken.SaManager;
/**
* Sa Same-Token 同源系统身份认证模块 - 工具类
*
* <p> 解决同源系统互相调用时的身份认证校验， 例如：微服务网关请求转发鉴权、微服务RPC调用鉴权
*
* @author kong
* @since 2022-10-24
*/
public class SaSameUtil {
private SaSameUtil(){}
/**
* 提交 Same-Token 时，建议使用的参数名称
*/
public static final String SAME_TOKEN = SaSameTemplate.SAME_TOKEN;
// -------------------- 获取 & 校验
/**
* 获取当前 Same-Token, 如果不存在，则立即创建并返回
* @return /
*/
public static String getToken() {
return SaManager.getSaSameTemplate().getToken();
}
/**
* 判断一个 Same-Token 是否有效
* @param token /
* @return /
*/
public static boolean isValid(String token) {
return SaManager.getSaSameTemplate().isValid(token);
}
/**
* 校验一个 Same-Token 是否有效 (如果无效则抛出异常)
* @param token /
*/
public static void checkToken(String token) {
SaManager.getSaSameTemplate().checkToken(token);
}
/**
* 校验当前 Request 上下文提供的 Same-Token 是否有效 (如果无效则抛出异常)
*/
public static void checkCurrentRequestToken() {
SaManager.getSaSameTemplate().checkCurrentRequestToken();
}
/**
* 刷新一次 Same-Token (注意集群环境中不要多个服务重复调用)
* @return 刷新后产生的新 Same-Token
*/
public static String refreshToken() {
return SaManager.getSaSameTemplate().refreshToken();
}
// -------------------- 获取Token
/**
* 获取 Same-Token，不做任何处理
* @return /
*/
public static String getTokenNh() {
return SaManager.getSaSameTemplate().getTokenNh();
}
/**
* 获取 Past-Same-Token，不做任何处理
* @return /
*/
public static String getPastTokenNh() {
return SaManager.getSaSameTemplate().getPastTokenNh();
}
}

2
sa-token-doc/_sidebar.md
View File

@ -56,7 +56,7 @@
- **微服务**
- [分布式Session会话](/micro/dcs-session)
- [网关统一鉴权](/micro/gateway-auth)
- [内部服务外网隔离](/micro/id-token)
- [内部服务外网隔离](/micro/same-token)
- [依赖引入说明](/micro/import-intro)
- **插件**

84
sa-token-doc/micro/id-token.md → sa-token-doc/micro/same-token.md
View File

@ -14,9 +14,9 @@
Sa-Token提供两种解决方案：
1. 使用 OAuth2.0 模式的凭证式，将 Client-Token 用作各个服务的身份凭证进行权限校验
2. 使用 Id-Token 模块提供的身份校验能力，完成服务间的权限认证
2. 使用 Same-Token 模块提供的身份校验能力，完成服务间的权限认证
本篇主要讲解方案二 `Id-Token` 模块的整合步骤，其鉴权流程与 OAuth2.0 类似，不过使用方式上更加简洁（希望使用方案一的同学可参考Sa-OAuth2模块，此处不再赘述）
本篇主要讲解方案二 `Same-Token` 模块的整合步骤，其鉴权流程与 OAuth2.0 类似，不过使用方式上更加简洁（希望使用方案一的同学可参考Sa-OAuth2模块，此处不再赘述）
### 二、网关转发鉴权
@ -88,12 +88,12 @@ implementation 'org.apache.commons:commons-pool2'
```
<!---------------------------- tabs:end ------------------------------>
##### 2、网关处添加Id-Token
##### 2、网关处添加Same-Token
为网关添加全局过滤器：
``` java
/**
* 全局过滤器，为请求添加 Id-Token
* 全局过滤器，为请求添加 Same-Token
*/
@Component
public class ForwardAuthFilter implements GlobalFilter {
@ -102,15 +102,15 @@ public class ForwardAuthFilter implements GlobalFilter {
ServerHttpRequest newRequest = exchange
.getRequest()
.mutate()
// 为请求追加 Id-Token 参数
.header(SaIdUtil.ID_TOKEN, SaIdUtil.getToken())
// 为请求追加 Same-Token 参数
.header(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken())
.build();
ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();
return chain.filter(newExchange);
}
}
```
此过滤器会为 Request 请求头追加 `Id-Token` 参数，这个参数会被转发到子服务
此过滤器会为 Request 请求头追加 `Same-Token` 参数，这个参数会被转发到子服务
##### 3、在子服务里校验参数
@ -129,9 +129,9 @@ public class SaTokenConfigure implements WebMvcConfigurer {
.addInclude("/**")
.addExclude("/favicon.ico")
.setAuth(obj -> {
// 校验 Id-Token 身份凭证 —— 以下两句代码可简化为：SaIdUtil.checkCurrentRequestToken();
String token = SaHolder.getRequest().getHeader(SaIdUtil.ID_TOKEN);
SaIdUtil.checkToken(token);
// 校验 Same-Token 身份凭证 —— 以下两句代码可简化为：SaSameUtil.checkCurrentRequestToken();
String token = SaHolder.getRequest().getHeader(SaSameUtil.SAME_TOKEN);
SaSameUtil.checkToken(token);
})
.setError(e -> {
return SaResult.error(e.getMessage());
@ -143,14 +143,14 @@ public class SaTokenConfigure implements WebMvcConfigurer {
启动网关与子服务，访问测试：
> 如果通过网关转发，可以正常访问，直接访问子服务会提示：`无效Id-Token：xxx`
> 如果通过网关转发，可以正常访问，直接访问子服务会提示：`无效Same-Token：xxx`
### 三、服务内部调用鉴权
有时候我们需要在一个服务调用另一个服务的接口，这也是需要添加`Id-Token`作为身份凭证的
有时候我们需要在一个服务调用另一个服务的接口，这也是需要添加`Same-Token`作为身份凭证的
在服务里添加 Id-Token 流程与网关类似，我们以RPC框架 `Feign` 为例：
在服务里添加 Same-Token 流程与网关类似，我们以RPC框架 `Feign` 为例：
##### 1、首先在调用方添加 FeignInterceptor
``` java
@ -159,10 +159,10 @@ public class SaTokenConfigure implements WebMvcConfigurer {
*/
@Component
public class FeignInterceptor implements RequestInterceptor {
// 为 Feign 的 RCP调用 添加请求头Id-Token
// 为 Feign 的 RCP调用 添加请求头Same-Token
@Override
public void apply(RequestTemplate requestTemplate) {
requestTemplate.header(SaIdUtil.ID_TOKEN, SaIdUtil.getToken());
requestTemplate.header(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken());
}
}
```
@ -189,63 +189,63 @@ public interface SpCfgInterface {
被调用方的代码无需更改（按照网关转发鉴权处的代码注册全局过滤器），保持启动测试即可
### 四、Id-Token 模块详解
### 四、Same-Token 模块详解
Id-Token —— 专门解决身份凭证问题的一个模块，它的作用不仅局限于微服务调用场景
Same-Token —— 专门解决同源系统互相调用时的身份认证校验，它的作用不仅局限于微服务调用场景
基本使用流程为：服务调用方获取Token，提交到请求中，被调用方取出Token进行校验：Token一致则校验通过，否则拒绝服务
首先我们预览一下此模块的相关API：
``` java
// 获取当前Id-Token
SaIdUtil.getToken();
// 获取当前Same-Token
SaSameUtil.getToken();
// 判断一个Id-Token是否有效
SaIdUtil.isValid(token);
// 判断一个Same-Token是否有效
SaSameUtil.isValid(token);
// 校验一个Id-Token是否有效 (如果无效则抛出异常)
SaIdUtil.checkToken(token);
// 校验一个Same-Token是否有效 (如果无效则抛出异常)
SaSameUtil.checkToken(token);
// 校验当前Request提供的Id-Token是否有效 (如果无效则抛出异常)
SaIdUtil.checkCurrentRequestToken();
// 校验当前Request提供的Same-Token是否有效 (如果无效则抛出异常)
SaSameUtil.checkCurrentRequestToken();
// 刷新一次Id-Token (注意集群环境中不要多个服务重复调用)
SaIdUtil.refreshToken();
// 刷新一次Same-Token (注意集群环境中不要多个服务重复调用)
SaSameUtil.refreshToken();
// 在 Request 上储存 Id-Token 时建议使用的key
SaIdUtil.ID_TOKEN;
// 在 Request 上储存 Same-Token 时建议使用的key
SaSameUtil.SAME_TOKEN;
```
##### 1、疑问：这个Token保存在什么地方？有没有泄露的风险？Token为永久有效还是临时有效？
Id-Token 默认随 Sa-Token 数据一起保存在Redis中，理论上不会存在泄露的风险，每个Token默认有效期只有一天
Same-Token 默认随 Sa-Token 数据一起保存在Redis中，理论上不会存在泄露的风险，每个Token默认有效期只有一天
##### 2、如何主动刷新Id-Token，例如：五分钟、两小时刷新一次？
Id-Token 刷新间隔越短，其安全性越高，每个Token的默认有效期为一天，在一天后再次获取会自动产生一个新的Token
##### 2、如何主动刷新Same-Token，例如：五分钟、两小时刷新一次？
Same-Token 刷新间隔越短，其安全性越高，每个Token的默认有效期为一天，在一天后再次获取会自动产生一个新的Token
!> 需要注意的一点是：Id-Token默认的自刷新机制，并不能做到高并发可用，多个服务一起触发Token刷新可能会造成毫秒级的短暂服务失效，其只能适用于 项目开发阶段 或 低并发业务场景
!> 需要注意的一点是：Same-Token默认的自刷新机制，并不能做到高并发可用，多个服务一起触发Token刷新可能会造成毫秒级的短暂服务失效，其只能适用于 项目开发阶段 或 低并发业务场景
因此在微服务架构下，我们需要有专门的机制主动刷新Id-Token，保证其高可用
因此在微服务架构下，我们需要有专门的机制主动刷新Same-Token，保证其高可用
例如，我们可以专门起一个服务，使用定时任务来刷新Id-Token
例如，我们可以专门起一个服务，使用定时任务来刷新Same-Token
``` java
/**
* Id-Token，定时刷新
* Same-Token，定时刷新
*/
@Configuration
public class SaIdTokenRefreshTask {
// 从 0 分钟开始 每隔 5 分钟执行一次 Id-Token
public class SaSameTokenRefreshTask {
// 从 0 分钟开始 每隔 5 分钟执行一次 Same-Token
@Scheduled(cron = "0 0/5 * * * ? ")
public void refreshToken(){
SaIdUtil.refreshToken();
SaSameUtil.refreshToken();
}
}
```
以上的cron表达式刷新间隔可以配置为`五分钟`、`十分钟` 或 `两小时`，只要低于Id-Token的有效期（默认为一天）即可。
以上的cron表达式刷新间隔可以配置为`五分钟`、`十分钟` 或 `两小时`，只要低于Same-Token的有效期（默认为一天）即可。
##### 3、如果网关携带token转发的请求在落到子服务的节点上时，恰好刷新了token，导致鉴权未通过怎么办？
Id-Token 模块在设计时，充分考虑到了这一点，在每次刷新 Token 时，旧 Token 会被作为次级 Token 存储起来，
只要网关携带的 Token 符合新旧 Token 其一即可通过认证，直至下一次刷新，新 Token 再次作为次级 Token 将此替换掉
Same-Token 模块在每次刷新 Token 时，旧 Token 会被作为次级 Token 存储起来，
只要网关携带的 Token 符合新旧 Token 其一即可通过认证，直至下一次刷新，新 Token 再次作为次级 Token 将此替换掉。

2
sa-token-doc/more/noun-intro.md
View File

@ -13,7 +13,7 @@ Sa-Token 无意发明任何晦涩概念提升逼格，但在处理 issue 、Q群
- temp-token：指通过 `SaTempUtil.createToken()` 临时验证模块产生的Token，也称：临时Token。
- Access-Token：在 OAuth2 模块产生的身份令牌，也称：访问令牌、资源令牌。
- Refresh-Token：在 OAuth2 模块产生的刷新令牌，也称：刷新令牌。
- Id-Token：在 SaIdUtil 模块生成的Token令牌，用于提供子服务外网隔离功能。
- Same-Token：在 SaSameUtil 模块生成的Token令牌，用于提供子服务外网隔离功能。
#### 两种过期时间：

26
sa-token-doc/plugin/dubbo-extend.md
View File

@ -60,9 +60,9 @@ implementation 'cn.dev33:sa-token-context-dubbo:${sa.top.version}'
### RPC调用鉴权
在之前的 [Id-Token](/micro/id-token) 章节，我们演示了基于 Feign 的 RPC 调用鉴权，下面我们演示一下在 Dubbo 中如何集成 Id-Token 模块。
在之前的 [Same-Token](/micro/same-token) 章节，我们演示了基于 Feign 的 RPC 调用鉴权，下面我们演示一下在 Dubbo 中如何集成 Same-Token 模块。
其实思路和 Feign 模式一致，在 [ 调用端 ] 追加 Id-Token 参数，在 [ 被调用端 ] 校验这个 Id-Token 参数：
其实思路和 Feign 模式一致，在 [ 调用端 ] 追加 Same-Token 参数，在 [ 被调用端 ] 校验这个 Same-Token 参数：
- 校验通过：调用成功。
- 校验不通过：通过失败，抛出异常。
@ -78,18 +78,18 @@ implementation 'cn.dev33:sa-token-context-dubbo:${sa.top.version}'
``` yaml
sa-token:
# 打开 RPC 调用鉴权
check-id-token: true
check-same-token: true
```
<!------------- tab:properties 风格 ------------->
``` properties
# 打开 RPC 调用鉴权
sa-token.check-id-token=true
sa-token.check-same-token=true
```
<!---------------------------- tabs:end ---------------------------->
##### 方式二、自建 Dubbo 过滤器校验
此方式略显繁琐，好处是除了Id-Token，我们还可以添加其它自定义参数 (attachment)。
此方式略显繁琐，好处是除了Same-Token，我们还可以添加其它自定义参数 (attachment)。
1、在 [ 调用端 ] 的 `\resources\META-INF\dubbo\` 目录新建 `org.apache.dubbo.rpc.Filter` 文件
``` html
@ -105,7 +105,7 @@ import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
/**
* Sa-Token 整合 Dubbo Consumer端过滤器
@ -116,8 +116,8 @@ public class DubboConsumerFilter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
// 追加 Id-Token 参数
RpcContext.getContext().setAttachment(SaIdUtil.ID_TOKEN, SaIdUtil.getToken());
// 追加 Same-Token 参数
RpcContext.getContext().setAttachment(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken());
// 如果有其他自定义附加数据，如租户
// RpcContext.getContext().setAttachment("tenantContext", tenantContext);
@ -144,7 +144,7 @@ import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
/**
* Sa-Token 整合 Dubbo Provider端过滤器
@ -155,9 +155,9 @@ public class DubboProviderFilter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
// 取出 Id-Token 进行校验
String idToken = invocation.getAttachment(SaIdUtil.ID_TOKEN);
SaIdUtil.checkToken(idToken);
// 取出 Same-Token 进行校验
String sameToken = invocation.getAttachment(SaSameUtil.SAME_TOKEN);
SaSameUtil.checkToken(sameToken);
// 取出其他自定义附加数据
// TenantContext tenantContext = invocation.getAttachment("tenantContext");
@ -170,5 +170,5 @@ public class DubboProviderFilter implements Filter {
```
然后我们就可以进行安全的 RPC 调用了，不带有 Id-Token 参数的调用都会抛出异常，无法调用成功。
然后我们就可以进行安全的 RPC 调用了，不带有 Same-Token 参数的调用都会抛出异常，无法调用成功。

8
sa-token-doc/plugin/grpc-extend.md
View File

@ -8,7 +8,7 @@
1. 在 [ 被调用端 ] 安全的调用 Sa-Token 相关 API。
2. 在 [ 调用端 ] 登录的会话，其登录状态可以自动传递到 [ 被调用端 ] ；在 [ 被调用端 ] 登录的会话，其登录状态可以自动回传到 [ 调用端 ]
3. id-token 安全校验
3. Same-Token 安全校验
---
和dubbo插件一样，具有以下限制：
@ -38,7 +38,7 @@ implementation 'cn.dev33:sa-token-context-grpc:${sa.top.version}'
---
### 开启id-token校验：
### 开启 Same-Token 校验：
直接在 `application.yml` 配置即可：
<!---------------------------- tabs:start ---------------------------->
@ -46,11 +46,11 @@ implementation 'cn.dev33:sa-token-context-grpc:${sa.top.version}'
``` yaml
sa-token:
# 打开 RPC 调用鉴权
check-id-token: true
check-same-token: true
```
<!------------- tab:properties 风格 ------------->
``` properties
# 打开 RPC 调用鉴权
sa-token.check-id-token=true
sa-token.check-same-token=true
```
<!---------------------------- tabs:end ---------------------------->

4
sa-token-doc/use/config.md
View File

@ -134,10 +134,10 @@ public class SaTokenConfigure {
| isPrint | Boolean | true | 是否在初始化配置时打印版本字符画 |
| isLog | Boolean | false | 是否打印操作日志 |
| jwtSecretKey | String | null | jwt秘钥 （只有集成 `sa-token-temp-jwt` 模块时此参数才会生效），[参考：和 jwt 集成](/plugin/jwt-extend) |
| idTokenTimeout | long | 86400 | Id-Token的有效期 （单位: 秒），[参考：内部服务外网隔离](/micro/id-token) |
| sameTokenTimeout | long | 86400 | Same-Token的有效期 （单位: 秒），[参考：内部服务外网隔离](/micro/same-token) |
| basic | String | "" | Http Basic 认证的账号和密码 [参考：Http Basic 认证](/up/basic-auth) |
| currDomain | String | null | 配置当前项目的网络访问地址 |
| checkIdToken | Boolean | false | 是否校验Id-Token（部分rpc插件有效） |
| checkSameToken | Boolean | false | 是否校验Same-Token（部分rpc插件有效） |
| cookie | Object | new SaCookieConfig() | Cookie配置对象 |
Cookie相关配置：

1
sa-token-plugin/sa-token-context-dubbo/pom.xml
View File

@ -21,7 +21,6 @@
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-core</artifactId>
<version>${revision}</version>
</dependency>
<!-- dubbo -->

8
sa-token-plugin/sa-token-context-dubbo/src/main/java/cn/dev33/satoken/context/dubbo/filter/SaTokenDubboConsumerFilter.java
View File

@ -11,7 +11,7 @@ import org.apache.dubbo.rpc.RpcException;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.context.SaTokenContextDefaultImpl;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
import cn.dev33.satoken.stp.StpUtil;
import cn.dev33.satoken.util.SaTokenConsts;
@ -28,9 +28,9 @@ public class SaTokenDubboConsumerFilter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
// 追加 Id-Token 参数
if(SaManager.getConfig().getCheckIdToken()) {
RpcContext.getContext().setAttachment(SaIdUtil.ID_TOKEN, SaIdUtil.getToken());
// 追加 Same-Token 参数
if(SaManager.getConfig().getCheckSameToken()) {
RpcContext.getContext().setAttachment(SaSameUtil.SAME_TOKEN, SaSameUtil.getToken());
}
// 1. 调用前，向下传递会话Token

10
sa-token-plugin/sa-token-context-dubbo/src/main/java/cn/dev33/satoken/context/dubbo/filter/SaTokenDubboProviderFilter.java
View File

@ -9,7 +9,7 @@ import org.apache.dubbo.rpc.Result;
import org.apache.dubbo.rpc.RpcException;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
/**
*
@ -25,13 +25,13 @@ public class SaTokenDubboProviderFilter implements Filter {
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
// RPC 调用鉴权
if(SaManager.getConfig().getCheckIdToken()) {
String idToken = invocation.getAttachment(SaIdUtil.ID_TOKEN);
if(SaManager.getConfig().getCheckSameToken()) {
String idToken = invocation.getAttachment(SaSameUtil.SAME_TOKEN);
// dubbo部分协议会将参数变为小写，详细参考：https://gitee.com/dromara/sa-token/issues/I4WXQG
if(idToken == null) {
idToken = invocation.getAttachment(SaIdUtil.ID_TOKEN.toLowerCase());
idToken = invocation.getAttachment(SaSameUtil.SAME_TOKEN.toLowerCase());
}
SaIdUtil.checkToken(idToken);
SaSameUtil.checkToken(idToken);
}
// 开始调用

6
sa-token-plugin/sa-token-context-grpc/src/main/java/cn/dev33/satoken/context/grpc/constants/GrpcContextConstants.java
View File

@ -1,6 +1,6 @@
package cn.dev33.satoken.context.grpc.constants;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
import cn.dev33.satoken.util.SaTokenConsts;
import io.grpc.Metadata;
@ -11,8 +11,8 @@ import io.grpc.Metadata;
* @since: 2022/8/26 14:27
*/
public class GrpcContextConstants {
public static final Metadata.Key<String> SA_ID_TOKEN =
Metadata.Key.of(SaIdUtil.ID_TOKEN, Metadata.ASCII_STRING_MARSHALLER);
public static final Metadata.Key<String> SA_SAME_TOKEN =
Metadata.Key.of(SaSameUtil.SAME_TOKEN, Metadata.ASCII_STRING_MARSHALLER);
public static final Metadata.Key<String> SA_JUST_CREATED_NOT_PREFIX =
Metadata.Key.of(SaTokenConsts.JUST_CREATED_NOT_PREFIX, Metadata.ASCII_STRING_MARSHALLER);

21
sa-token-plugin/sa-token-context-grpc/src/main/java/cn/dev33/satoken/context/grpc/interceptor/SaTokenGrpcClientInterceptor.java
View File

@ -1,14 +1,23 @@
package cn.dev33.satoken.context.grpc.interceptor;
import org.springframework.core.Ordered;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.context.SaTokenContextDefaultImpl;
import cn.dev33.satoken.context.grpc.constants.GrpcContextConstants;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
import cn.dev33.satoken.stp.StpUtil;
import cn.dev33.satoken.util.SaFoxUtil;
import io.grpc.*;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.ForwardingClientCall;
import io.grpc.ForwardingClientCallListener;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.Status;
import net.devh.boot.grpc.client.interceptor.GrpcGlobalClientInterceptor;
import org.springframework.core.Ordered;
/**
@ -26,9 +35,9 @@ public class SaTokenGrpcClientInterceptor implements ClientInterceptor, Ordered
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
// 追加 Id-Token 参数
if (SaManager.getConfig().getCheckIdToken()) {
headers.put(GrpcContextConstants.SA_ID_TOKEN, SaIdUtil.getToken());
// 追加 Same-Token 参数
if (SaManager.getConfig().getCheckSameToken()) {
headers.put(GrpcContextConstants.SA_SAME_TOKEN, SaSameUtil.getToken());
}
// 调用前，传递会话Token

15
sa-token-plugin/sa-token-context-grpc/src/main/java/cn/dev33/satoken/context/grpc/interceptor/SaTokenGrpcServerInterceptor.java
View File

@ -2,10 +2,15 @@ package cn.dev33.satoken.context.grpc.interceptor;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.context.grpc.constants.GrpcContextConstants;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
import cn.dev33.satoken.stp.StpUtil;
import cn.dev33.satoken.util.SaFoxUtil;
import io.grpc.*;
import io.grpc.ForwardingServerCall;
import io.grpc.Metadata;
import io.grpc.ServerCall;
import io.grpc.ServerCallHandler;
import io.grpc.ServerInterceptor;
import io.grpc.Status;
import net.devh.boot.grpc.server.interceptor.GrpcGlobalServerInterceptor;
/**
@ -19,9 +24,9 @@ public class SaTokenGrpcServerInterceptor implements ServerInterceptor {
@Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
// RPC 调用鉴权
if (SaManager.getConfig().getCheckIdToken()) {
String idToken = headers.get(GrpcContextConstants.SA_ID_TOKEN);
SaIdUtil.checkToken(idToken);
if (SaManager.getConfig().getCheckSameToken()) {
String sameToken = headers.get(GrpcContextConstants.SA_SAME_TOKEN);
SaSameUtil.checkToken(sameToken);
}
String tokenFromClient = headers.get(GrpcContextConstants.SA_JUST_CREATED_NOT_PREFIX);
StpUtil.setTokenValue(tokenFromClient);

12
sa-token-starter/sa-token-reactor-spring-boot-starter/src/main/java/cn/dev33/satoken/reactor/spring/SaBeanInject.java
View File

@ -18,6 +18,7 @@ import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.json.SaJsonTemplate;
import cn.dev33.satoken.listener.SaTokenEventCenter;
import cn.dev33.satoken.listener.SaTokenListener;
import cn.dev33.satoken.same.SaSameTemplate;
import cn.dev33.satoken.sign.SaSignTemplate;
import cn.dev33.satoken.stp.StpInterface;
import cn.dev33.satoken.stp.StpLogic;
@ -30,6 +31,7 @@ import cn.dev33.satoken.temp.SaTempInterface;
* @author kong
*
*/
@SuppressWarnings("deprecation")
public class SaBeanInject {
/**
@ -112,6 +114,16 @@ public class SaBeanInject {
SaIdUtil.saIdTemplate = saIdTemplate;
}
/**
* 注入 Same-Token 模块 Bean
*
* @param saSameTemplate saSameTemplate对象
*/
@Autowired(required = false)
public void setSaIdTemplate(SaSameTemplate saSameTemplate) {
SaManager.setSaSameTemplate(saSameTemplate);
}
/**
* 注入 Sa-Token Http Basic 认证模块
*

6
sa-token-starter/sa-token-solon-plugin/src/main/java/cn/dev33/satoken/solon/XPluginImp.java
View File

@ -21,6 +21,7 @@ import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.json.SaJsonTemplate;
import cn.dev33.satoken.listener.SaTokenEventCenter;
import cn.dev33.satoken.listener.SaTokenListener;
import cn.dev33.satoken.same.SaSameTemplate;
import cn.dev33.satoken.sign.SaSignTemplate;
import cn.dev33.satoken.solon.integration.SaTokenAnnotationInterceptor;
import cn.dev33.satoken.solon.model.SaContextForSolon;
@ -96,6 +97,11 @@ public class XPluginImp implements Plugin {
SaIdUtil.saIdTemplate = bw.raw();
});
// Sa-Token Same-Token 模块 Bean
context.getWrapAsyn(SaSameTemplate.class, bw->{
SaManager.setSaSignTemplate(bw.raw());
});
// Sa-Token Http Basic 认证模块 Bean
context.getWrapAsyn(SaBasicTemplate.class, bw->{
SaBasicUtil.saBasicTemplate = bw.raw();

12
sa-token-starter/sa-token-spring-boot-starter/src/main/java/cn/dev33/satoken/spring/SaBeanInject.java
View File

@ -18,6 +18,7 @@ import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.json.SaJsonTemplate;
import cn.dev33.satoken.listener.SaTokenEventCenter;
import cn.dev33.satoken.listener.SaTokenListener;
import cn.dev33.satoken.same.SaSameTemplate;
import cn.dev33.satoken.sign.SaSignTemplate;
import cn.dev33.satoken.stp.StpInterface;
import cn.dev33.satoken.stp.StpLogic;
@ -30,6 +31,7 @@ import cn.dev33.satoken.temp.SaTempInterface;
* @author kong
*
*/
@SuppressWarnings("deprecation")
public class SaBeanInject {
/**
@ -112,6 +114,16 @@ public class SaBeanInject {
SaIdUtil.saIdTemplate = saIdTemplate;
}
/**
* 注入 Same-Token 模块 Bean
*
* @param saSameTemplate saSameTemplate对象
*/
@Autowired(required = false)
public void setSaIdTemplate(SaSameTemplate saSameTemplate) {
SaManager.setSaSameTemplate(saSameTemplate);
}
/**
* 注入 Sa-Token Http Basic 认证模块
*

2
sa-token-test/sa-token-jwt-test/pom.xml
View File

@ -20,12 +20,10 @@
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-spring-boot-starter</artifactId>
<version>${revision}</version>
</dependency>
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-jwt</artifactId>
<version>${revision}</version>
</dependency>
</dependencies>

5
sa-token-test/sa-token-springboot-test/pom.xml
View File

@ -20,30 +20,25 @@
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-spring-boot-starter</artifactId>
<version>${revision}</version>
</dependency>
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-sso</artifactId>
<version>${revision}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-oauth2</artifactId>
<version>${revision}</version>
<scope>test</scope>
</dependency>
<!-- 冗余（生成单元测试报告） -->
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-servlet</artifactId>
<version>${revision}</version>
</dependency>
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-core</artifactId>
<version>${revision}</version>
</dependency>
</dependencies>

8
sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/core/config/SaTokenConfigTest.java
View File

@ -71,8 +71,8 @@ public class SaTokenConfigTest {
config.setJwtSecretKey("NgdfaXasARggr");
Assertions.assertEquals(config.getJwtSecretKey(), "NgdfaXasARggr");
config.setIdTokenTimeout(1004);
Assertions.assertEquals(config.getIdTokenTimeout(), 1004);
config.setSameTokenTimeout(1004);
Assertions.assertEquals(config.getSameTokenTimeout(), 1004);
config.setBasic("sa:123456");
Assertions.assertEquals(config.getBasic(), "sa:123456");
@ -80,8 +80,8 @@ public class SaTokenConfigTest {
config.setCurrDomain("http://127.0.0.1:8084");
Assertions.assertEquals(config.getCurrDomain(), "http://127.0.0.1:8084");
config.setCheckIdToken(false);
Assertions.assertEquals(config.getCheckIdToken(), false);
config.setCheckSameToken(false);
Assertions.assertEquals(config.getCheckSameToken(), false);
SaCookieConfig scc = new SaCookieConfig();
config.setCookie(scc);

4
sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/core/util/SaFoxUtilTest.java
View File

@ -90,11 +90,11 @@ public class SaFoxUtilTest {
// 不做分页
List<String> list5 = SaFoxUtil.searchList(dataList, "", "", -1, 0, true);
List<String> list5 = SaFoxUtil.searchList(dataList, "", "", 0, -1, true);
Assertions.assertEquals(list5.size(), dataList.size());
// 反序排列 list6的第一个元素 == dataList最后一个元素
List<String> list6 = SaFoxUtil.searchList(dataList, "", "", -1, 0, false);
List<String> list6 = SaFoxUtil.searchList(dataList, "", "", 0, -1, false);
Assertions.assertEquals(list6.get(0), dataList.get(dataList.size() - 1));
}

8
sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/configure/HandlerException.java
View File

@ -4,12 +4,12 @@ import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import cn.dev33.satoken.exception.DisableServiceException;
import cn.dev33.satoken.exception.IdTokenInvalidException;
import cn.dev33.satoken.exception.NotBasicAuthException;
import cn.dev33.satoken.exception.NotLoginException;
import cn.dev33.satoken.exception.NotPermissionException;
import cn.dev33.satoken.exception.NotRoleException;
import cn.dev33.satoken.exception.NotSafeException;
import cn.dev33.satoken.exception.SameTokenInvalidException;
import cn.dev33.satoken.util.SaResult;
/**
@ -44,9 +44,9 @@ public class HandlerException {
return SaResult.error().setCode(901);
}
// id-token 校验失败，code=902
@ExceptionHandler(IdTokenInvalidException.class)
public SaResult handlerIdTokenInvalidException(IdTokenInvalidException e) {
// same-token 校验失败，code=902
@ExceptionHandler(SameTokenInvalidException.class)
public SaResult handlerSameTokenInvalidException(SameTokenInvalidException e) {
return SaResult.error().setCode(902);
}

4
sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/configure/inject/MySaIdTemplate.java → sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/configure/inject/MySaSameTemplate.java
View File

@ -2,9 +2,9 @@ package cn.dev33.satoken.integrate.configure.inject;
import org.springframework.stereotype.Component;
import cn.dev33.satoken.id.SaIdTemplate;
import cn.dev33.satoken.same.SaSameTemplate;
@Component
public class MySaIdTemplate extends SaIdTemplate {
public class MySaSameTemplate extends SaSameTemplate {
}

20
sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/id/SaIdTokenController.java → sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/same/SaSameTokenController.java
View File

@ -1,28 +1,28 @@
package cn.dev33.satoken.integrate.id;
package cn.dev33.satoken.integrate.same;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.same.SaSameUtil;
import cn.dev33.satoken.spring.SpringMVCUtil;
import cn.dev33.satoken.util.SaResult;
/**
* id-token Controller
* same-token Controller
*
* @author kong
*
*/
@RestController
@RequestMapping("/id/")
public class SaIdTokenController {
@RequestMapping("/same/")
public class SaSameTokenController {
// 获取信息
@RequestMapping("getInfo")
public SaResult getInfo() {
// 获取并校验id-token
String idToken = SpringMVCUtil.getRequest().getHeader(SaIdUtil.ID_TOKEN);
SaIdUtil.checkToken(idToken);
// 获取并校验same-token
String sameToken = SpringMVCUtil.getRequest().getHeader(SaSameUtil.SAME_TOKEN);
SaSameUtil.checkToken(sameToken);
// 返回信息
return SaResult.data("info=zhangsan");
}
@ -30,8 +30,8 @@ public class SaIdTokenController {
// 获取信息2
@RequestMapping("getInfo2")
public SaResult getInfo2() {
// 获取并校验id-token
SaIdUtil.checkCurrentRequestToken();
// 获取并校验same-token
SaSameUtil.checkCurrentRequestToken();
// 返回信息
return SaResult.data("info=zhangsan2");
}

56
sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/id/SaIdTokenControllerTest.java → sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/same/SaSameTokenControllerTest.java
View File

@ -1,4 +1,4 @@
package cn.dev33.satoken.integrate.id;
package cn.dev33.satoken.integrate.same;
import java.util.Map;
@ -16,19 +16,19 @@ import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.exception.IdTokenInvalidException;
import cn.dev33.satoken.id.SaIdUtil;
import cn.dev33.satoken.exception.SameTokenInvalidException;
import cn.dev33.satoken.integrate.StartUpApplication;
import cn.dev33.satoken.same.SaSameUtil;
import cn.dev33.satoken.util.SaResult;
/**
* id-token Controller 测试
* same-token Controller 测试
*
* @author kong
*
*/
@SpringBootTest(classes = StartUpApplication.class)
public class SaIdTokenControllerTest {
public class SaSameTokenControllerTest {
@Autowired
private WebApplicationContext wac;
@ -44,73 +44,73 @@ public class SaIdTokenControllerTest {
// 获取信息
@Test
public void testGetInfo() {
String token = SaIdUtil.getToken();
String token = SaSameUtil.getToken();
// 加token，能调通
SaResult res = request("/id/getInfo", token);
SaResult res = request("/same/getInfo", token);
Assertions.assertEquals(res.getCode(), 200);
// 不加token，不能调通
SaResult res2 = request("/id/getInfo", "xxx");
SaResult res2 = request("/same/getInfo", "xxx");
Assertions.assertEquals(res2.getCode(), 902);
// 获取信息2
token = SaIdUtil.getTokenNh();
token = SaSameUtil.getTokenNh();
// 加token，能调通
SaResult res3 = request("/id/getInfo2", token);
SaResult res3 = request("/same/getInfo2", token);
Assertions.assertEquals(res3.getCode(), 200);
// 不加token，不能调通
SaResult res4 = request("/id/getInfo2", "xxx");
SaResult res4 = request("/same/getInfo2", "xxx");
Assertions.assertEquals(res4.getCode(), 902);
}
// 基础测试
@Test
public void testApi() {
String token = SaIdUtil.getToken();
String token = SaSameUtil.getToken();
// 刷新一下，会有变化
SaIdUtil.refreshToken();
String token2 = SaIdUtil.getToken();
SaSameUtil.refreshToken();
String token2 = SaSameUtil.getToken();
Assertions.assertNotEquals(token, token2);
// 旧token，变为次级token
String pastToken = SaIdUtil.getPastTokenNh();
String pastToken = SaSameUtil.getPastTokenNh();
Assertions.assertEquals(token, pastToken);
// dao中应该有值
String daoToken = SaManager.getSaTokenDao().get("satoken:var:id-token");
String daoToken2 = SaManager.getSaTokenDao().get("satoken:var:past-id-token");
String daoToken = SaManager.getSaTokenDao().get("satoken:var:same-token");
String daoToken2 = SaManager.getSaTokenDao().get("satoken:var:past-same-token");
Assertions.assertEquals(token2, daoToken);
Assertions.assertEquals(token, daoToken2);
// 新旧都有效
Assertions.assertTrue(SaIdUtil.isValid(token));
Assertions.assertTrue(SaIdUtil.isValid(token2));
Assertions.assertTrue(SaSameUtil.isValid(token));
Assertions.assertTrue(SaSameUtil.isValid(token2));
// 空的不行
Assertions.assertFalse(SaIdUtil.isValid(null));
Assertions.assertFalse(SaIdUtil.isValid(""));
Assertions.assertFalse(SaSameUtil.isValid(null));
Assertions.assertFalse(SaSameUtil.isValid(""));
// 不抛出异常
Assertions.assertDoesNotThrow(() -> SaIdUtil.checkToken(token));
Assertions.assertDoesNotThrow(() -> SaIdUtil.checkToken(token2));
Assertions.assertDoesNotThrow(() -> SaSameUtil.checkToken(token));
Assertions.assertDoesNotThrow(() -> SaSameUtil.checkToken(token2));
// 抛出异常
Assertions.assertThrows(IdTokenInvalidException.class, () -> SaIdUtil.checkToken(null));
Assertions.assertThrows(IdTokenInvalidException.class, () -> SaIdUtil.checkToken(""));
Assertions.assertThrows(IdTokenInvalidException.class, () -> SaIdUtil.checkToken("aaa"));
Assertions.assertThrows(SameTokenInvalidException.class, () -> SaSameUtil.checkToken(null));
Assertions.assertThrows(SameTokenInvalidException.class, () -> SaSameUtil.checkToken(""));
Assertions.assertThrows(SameTokenInvalidException.class, () -> SaSameUtil.checkToken("aaa"));
}
// 封装请求
private SaResult request(String path, String idToken) {
private SaResult request(String path, String sameToken) {
try {
// 发请求
MvcResult mvcResult = mvc.perform(
MockMvcRequestBuilders.post(path)
.contentType(MediaType.APPLICATION_PROBLEM_JSON)
.accept(MediaType.APPLICATION_PROBLEM_JSON)
.header(SaIdUtil.ID_TOKEN, idToken)
.header(SaSameUtil.SAME_TOKEN, sameToken)
)
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn();