当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5
- * - * @param loginId 账号id + * 踢人下线，根据账号id + *当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5
+ * + * @param loginId 账号id */ public static void kickout(Object loginId) { stpLogic.kickout(loginId); } - + /** * 踢人下线，根据账号id 和 设备类型 - *当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5
- * - * @param loginId 账号id - * @param device 设备类型 (填null代表踢出所有设备类型) + *当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5
+ * + * @param loginId 账号id + * @param device 设备类型 (填 null 代表踢出该账号的所有设备类型) */ public static void kickout(Object loginId, String device) { stpLogic.kickout(loginId, device); } /** - * 踢人下线，根据指定 Token - *当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5
- * - * @param tokenValue 指定token + * 踢人下线，根据指定 token + *当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5
+ * + * @param tokenValue 指定 token */ public static void kickoutByTokenValue(String tokenValue) { stpLogic.kickoutByTokenValue(tokenValue); } - + /** * 顶人下线，根据账号id 和 设备类型 - *当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4
- * - * @param loginId 账号id - * @param device 设备类型 (填null代表顶替所有设备类型) + *当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4
+ * + * @param loginId 账号id + * @param device 设备类型 （填 null 代表顶替该账号的所有设备类型） */ public static void replaced(Object loginId, String device) { stpLogic.replaced(loginId, device); } - - - // 查询相关 - /** - * 当前会话是否已经登录 - * @return 是否已登录 - */ + // 会话查询 + + /** + * 判断当前会话是否已经登录 + * + * @return 已登录返回 true，未登录返回 false + */ public static boolean isLogin() { return stpLogic.isLogin(); } - /** - * 检验当前会话是否已经登录，如未登录，则抛出异常 - */ - public static void checkLogin() { - stpLogic.checkLogin(); - } + /** + * 检验当前会话是否已经登录，如未登录，则抛出异常 + */ + public static void checkLogin() { + stpLogic.checkLogin(); + } - /** - * 获取当前会话账号id, 如果未登录，则抛出异常 - * @return 账号id - */ + /** + * 获取当前会话账号id，如果未登录，则抛出异常 + * + * @return 账号id + */ public static Object getLoginId() { return stpLogic.getLoginId(); } - /** - * 获取当前会话账号id, 如果未登录，则返回默认值 - * @param在配置为允许并发登录时，此方法只会返回队列的最后一个token， - * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId + // ------------------- id 反查 token 相关操作 ------------------- + + /** + * 获取指定账号 id 的 token + *
+ * 在配置为允许并发登录时，此方法只会返回队列的最后一个 token， + * 如果你需要返回此账号 id 的所有 token，请调用 getTokenValueListByLoginId + *
+ * * @param loginId 账号id - * @return token值 + * @return token值 */ public static String getTokenValueByLoginId(Object loginId) { return stpLogic.getTokenValueByLoginId(loginId); } - /** - * 获取指定账号id指定设备类型端的tokenValue - *在配置为允许并发登录时，此方法只会返回队列的最后一个token， - * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId + /** + * 获取指定账号 id 指定设备类型端的 token + *
+ * 在配置为允许并发登录时，此方法只会返回队列的最后一个 token， + * 如果你需要返回此账号 id 的所有 token，请调用 getTokenValueListByLoginId + *
+ * * @param loginId 账号id - * @param device 设备类型 - * @return token值 + * @param device 设备类型，填 null 代表不限设备类型 + * @return token值 */ public static String getTokenValueByLoginId(Object loginId, String device) { return stpLogic.getTokenValueByLoginId(loginId, device); } - - /** - * 获取指定账号id的tokenValue集合 - * @param loginId 账号id - * @return 此loginId的所有相关token - */ + + /** + * 获取指定账号 id 的 token 集合 + * + * @param loginId 账号id + * @return 此 loginId 的所有相关 token + */ public static List此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id) - * - * @param loginId 指定账号id + * + * @param loginId 指定账号id * @param time 封禁时间, 单位: 秒 （-1=永久封禁） */ public static void disable(Object loginId, long time) { @@ -783,17 +871,18 @@ public class StpUserUtil { } /** - * 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁) - * + * 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁) + * * @param loginId 账号id - * @return / + * @return / */ public static boolean isDisable(Object loginId) { return stpLogic.isDisable(loginId); } /** - * 校验：指定账号是否已被封禁，如果被封禁则抛出异常 + * 校验：指定账号是否已被封禁，如果被封禁则抛出异常 + * * @param loginId 账号id */ public static void checkDisable(Object loginId) { @@ -802,8 +891,9 @@ public class StpUserUtil { /** * 获取：指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁） + * * @param loginId 账号id - * @return / + * @return / */ public static long getDisableTime(Object loginId) { return stpLogic.getDisableTime(loginId); @@ -811,20 +901,22 @@ public class StpUserUtil { /** * 解封：指定账号 + * * @param loginId 账号id */ public static void untieDisable(Object loginId) { stpLogic.untieDisable(loginId); } - - // ------------------- 分类封禁 ------------------- + + // ------------------- 分类封禁 ------------------- /** - * 封禁：指定账号的指定服务 + * 封禁：指定账号的指定服务 *
此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
- * @param loginId 指定账号id
- * @param service 指定服务
+ *
+ * @param loginId 指定账号id
+ * @param service 指定服务
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, String service, long time) {
@@ -832,19 +924,21 @@ public class StpUserUtil {
}
/**
- * 判断：指定账号的指定服务 是否已被封禁 (true=已被封禁, false=未被封禁)
+ * 判断：指定账号的指定服务 是否已被封禁（true=已被封禁, false=未被封禁）
+ *
* @param loginId 账号id
- * @param service 指定服务
- * @return /
+ * @param service 指定服务
+ * @return /
*/
public static boolean isDisable(Object loginId, String service) {
return stpLogic.isDisable(loginId, service);
}
/**
- * 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
+ * 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
+ *
* @param loginId 账号id
- * @param services 指定服务，可以指定多个
+ * @param services 指定服务，可以指定多个
*/
public static void checkDisable(Object loginId, String... services) {
stpLogic.checkDisable(loginId, services);
@@ -852,9 +946,10 @@ public class StpUserUtil {
/**
* 获取：指定账号 指定服务 剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+ *
* @param loginId 账号id
- * @param service 指定服务
- * @return see note
+ * @param service 指定服务
+ * @return see note
*/
public static long getDisableTime(Object loginId, String service) {
return stpLogic.getDisableTime(loginId, service);
@@ -862,20 +957,22 @@ public class StpUserUtil {
/**
* 解封：指定账号、指定服务
+ *
* @param loginId 账号id
- * @param services 指定服务，可以指定多个
+ * @param services 指定服务，可以指定多个
*/
public static void untieDisable(Object loginId, String... services) {
stpLogic.untieDisable(loginId, services);
}
- // ------------------- 阶梯封禁 -------------------
+ // ------------------- 阶梯封禁 -------------------
/**
- * 封禁：指定账号，并指定封禁等级
- * @param loginId 指定账号id
- * @param level 指定封禁等级
+ * 封禁：指定账号，并指定封禁等级
+ *
+ * @param loginId 指定账号id
+ * @param level 指定封禁等级
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disableLevel(Object loginId, int level, long time) {
@@ -883,10 +980,11 @@ public class StpUserUtil {
}
/**
- * 封禁：指定账号的指定服务，并指定封禁等级
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 指定封禁等级
+ * 封禁：指定账号的指定服务，并指定封禁等级
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
+ * @param level 指定封禁等级
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disableLevel(Object loginId, String service, int level, long time) {
@@ -895,22 +993,22 @@ public class StpUserUtil {
/**
* 判断：指定账号是否已被封禁到指定等级
- *
- * @param loginId 指定账号id
- * @param level 指定封禁等级
- * @return /
+ *
+ * @param loginId 指定账号id
+ * @param level 指定封禁等级
+ * @return /
*/
public static boolean isDisableLevel(Object loginId, int level) {
return stpLogic.isDisableLevel(loginId, level);
}
/**
- * 判断：指定账号的指定服务，是否已被封禁到指定等级
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 指定封禁等级
- * @return /
+ * 判断：指定账号的指定服务，是否已被封禁到指定等级
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
+ * @param level 指定封禁等级
+ * @return /
*/
public static boolean isDisableLevel(Object loginId, String service, int level) {
return stpLogic.isDisableLevel(loginId, service, level);
@@ -918,8 +1016,8 @@ public class StpUserUtil {
/**
* 校验：指定账号是否已被封禁到指定等级（如果已经达到，则抛出异常）
- *
- * @param loginId 指定账号id
+ *
+ * @param loginId 指定账号id
* @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
*/
public static void checkDisableLevel(Object loginId, int level) {
@@ -928,9 +1026,9 @@ public class StpUserUtil {
/**
* 校验：指定账号的指定服务，是否已被封禁到指定等级（如果已经达到，则抛出异常）
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
* @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
*/
public static void checkDisableLevel(Object loginId, String service, int level) {
@@ -938,37 +1036,38 @@ public class StpUserUtil {
}
/**
- * 获取：指定账号被封禁的等级，如果未被封禁则返回-2
- *
- * @param loginId 指定账号id
- * @return /
+ * 获取：指定账号被封禁的等级，如果未被封禁则返回-2
+ *
+ * @param loginId 指定账号id
+ * @return /
*/
public static int getDisableLevel(Object loginId) {
return stpLogic.getDisableLevel(loginId);
}
/**
- * 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @return /
+ * 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
+ * @return /
*/
public static int getDisableLevel(Object loginId, String service) {
return stpLogic.getDisableLevel(loginId, service);
}
-
-
- // ------------------- 身份切换 -------------------
+
+
+ // ------------------- 临时身份切换 -------------------
/**
- * 临时切换身份为指定账号id
- * @param loginId 指定loginId
+ * 临时切换身份为指定账号id
+ *
+ * @param loginId 指定loginId
*/
public static void switchTo(Object loginId) {
stpLogic.switchTo(loginId);
}
-
+
/**
* 结束临时切换身份
*/
@@ -977,86 +1076,95 @@ public class StpUserUtil {
}
/**
- * 当前是否正处于[身份临时切换]中
- * @return 是否正处于[身份临时切换]中
+ * 判断当前请求是否正处于 [ 身份临时切换 ] 中
+ *
+ * @return /
*/
public static boolean isSwitch() {
return stpLogic.isSwitch();
}
/**
- * 在一个代码段里方法内，临时切换身份为指定账号id
- * @param loginId 指定账号id
- * @param function 要执行的方法
+ * 在一个 lambda 代码段里，临时切换身份为指定账号id，lambda 结束后自动恢复
+ *
+ * @param loginId 指定账号id
+ * @param function 要执行的方法
*/
public static void switchTo(Object loginId, SaFunction function) {
stpLogic.switchTo(loginId, function);
}
-
- // ------------------- 二级认证 -------------------
-
+
+ // ------------------- 二级认证 -------------------
+
/**
- * 在当前会话 开启二级认证
- * @param safeTime 维持时间 (单位: 秒)
+ * 在当前会话 开启二级认证
+ *
+ * @param safeTime 维持时间 (单位: 秒)
*/
public static void openSafe(long safeTime) {
stpLogic.openSafe(safeTime);
}
/**
- * 在当前会话 开启二级认证
- * @param service 业务标识
- * @param safeTime 维持时间 (单位: 秒)
+ * 在当前会话 开启二级认证
+ *
+ * @param service 业务标识
+ * @param safeTime 维持时间 (单位: 秒)
*/
public static void openSafe(String service, long safeTime) {
stpLogic.openSafe(service, safeTime);
}
/**
- * 当前会话 是否处于二级认证时间内
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+ * 判断：当前会话是否处于二级认证时间内
+ *
+ * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe() {
return stpLogic.isSafe();
}
/**
- * 当前会话 是否处于二级认证时间内
- * @param service 业务标识
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+ * 判断：当前会话 是否处于指定业务的二级认证时间内
+ *
+ * @param service 业务标识
+ * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe(String service) {
return stpLogic.isSafe(service);
}
/**
- * 指定 Token 是否处于二级认证时间内
- * @param tokenValue Token 值
- * @param service 业务标识
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+ * 判断：指定 token 是否处于二级认证时间内
+ *
+ * @param tokenValue Token 值
+ * @param service 业务标识
+ * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe(String tokenValue, String service) {
return stpLogic.isSafe(tokenValue, service);
}
/**
- * 检查当前会话是否已通过二级认证，如未通过则抛出异常
+ * 校验：当前会话是否已通过二级认证，如未通过则抛出异常
*/
public static void checkSafe() {
stpLogic.checkSafe();
}
/**
- * 检查当前会话是否已通过二级认证，如未通过则抛出异常
- * @param service 业务标识
+ * 校验：检查当前会话是否已通过指定业务的二级认证，如未通过则抛出异常
+ *
+ * @param service 业务标识
*/
public static void checkSafe(String service) {
stpLogic.checkSafe(service);
}
-
+
/**
- * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
+ * 获取：当前会话的二级认证剩余有效时间（单位: 秒, 返回-2代表尚未通过二级认证）
+ *
* @return 剩余有效时间
*/
public static long getSafeTime() {
@@ -1064,8 +1172,9 @@ public class StpUserUtil {
}
/**
- * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
- * @param service 业务标识
+ * 获取：当前会话的二级认证剩余有效时间（单位: 秒, 返回-2代表尚未通过二级认证）
+ *
+ * @param service 业务标识
* @return 剩余有效时间
*/
public static long getSafeTime(String service) {
@@ -1073,14 +1182,15 @@ public class StpUserUtil {
}
/**
- * 在当前会话 结束二级认证
+ * 在当前会话 结束二级认证
*/
public static void closeSafe() {
stpLogic.closeSafe();
}
/**
- * 在当前会话 结束二级认证
+ * 在当前会话 结束指定业务标识的二级认证
+ *
* @param service 业务标识
*/
public static void closeSafe(String service) {
diff --git a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckLogin.java b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckLogin.java
index 08085bbc..5c623667 100644
--- a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckLogin.java
+++ b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckLogin.java
@@ -6,6 +6,7 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import cn.dev33.satoken.annotation.SaCheckLogin;
+import com.pj.satoken.StpUserUtil;
/**
* 登录认证(User版)：只有登录之后才能进入该方法
diff --git a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckPermission.java b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckPermission.java
index d63fe208..22938622 100644
--- a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckPermission.java
+++ b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckPermission.java
@@ -5,6 +5,7 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
+import com.pj.satoken.StpUserUtil;
import org.springframework.core.annotation.AliasFor;
import cn.dev33.satoken.annotation.SaCheckPermission;
diff --git a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckRole.java b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckRole.java
index e8707280..66e1f6d0 100644
--- a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckRole.java
+++ b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/SaUserCheckRole.java
@@ -5,6 +5,7 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
+import com.pj.satoken.StpUserUtil;
import org.springframework.core.annotation.AliasFor;
import cn.dev33.satoken.annotation.SaCheckRole;
diff --git a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/StpUserUtil.java b/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/StpUserUtil.java
deleted file mode 100644
index 7f817598..00000000
--- a/sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/at/StpUserUtil.java
+++ /dev/null
@@ -1,1029 +0,0 @@
-package com.pj.satoken.at;
-
-import java.util.List;
-
-import cn.dev33.satoken.SaManager;
-import cn.dev33.satoken.fun.SaFunction;
-import cn.dev33.satoken.session.SaSession;
-import cn.dev33.satoken.stp.SaLoginModel;
-import cn.dev33.satoken.stp.SaTokenInfo;
-import cn.dev33.satoken.stp.StpLogic;
-
-/**
- * Sa-Token 权限认证工具类 (User版)
- * @author click33
- */
-public class StpUserUtil {
-
- private StpUserUtil() {}
-
- /**
- * 账号类型标识
- */
- public static final String TYPE = "user";
-
- /**
- * 底层的 StpLogic 对象
- */
- public static StpLogic stpLogic = new StpLogic(TYPE);
-
- /**
- * 获取当前 StpLogic 的账号类型
- * @return See Note
- */
- public static String getLoginType(){
- return stpLogic.getLoginType();
- }
-
- /**
- * 重置 StpLogic 对象
- *
1、更改此账户的 StpLogic 对象
- *
2、put 到全局 StpLogic 集合中
- *
- * @param newStpLogic /
- */
- public static void setStpLogic(StpLogic newStpLogic) {
- // 重置此账户的 StpLogic 对象
- stpLogic = newStpLogic;
-
- // 添加到全局 StpLogic 集合中
- // 以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic
- SaManager.putStpLogic(newStpLogic);
- }
-
- /**
- * 获取 StpLogic 对象
- * @return /
- */
- public static StpLogic getStpLogic() {
- return stpLogic;
- }
-
-
- // ------------------- 获取token 相关 -------------------
-
- /**
- * 返回token名称
- * @return 此StpLogic的token名称
- */
- public static String getTokenName() {
- return stpLogic.getTokenName();
- }
-
- /**
- * 在当前会话写入当前TokenValue
- * @param tokenValue token值
- */
- public static void setTokenValue(String tokenValue){
- stpLogic.setTokenValue(tokenValue);
- }
-
- /**
- * 在当前会话写入当前TokenValue
- * @param tokenValue token值
- * @param cookieTimeout Cookie存活时间(秒)
- */
- public static void setTokenValue(String tokenValue, int cookieTimeout){
- stpLogic.setTokenValue(tokenValue, cookieTimeout);
- }
-
- /**
- * 获取当前TokenValue
- * @return 当前tokenValue
- */
- public static String getTokenValue() {
- return stpLogic.getTokenValue();
- }
-
- /**
- * 获取当前TokenValue (不裁剪前缀)
- * @return /
- */
- public static String getTokenValueNotCut(){
- return stpLogic.getTokenValueNotCut();
- }
-
- /**
- * 获取当前会话的Token信息
- * @return token信息
- */
- public static SaTokenInfo getTokenInfo() {
- return stpLogic.getTokenInfo();
- }
-
-
- // ------------------- 登录相关操作 -------------------
-
- // --- 登录
-
- /**
- * 会话登录
- * @param id 账号id，建议的类型：（long | int | String）
- */
- public static void login(Object id) {
- stpLogic.login(id);
- }
-
- /**
- * 会话登录，并指定登录设备类型
- * @param id 账号id，建议的类型：（long | int | String）
- * @param device 设备类型
- */
- public static void login(Object id, String device) {
- stpLogic.login(id, device);
- }
-
- /**
- * 会话登录，并指定是否 [记住我]
- *
- * @param id 账号id，建议的类型：（long | int | String）
- * @param isLastingCookie 是否为持久Cookie
- */
- public static void login(Object id, boolean isLastingCookie) {
- stpLogic.login(id, isLastingCookie);
- }
-
- /**
- * 会话登录，并指定此次登录token的有效期, 单位:秒
- *
- * @param id 账号id，建议的类型：（long | int | String）
- * @param timeout 此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
- */
- public static void login(Object id, long timeout) {
- stpLogic.login(id, timeout);
- }
-
- /**
- * 会话登录，并指定所有登录参数Model
- *
- * @param id 登录id，建议的类型：（long | int | String）
- * @param loginModel 此次登录的参数Model
- */
- public static void login(Object id, SaLoginModel loginModel) {
- stpLogic.login(id, loginModel);
- }
-
- /**
- * 创建指定账号id的登录会话
- * @param id 登录id，建议的类型：（long | int | String）
- * @return 返回会话令牌
- */
- public static String createLoginSession(Object id) {
- return stpLogic.createLoginSession(id);
- }
-
- /**
- * 创建指定账号id的登录会话
- * @param id 登录id，建议的类型：（long | int | String）
- * @param loginModel 此次登录的参数Model
- * @return 返回会话令牌
- */
- public static String createLoginSession(Object id, SaLoginModel loginModel) {
- return stpLogic.createLoginSession(id, loginModel);
- }
-
- // --- 注销
-
- /**
- * 会话注销
- */
- public static void logout() {
- stpLogic.logout();
- }
-
- /**
- * 会话注销，根据账号id
- * @param loginId 账号id
- */
- public static void logout(Object loginId) {
- stpLogic.logout(loginId);
- }
-
- /**
- * 会话注销，根据账号id 和 设备类型
- *
- * @param loginId 账号id
- * @param device 设备类型 (填null代表注销所有设备类型)
- */
- public static void logout(Object loginId, String device) {
- stpLogic.logout(loginId, device);
- }
-
- /**
- * 会话注销，根据指定 Token
- *
- * @param tokenValue 指定token
- */
- public static void logoutByTokenValue(String tokenValue) {
- stpLogic.logoutByTokenValue(tokenValue);
- }
-
- /**
- * 踢人下线，根据账号id
- *
当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5
- * - * @param loginId 账号id - */ - public static void kickout(Object loginId) { - stpLogic.kickout(loginId); - } - - /** - * 踢人下线，根据账号id 和 设备类型 - *当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5
- * - * @param loginId 账号id - * @param device 设备类型 (填null代表踢出所有设备类型) - */ - public static void kickout(Object loginId, String device) { - stpLogic.kickout(loginId, device); - } - - /** - * 踢人下线，根据指定 Token - *当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5
- * - * @param tokenValue 指定token - */ - public static void kickoutByTokenValue(String tokenValue) { - stpLogic.kickoutByTokenValue(tokenValue); - } - - /** - * 顶人下线，根据账号id 和 设备类型 - *当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4
- * - * @param loginId 账号id - * @param device 设备类型 (填null代表顶替所有设备类型) - */ - public static void replaced(Object loginId, String device) { - stpLogic.replaced(loginId, device); - } - - - // 查询相关 - - /** - * 当前会话是否已经登录 - * @return 是否已登录 - */ - public static boolean isLogin() { - return stpLogic.isLogin(); - } - - /** - * 检验当前会话是否已经登录，如未登录，则抛出异常 - */ - public static void checkLogin() { - stpLogic.checkLogin(); - } - - /** - * 获取当前会话账号id, 如果未登录，则抛出异常 - * @return 账号id - */ - public static Object getLoginId() { - return stpLogic.getLoginId(); - } - - /** - * 获取当前会话账号id, 如果未登录，则返回默认值 - * @param在配置为允许并发登录时，此方法只会返回队列的最后一个token， - * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId - * @param loginId 账号id - * @return token值 - */ - public static String getTokenValueByLoginId(Object loginId) { - return stpLogic.getTokenValueByLoginId(loginId); - } - - /** - * 获取指定账号id指定设备类型端的tokenValue - *
在配置为允许并发登录时，此方法只会返回队列的最后一个token，
- * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
- * @param loginId 账号id
- * @param device 设备类型
- * @return token值
- */
- public static String getTokenValueByLoginId(Object loginId, String device) {
- return stpLogic.getTokenValueByLoginId(loginId, device);
- }
-
- /**
- * 获取指定账号id的tokenValue集合
- * @param loginId 账号id
- * @return 此loginId的所有相关token
- */
- public static List 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
- *
- * @param loginId 指定账号id
- * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
- */
- public static void disable(Object loginId, long time) {
- stpLogic.disable(loginId, time);
- }
-
- /**
- * 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
- *
- * @param loginId 账号id
- * @return /
- */
- public static boolean isDisable(Object loginId) {
- return stpLogic.isDisable(loginId);
- }
-
- /**
- * 校验：指定账号是否已被封禁，如果被封禁则抛出异常
- * @param loginId 账号id
- */
- public static void checkDisable(Object loginId) {
- stpLogic.checkDisable(loginId);
- }
-
- /**
- * 获取：指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
- * @param loginId 账号id
- * @return /
- */
- public static long getDisableTime(Object loginId) {
- return stpLogic.getDisableTime(loginId);
- }
-
- /**
- * 解封：指定账号
- * @param loginId 账号id
- */
- public static void untieDisable(Object loginId) {
- stpLogic.untieDisable(loginId);
- }
-
-
- // ------------------- 分类封禁 -------------------
-
- /**
- * 封禁：指定账号的指定服务
- * 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
- * @param loginId 指定账号id
- * @param service 指定服务
- * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
- */
- public static void disable(Object loginId, String service, long time) {
- stpLogic.disable(loginId, service, time);
- }
-
- /**
- * 判断：指定账号的指定服务 是否已被封禁 (true=已被封禁, false=未被封禁)
- * @param loginId 账号id
- * @param service 指定服务
- * @return /
- */
- public static boolean isDisable(Object loginId, String service) {
- return stpLogic.isDisable(loginId, service);
- }
-
- /**
- * 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
- * @param loginId 账号id
- * @param services 指定服务，可以指定多个
- */
- public static void checkDisable(Object loginId, String... services) {
- stpLogic.checkDisable(loginId, services);
- }
-
- /**
- * 获取：指定账号 指定服务 剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
- * @param loginId 账号id
- * @param service 指定服务
- * @return see note
- */
- public static long getDisableTime(Object loginId, String service) {
- return stpLogic.getDisableTime(loginId, service);
- }
-
- /**
- * 解封：指定账号、指定服务
- * @param loginId 账号id
- * @param services 指定服务，可以指定多个
- */
- public static void untieDisable(Object loginId, String... services) {
- stpLogic.untieDisable(loginId, services);
- }
-
-
- // ------------------- 阶梯封禁 -------------------
-
- /**
- * 封禁：指定账号，并指定封禁等级
- * @param loginId 指定账号id
- * @param level 指定封禁等级
- * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
- */
- public static void disableLevel(Object loginId, int level, long time) {
- stpLogic.disableLevel(loginId, level, time);
- }
-
- /**
- * 封禁：指定账号的指定服务，并指定封禁等级
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 指定封禁等级
- * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
- */
- public static void disableLevel(Object loginId, String service, int level, long time) {
- stpLogic.disableLevel(loginId, service, level, time);
- }
-
- /**
- * 判断：指定账号是否已被封禁到指定等级
- *
- * @param loginId 指定账号id
- * @param level 指定封禁等级
- * @return /
- */
- public static boolean isDisableLevel(Object loginId, int level) {
- return stpLogic.isDisableLevel(loginId, level);
- }
-
- /**
- * 判断：指定账号的指定服务，是否已被封禁到指定等级
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 指定封禁等级
- * @return /
- */
- public static boolean isDisableLevel(Object loginId, String service, int level) {
- return stpLogic.isDisableLevel(loginId, service, level);
- }
-
- /**
- * 校验：指定账号是否已被封禁到指定等级（如果已经达到，则抛出异常）
- *
- * @param loginId 指定账号id
- * @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
- */
- public static void checkDisableLevel(Object loginId, int level) {
- stpLogic.checkDisableLevel(loginId, level);
- }
-
- /**
- * 校验：指定账号的指定服务，是否已被封禁到指定等级（如果已经达到，则抛出异常）
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
- */
- public static void checkDisableLevel(Object loginId, String service, int level) {
- stpLogic.checkDisableLevel(loginId, service, level);
- }
-
- /**
- * 获取：指定账号被封禁的等级，如果未被封禁则返回-2
- *
- * @param loginId 指定账号id
- * @return /
- */
- public static int getDisableLevel(Object loginId) {
- return stpLogic.getDisableLevel(loginId);
- }
-
- /**
- * 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @return /
- */
- public static int getDisableLevel(Object loginId, String service) {
- return stpLogic.getDisableLevel(loginId, service);
- }
-
-
- // ------------------- 身份切换 -------------------
-
- /**
- * 临时切换身份为指定账号id
- * @param loginId 指定loginId
- */
- public static void switchTo(Object loginId) {
- stpLogic.switchTo(loginId);
- }
-
- /**
- * 结束临时切换身份
- */
- public static void endSwitch() {
- stpLogic.endSwitch();
- }
-
- /**
- * 当前是否正处于[身份临时切换]中
- * @return 是否正处于[身份临时切换]中
- */
- public static boolean isSwitch() {
- return stpLogic.isSwitch();
- }
-
- /**
- * 在一个代码段里方法内，临时切换身份为指定账号id
- * @param loginId 指定账号id
- * @param function 要执行的方法
- */
- public static void switchTo(Object loginId, SaFunction function) {
- stpLogic.switchTo(loginId, function);
- }
-
-
- // ------------------- 二级认证 -------------------
-
- /**
- * 在当前会话 开启二级认证
- * @param safeTime 维持时间 (单位: 秒)
- */
- public static void openSafe(long safeTime) {
- stpLogic.openSafe(safeTime);
- }
-
- /**
- * 当前会话 是否处于二级认证时间内
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
- */
- public static boolean isSafe() {
- return stpLogic.isSafe();
- }
-
- /**
- * 检查当前会话是否已通过二级认证，如未通过则抛出异常
- */
- public static void checkSafe() {
- stpLogic.checkSafe();
- }
-
- /**
- * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
- * @return 剩余有效时间
- */
- public static long getSafeTime() {
- return stpLogic.getSafeTime();
- }
-
- /**
- * 在当前会话 结束二级认证
- */
- public static void closeSafe() {
- stpLogic.closeSafe();
- }
-
-}
diff --git a/sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/SaTokenDemoApp.java b/sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/SaTokenDemoApp.java
index 8173ea54..8bc72dfa 100644
--- a/sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/SaTokenDemoApp.java
+++ b/sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/SaTokenDemoApp.java
@@ -1,11 +1,10 @@
package com.pj;
+import cn.dev33.satoken.SaManager;
import org.noear.solon.Solon;
import org.noear.solon.annotation.SolonMain;
-import cn.dev33.satoken.SaManager;
-
/**
* sa-token整合 solon 示例
* @author noear
diff --git a/sa-token-demo/sa-token-demo-test/src/main/java/com/pj/satoken/StpUserUtil.java b/sa-token-demo/sa-token-demo-test/src/main/java/com/pj/satoken/StpUserUtil.java
index 7431acec..23640c1c 100644
--- a/sa-token-demo/sa-token-demo-test/src/main/java/com/pj/satoken/StpUserUtil.java
+++ b/sa-token-demo/sa-token-demo-test/src/main/java/com/pj/satoken/StpUserUtil.java
@@ -1,9 +1,5 @@
package com.pj.satoken;
-import java.util.List;
-
-import org.springframework.stereotype.Component;
-
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.fun.SaFunction;
import cn.dev33.satoken.listener.SaTokenEventCenter;
@@ -12,91 +8,111 @@ import cn.dev33.satoken.stp.SaLoginModel;
import cn.dev33.satoken.stp.SaTokenInfo;
import cn.dev33.satoken.stp.StpLogic;
+import java.util.List;
+
/**
- * Sa-Token 权限认证工具类 （User版）
- * @author click33
+ * Sa-Token 权限认证工具类 (User版)
+ *
+ * @author click33
+ * @since <= 1.34.0
*/
-@Component
public class StpUserUtil {
-
+
private StpUserUtil() {}
-
+
/**
- * 账号类型标识
+ * 多账号体系下的类型标识
*/
- public static final String TYPE = "user";
-
+ public static final String TYPE = "login";
+
/**
- * 底层的 StpLogic 对象
+ * 底层使用的 StpLogic 对象
*/
- public static StpLogic stpLogic = new StpLogic(TYPE);
+ public static StpLogic stpLogic = new StpLogic(TYPE);
/**
* 获取当前 StpLogic 的账号类型
- * @return See Note
+ *
+ * @return /
*/
public static String getLoginType(){
return stpLogic.getLoginType();
}
/**
- * 重置 StpLogic 对象
- * 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
- * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
+ // ------------------- id 反查 token 相关操作 -------------------
+
+ /**
+ * 获取指定账号 id 的 token
+ *
+ * 在配置为允许并发登录时，此方法只会返回队列的最后一个 token，
+ * 如果你需要返回此账号 id 的所有 token，请调用 getTokenValueListByLoginId
+ * 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
- * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
+ /**
+ * 获取指定账号 id 指定设备类型端的 token
+ *
+ * 在配置为允许并发登录时，此方法只会返回队列的最后一个 token，
+ * 如果你需要返回此账号 id 的所有 token，请调用 getTokenValueListByLoginId
+ * 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
- *
- * @param loginId 指定账号id
+ *
+ * @param loginId 指定账号id
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, long time) {
@@ -783,17 +871,18 @@ public class StpUserUtil {
}
/**
- * 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
- *
+ * 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
+ *
* @param loginId 账号id
- * @return /
+ * @return /
*/
public static boolean isDisable(Object loginId) {
return stpLogic.isDisable(loginId);
}
/**
- * 校验：指定账号是否已被封禁，如果被封禁则抛出异常
+ * 校验：指定账号是否已被封禁，如果被封禁则抛出异常
+ *
* @param loginId 账号id
*/
public static void checkDisable(Object loginId) {
@@ -802,8 +891,9 @@ public class StpUserUtil {
/**
* 获取：指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+ *
* @param loginId 账号id
- * @return /
+ * @return /
*/
public static long getDisableTime(Object loginId) {
return stpLogic.getDisableTime(loginId);
@@ -811,20 +901,22 @@ public class StpUserUtil {
/**
* 解封：指定账号
+ *
* @param loginId 账号id
*/
public static void untieDisable(Object loginId) {
stpLogic.untieDisable(loginId);
}
-
- // ------------------- 分类封禁 -------------------
+
+ // ------------------- 分类封禁 -------------------
/**
- * 封禁：指定账号的指定服务
+ * 封禁：指定账号的指定服务
* 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
- * @param loginId 指定账号id
- * @param service 指定服务
+ *
+ * @param loginId 指定账号id
+ * @param service 指定服务
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, String service, long time) {
@@ -832,19 +924,21 @@ public class StpUserUtil {
}
/**
- * 判断：指定账号的指定服务 是否已被封禁 (true=已被封禁, false=未被封禁)
+ * 判断：指定账号的指定服务 是否已被封禁（true=已被封禁, false=未被封禁）
+ *
* @param loginId 账号id
- * @param service 指定服务
- * @return /
+ * @param service 指定服务
+ * @return /
*/
public static boolean isDisable(Object loginId, String service) {
return stpLogic.isDisable(loginId, service);
}
/**
- * 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
+ * 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
+ *
* @param loginId 账号id
- * @param services 指定服务，可以指定多个
+ * @param services 指定服务，可以指定多个
*/
public static void checkDisable(Object loginId, String... services) {
stpLogic.checkDisable(loginId, services);
@@ -852,9 +946,10 @@ public class StpUserUtil {
/**
* 获取：指定账号 指定服务 剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+ *
* @param loginId 账号id
- * @param service 指定服务
- * @return see note
+ * @param service 指定服务
+ * @return see note
*/
public static long getDisableTime(Object loginId, String service) {
return stpLogic.getDisableTime(loginId, service);
@@ -862,20 +957,22 @@ public class StpUserUtil {
/**
* 解封：指定账号、指定服务
+ *
* @param loginId 账号id
- * @param services 指定服务，可以指定多个
+ * @param services 指定服务，可以指定多个
*/
public static void untieDisable(Object loginId, String... services) {
stpLogic.untieDisable(loginId, services);
}
- // ------------------- 阶梯封禁 -------------------
+ // ------------------- 阶梯封禁 -------------------
/**
- * 封禁：指定账号，并指定封禁等级
- * @param loginId 指定账号id
- * @param level 指定封禁等级
+ * 封禁：指定账号，并指定封禁等级
+ *
+ * @param loginId 指定账号id
+ * @param level 指定封禁等级
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disableLevel(Object loginId, int level, long time) {
@@ -883,10 +980,11 @@ public class StpUserUtil {
}
/**
- * 封禁：指定账号的指定服务，并指定封禁等级
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 指定封禁等级
+ * 封禁：指定账号的指定服务，并指定封禁等级
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
+ * @param level 指定封禁等级
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disableLevel(Object loginId, String service, int level, long time) {
@@ -895,22 +993,22 @@ public class StpUserUtil {
/**
* 判断：指定账号是否已被封禁到指定等级
- *
- * @param loginId 指定账号id
- * @param level 指定封禁等级
- * @return /
+ *
+ * @param loginId 指定账号id
+ * @param level 指定封禁等级
+ * @return /
*/
public static boolean isDisableLevel(Object loginId, int level) {
return stpLogic.isDisableLevel(loginId, level);
}
/**
- * 判断：指定账号的指定服务，是否已被封禁到指定等级
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @param level 指定封禁等级
- * @return /
+ * 判断：指定账号的指定服务，是否已被封禁到指定等级
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
+ * @param level 指定封禁等级
+ * @return /
*/
public static boolean isDisableLevel(Object loginId, String service, int level) {
return stpLogic.isDisableLevel(loginId, service, level);
@@ -918,8 +1016,8 @@ public class StpUserUtil {
/**
* 校验：指定账号是否已被封禁到指定等级（如果已经达到，则抛出异常）
- *
- * @param loginId 指定账号id
+ *
+ * @param loginId 指定账号id
* @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
*/
public static void checkDisableLevel(Object loginId, int level) {
@@ -928,9 +1026,9 @@ public class StpUserUtil {
/**
* 校验：指定账号的指定服务，是否已被封禁到指定等级（如果已经达到，则抛出异常）
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
* @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
*/
public static void checkDisableLevel(Object loginId, String service, int level) {
@@ -938,37 +1036,38 @@ public class StpUserUtil {
}
/**
- * 获取：指定账号被封禁的等级，如果未被封禁则返回-2
- *
- * @param loginId 指定账号id
- * @return /
+ * 获取：指定账号被封禁的等级，如果未被封禁则返回-2
+ *
+ * @param loginId 指定账号id
+ * @return /
*/
public static int getDisableLevel(Object loginId) {
return stpLogic.getDisableLevel(loginId);
}
/**
- * 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
- *
- * @param loginId 指定账号id
- * @param service 指定封禁服务
- * @return /
+ * 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
+ *
+ * @param loginId 指定账号id
+ * @param service 指定封禁服务
+ * @return /
*/
public static int getDisableLevel(Object loginId, String service) {
return stpLogic.getDisableLevel(loginId, service);
}
-
-
- // ------------------- 身份切换 -------------------
+
+
+ // ------------------- 临时身份切换 -------------------
/**
- * 临时切换身份为指定账号id
- * @param loginId 指定loginId
+ * 临时切换身份为指定账号id
+ *
+ * @param loginId 指定loginId
*/
public static void switchTo(Object loginId) {
stpLogic.switchTo(loginId);
}
-
+
/**
* 结束临时切换身份
*/
@@ -977,86 +1076,95 @@ public class StpUserUtil {
}
/**
- * 当前是否正处于[身份临时切换]中
- * @return 是否正处于[身份临时切换]中
+ * 判断当前请求是否正处于 [ 身份临时切换 ] 中
+ *
+ * @return /
*/
public static boolean isSwitch() {
return stpLogic.isSwitch();
}
/**
- * 在一个代码段里方法内，临时切换身份为指定账号id
- * @param loginId 指定账号id
- * @param function 要执行的方法
+ * 在一个 lambda 代码段里，临时切换身份为指定账号id，lambda 结束后自动恢复
+ *
+ * @param loginId 指定账号id
+ * @param function 要执行的方法
*/
public static void switchTo(Object loginId, SaFunction function) {
stpLogic.switchTo(loginId, function);
}
-
- // ------------------- 二级认证 -------------------
-
+
+ // ------------------- 二级认证 -------------------
+
/**
- * 在当前会话 开启二级认证
- * @param safeTime 维持时间 (单位: 秒)
+ * 在当前会话 开启二级认证
+ *
+ * @param safeTime 维持时间 (单位: 秒)
*/
public static void openSafe(long safeTime) {
stpLogic.openSafe(safeTime);
}
/**
- * 在当前会话 开启二级认证
- * @param service 业务标识
- * @param safeTime 维持时间 (单位: 秒)
+ * 在当前会话 开启二级认证
+ *
+ * @param service 业务标识
+ * @param safeTime 维持时间 (单位: 秒)
*/
public static void openSafe(String service, long safeTime) {
stpLogic.openSafe(service, safeTime);
}
/**
- * 当前会话 是否处于二级认证时间内
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+ * 判断：当前会话是否处于二级认证时间内
+ *
+ * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe() {
return stpLogic.isSafe();
}
/**
- * 当前会话 是否处于二级认证时间内
- * @param service 业务标识
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+ * 判断：当前会话 是否处于指定业务的二级认证时间内
+ *
+ * @param service 业务标识
+ * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe(String service) {
return stpLogic.isSafe(service);
}
/**
- * 指定 Token 是否处于二级认证时间内
- * @param tokenValue Token 值
- * @param service 业务标识
- * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+ * 判断：指定 token 是否处于二级认证时间内
+ *
+ * @param tokenValue Token 值
+ * @param service 业务标识
+ * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe(String tokenValue, String service) {
return stpLogic.isSafe(tokenValue, service);
}
/**
- * 检查当前会话是否已通过二级认证，如未通过则抛出异常
+ * 校验：当前会话是否已通过二级认证，如未通过则抛出异常
*/
public static void checkSafe() {
stpLogic.checkSafe();
}
/**
- * 检查当前会话是否已通过二级认证，如未通过则抛出异常
- * @param service 业务标识
+ * 校验：检查当前会话是否已通过指定业务的二级认证，如未通过则抛出异常
+ *
+ * @param service 业务标识
*/
public static void checkSafe(String service) {
stpLogic.checkSafe(service);
}
-
+
/**
- * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
+ * 获取：当前会话的二级认证剩余有效时间（单位: 秒, 返回-2代表尚未通过二级认证）
+ *
* @return 剩余有效时间
*/
public static long getSafeTime() {
@@ -1064,8 +1172,9 @@ public class StpUserUtil {
}
/**
- * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
- * @param service 业务标识
+ * 获取：当前会话的二级认证剩余有效时间（单位: 秒, 返回-2代表尚未通过二级认证）
+ *
+ * @param service 业务标识
* @return 剩余有效时间
*/
public static long getSafeTime(String service) {
@@ -1073,14 +1182,15 @@ public class StpUserUtil {
}
/**
- * 在当前会话 结束二级认证
+ * 在当前会话 结束二级认证
*/
public static void closeSafe() {
stpLogic.closeSafe();
}
/**
- * 在当前会话 结束二级认证
+ * 在当前会话 结束指定业务标识的二级认证
+ *
* @param service 业务标识
*/
public static void closeSafe(String service) {
diff --git a/sa-token-doc/api/stp-util.md b/sa-token-doc/api/stp-util.md
index f9de7f50..1837df09 100644
--- a/sa-token-doc/api/stp-util.md
+++ b/sa-token-doc/api/stp-util.md
@@ -72,7 +72,7 @@ StpUtil.getExtra(token, key); // 获取指定 Token 的扩展信息（此函
### 5、Session 相关
``` java
-// User-Session 相关
+// Account-Session 相关
StpUtil.getSession(); // 获取当前会话的Session，如果Session尚未创建，则新建并返回
StpUtil.getSession(true); // 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回
StpUtil.getSessionByLoginId(10001); // 获取指定账号id的Session，如果Session尚未创建，则新建并返回
@@ -97,7 +97,7 @@ StpUtil.updateLastActivityToNow(); // 续签当前token：(将 [最后操作
// 长久有效期
StpUtil.getTokenTimeout(); // 获取当前登录者的 token 剩余有效时间 (单位: 秒)
-StpUtil.getSessionTimeout(); // 获取当前登录者的 User-Session 剩余有效时间 (单位: 秒)
+StpUtil.getSessionTimeout(); // 获取当前登录者的 Account-Session 剩余有效时间 (单位: 秒)
StpUtil.getTokenSessionTimeout(); // 获取当前 Token-Session 剩余有效时间 (单位: 秒)
StpUtil.renewTimeout(timeout); // 对当前 Token 的 timeout 值进行续期
StpUtil.renewTimeout(token, timeout); // 对指定 Token 的 timeout 值进行续期
diff --git a/sa-token-doc/fun/session-model.md b/sa-token-doc/fun/session-model.md
index 4d2fd66c..496ab6a4 100644
--- a/sa-token-doc/fun/session-model.md
+++ b/sa-token-doc/fun/session-model.md
@@ -2,7 +2,7 @@
---
-### 1、User-Session
+### 1、Account-Session
提起Session，你脑海中最先浮现的可能就是 JSP 中的 HttpSession，它的工作原理可以大致总结为：
@@ -24,17 +24,17 @@ Sa-Token Session可以理解为 HttpSession 的升级版：
3. Sa-Token支持Cookie、Header、body三个途径提交Token，而不是仅限于Cookie
4. 由于不强依赖Cookie，所以只要将Token存储到不同的地方，便可以做到一个客户端同时登录多个账号
-这种为账号id分配的Session，我们给它起一个合适的名字：`User-Session`，你可以通过如下方式操作它：
+这种为账号id分配的Session，我们给它起一个合适的名字：`Account-Session`，你可以通过如下方式操作它：
``` java
-// 获取当前会话的 User-Session
+// 获取当前会话的 Account-Session
SaSession session = StpUtil.getSession();
-// 从 User-Session 中读取、写入数据
+// 从 Account-Session 中读取、写入数据
session.get("name");
session.set("name", "张三");
```
-使用`User-Session`在不同端同步数据是非常方便的，因为只要 PC 和 APP 登录的账号id一致，它们对应的都是同一个Session，
+使用`Account-Session`在不同端同步数据是非常方便的，因为只要 PC 和 APP 登录的账号id一致，它们对应的都是同一个Session，
举个应用场景：在PC端点赞的帖子列表，在APP端的点赞记录里也要同步显示出来
@@ -44,13 +44,13 @@ session.set("name", "张三");
> 指定客户端超过两小时无操作就自动下线，如果两小时内有操作，就再续期两小时，直到新的两小时无操作
-那么这种请求访问记录应该存储在哪里呢？放在 User-Session 里吗？
+那么这种请求访问记录应该存储在哪里呢？放在 Account-Session 里吗？
-可别忘了，PC端和APP端可是共享的同一个 User-Session ，如果把数据放在这里，
+可别忘了，PC端和APP端可是共享的同一个 Account-Session ，如果把数据放在这里，
那就意味着，即使用户在PC端一直无操作，只要手机上用户还在不间断的操作，那PC端也不会过期！
解决这个问题的关键在于，虽然两个设备登录的是同一账号，但是两个它们得到的token是不一样的，
-Sa-Token针对会话登录，不仅为账号id分配了`User-Session`，同时还为每个token分配了不同的`Token-Session`
+Sa-Token针对会话登录，不仅为账号id分配了`Account-Session`，同时还为每个token分配了不同的`Token-Session`
不同的设备端，哪怕登录了同一账号，只要它们得到的token不一致，它们对应的 `Token-Session` 就不一致，这就为我们不同端的独立数据读写提供了支持：
@@ -91,7 +91,7 @@ session.updateTimeout(1000); // 参数说明和全局有效期保持一致
三种Session创建时机：
-- `User-Session`: 指的是框架为每个 账号id 分配的 Session
+- `Account-Session`: 指的是框架为每个 账号id 分配的 Session
- `Token-Session`: 指的是框架为每个 token 分配的 Session
- `Custom-Session`: 指的是以一个 特定的值 作为SessionId，来分配的 Session
@@ -101,7 +101,7 @@ session.updateTimeout(1000); // 参数说明和全局有效期保持一致
简而言之：
-- `User-Session` 以UserId为主，只要token指向的UserId一致，那么对应的Session对象就一致
+- `Account-Session` 以账号 id 为主，只要 token 指向的账号 id 一致，那么对应的Session对象就一致
- `Token-Session` 以token为主，只要token不同，那么对应的Session对象就不同
- `Custom-Session` 以特定的key为主，不同key对应不同的Session对象，同样的key指向同一个Session对象
diff --git a/sa-token-doc/fun/token-info.md b/sa-token-doc/fun/token-info.md
index 195d5942..ab31874b 100644
--- a/sa-token-doc/fun/token-info.md
+++ b/sa-token-doc/fun/token-info.md
@@ -13,7 +13,7 @@ token信息Model: 用来描述一个token的常用参数
"loginId": "10001", // 此token对应的LoginId，未登录时为null
"loginType": "login", // 账号类型标识
"tokenTimeout": 2591977, // token剩余有效期 (单位: 秒)
- "sessionTimeout": 2591977, // User-Session剩余有效时间 (单位: 秒)
+ "sessionTimeout": 2591977, // Account-Session剩余有效时间 (单位: 秒)
"tokenSessionTimeout": -2, // Token-Session剩余有效时间 (单位: 秒) (-2表示系统中不存在这个缓存)
"tokenActivityTimeout": -1, // token剩余无操作有效时间 (单位: 秒)
"loginDevice": "default-device" // 登录设备类型
diff --git a/sa-token-doc/more/common-questions.md b/sa-token-doc/more/common-questions.md
index 053979e0..9dcb325e 100644
--- a/sa-token-doc/more/common-questions.md
+++ b/sa-token-doc/more/common-questions.md
@@ -562,8 +562,8 @@ SaRouter.match("/**").notMatch("/login", "/reg").check(r -> StpUtil.checkLogin()
### Q：StpUtil.getSession()必须登录后才能调用吗？如果我想在用户未登录之前存储一些数据应该怎么办？
-`StpUtil.getSession()`获取的是`User-Session`，必须登录后才能使用，如果需要在未登录状态下也使用Session功能，请使用`Token-Session`
1、更改此账户的 StpLogic 对象
- *
2、put 到全局 StpLogic 集合中
- *
3、发送日志
- *
- * @param newStpLogic /
+ * 安全的重置 StpLogic 对象
+ *
+ *
1、更改此账户的 StpLogic 对象
+ *
2、put 到全局 StpLogic 集合中
+ *
3、发送日志
+ *
+ * @param newStpLogic /
*/
public static void setStpLogic(StpLogic newStpLogic) {
- // 重置此账户的 StpLogic 对象
+ // 1、重置此账户的 StpLogic 对象
stpLogic = newStpLogic;
-
- // 添加到全局 StpLogic 集合中
- // 以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic
+
+ // 2、添加到全局 StpLogic 集合中
+ // 以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic
SaManager.putStpLogic(newStpLogic);
-
- // $$ 全局事件
+
+ // 3、$$ 发布事件：更新了 stpLogic 对象
SaTokenEventCenter.doSetStpLogic(stpLogic);
}
/**
* 获取 StpLogic 对象
- * @return /
+ *
+ * @return /
*/
public static StpLogic getStpLogic() {
return stpLogic;
}
-
-
- // ------------------- 获取token 相关 -------------------
+
+
+ // ------------------- 获取 token 相关 -------------------
/**
- * 返回token名称
- * @return 此StpLogic的token名称
+ * 返回 token 名称，此名称在以下地方体现：Cookie 保存 token 时的名称、提交 token 时参数的名称、存储 token 时的 key 前缀
+ *
+ * @return /
*/
public static String getTokenName() {
- return stpLogic.getTokenName();
- }
+ return stpLogic.getTokenName();
+ }
- /**
- * 在当前会话写入当前TokenValue
- * @param tokenValue token值
- */
+ /**
+ * 在当前会话写入指定 token 值
+ *
+ * @param tokenValue token 值
+ */
public static void setTokenValue(String tokenValue){
stpLogic.setTokenValue(tokenValue);
}
-
- /**
- * 在当前会话写入当前TokenValue
- * @param tokenValue token值
- * @param cookieTimeout Cookie存活时间(秒)
- */
+
+ /**
+ * 在当前会话写入指定 token 值
+ *
+ * @param tokenValue token 值
+ * @param cookieTimeout Cookie存活时间(秒)
+ */
public static void setTokenValue(String tokenValue, int cookieTimeout){
stpLogic.setTokenValue(tokenValue, cookieTimeout);
}
-
+
/**
- * 获取当前TokenValue
+ * 在当前会话写入指定 token 值
+ *
+ * @param tokenValue token 值
+ * @param loginModel 登录参数
+ */
+ public static void setTokenValue(String tokenValue, SaLoginModel loginModel){
+ stpLogic.setTokenValue(tokenValue, loginModel);
+ }
+
+ /**
+ * 获取当前请求的 token 值
+ *
* @return 当前tokenValue
*/
public static String getTokenValue() {
@@ -104,28 +120,31 @@ public class StpUserUtil {
}
/**
- * 获取当前TokenValue (不裁剪前缀)
- * @return /
+ * 获取当前请求的 token 值 （不裁剪前缀）
+ *
+ * @return /
*/
public static String getTokenValueNotCut(){
return stpLogic.getTokenValueNotCut();
}
/**
- * 获取当前会话的Token信息
- * @return token信息
+ * 获取当前会话的 token 参数信息
+ *
+ * @return token 参数信息
*/
public static SaTokenInfo getTokenInfo() {
return stpLogic.getTokenInfo();
}
-
+
// ------------------- 登录相关操作 -------------------
- // --- 登录
-
+ // --- 登录
+
/**
- * 会话登录
+ * 会话登录
+ *
* @param id 账号id，建议的类型：（long | int | String）
*/
public static void login(Object id) {
@@ -134,6 +153,7 @@ public class StpUserUtil {
/**
* 会话登录，并指定登录设备类型
+ *
* @param id 账号id，建议的类型：（long | int | String）
* @param device 设备类型
*/
@@ -144,27 +164,27 @@ public class StpUserUtil {
/**
* 会话登录，并指定是否 [记住我]
*
- * @param id 账号id，建议的类型：（long | int | String）
- * @param isLastingCookie 是否为持久Cookie
+ * @param id 账号id，建议的类型：（long | int | String）
+ * @param isLastingCookie 是否为持久Cookie，值为 true 时记住我，值为 false 时关闭浏览器需要重新登录
*/
public static void login(Object id, boolean isLastingCookie) {
stpLogic.login(id, isLastingCookie);
}
/**
- * 会话登录，并指定此次登录token的有效期, 单位:秒
+ * 会话登录，并指定此次登录 token 的有效期, 单位:秒
*
* @param id 账号id，建议的类型：（long | int | String）
- * @param timeout 此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
+ * @param timeout 此次登录 token 的有效期, 单位:秒
*/
public static void login(Object id, long timeout) {
stpLogic.login(id, timeout);
}
/**
- * 会话登录，并指定所有登录参数Model
+ * 会话登录，并指定所有登录参数 Model
*
- * @param id 登录id，建议的类型：（long | int | String）
+ * @param id 账号id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
*/
public static void login(Object id, SaLoginModel loginModel) {
@@ -172,36 +192,39 @@ public class StpUserUtil {
}
/**
- * 创建指定账号id的登录会话
- * @param id 登录id，建议的类型：（long | int | String）
- * @return 返回会话令牌
+ * 创建指定账号 id 的登录会话数据
+ *
+ * @param id 账号id，建议的类型：（long | int | String）
+ * @return 返回会话令牌
*/
public static String createLoginSession(Object id) {
return stpLogic.createLoginSession(id);
}
-
+
/**
- * 创建指定账号id的登录会话
- * @param id 登录id，建议的类型：（long | int | String）
- * @param loginModel 此次登录的参数Model
- * @return 返回会话令牌
+ * 创建指定账号 id 的登录会话数据
+ *
+ * @param id 账号id，建议的类型：（long | int | String）
+ * @param loginModel 此次登录的参数Model
+ * @return 返回会话令牌
*/
public static String createLoginSession(Object id, SaLoginModel loginModel) {
return stpLogic.createLoginSession(id, loginModel);
}
-
- // --- 注销
-
- /**
- * 会话注销
+
+ // --- 注销
+
+ /**
+ * 在当前客户端会话注销
*/
public static void logout() {
stpLogic.logout();
}
/**
- * 会话注销，根据账号id
- * @param loginId 账号id
+ * 会话注销，根据账号id
+ *
+ * @param loginId 账号id
*/
public static void logout(Object loginId) {
stpLogic.logout(loginId);
@@ -209,146 +232,154 @@ public class StpUserUtil {
/**
* 会话注销，根据账号id 和 设备类型
- *
- * @param loginId 账号id
- * @param device 设备类型 (填null代表注销所有设备类型)
+ *
+ * @param loginId 账号id
+ * @param device 设备类型 (填 null 代表注销该账号的所有设备类型)
*/
public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device);
}
-
+
/**
- * 会话注销，根据指定 Token
- *
- * @param tokenValue 指定token
+ * 会话注销，根据指定 Token
+ *
+ * @param tokenValue 指定 token
*/
public static void logoutByTokenValue(String tokenValue) {
stpLogic.logoutByTokenValue(tokenValue);
}
-
+
/**
- * 踢人下线，根据账号id
- * 请注意: 即使token已经 [临时过期] 也可续签成功，
- * 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可
- */
- public static void updateLastActivityToNow() {
- stpLogic.updateLastActivityToNow();
- }
-
-
- // ------------------- 过期时间相关 -------------------
-
- /**
- * 获取当前登录者的 token 剩余有效时间 (单位: 秒)
- * @return token剩余有效时间
- */
- public static long getTokenTimeout() {
- return stpLogic.getTokenTimeout();
- }
-
- /**
- * 获取当前登录者的 User-Session 剩余有效时间 (单位: 秒)
- * @return token剩余有效时间
- */
- public static long getSessionTimeout() {
- return stpLogic.getSessionTimeout();
- }
-
- /**
- * 获取当前 Token-Session 剩余有效时间 (单位: 秒)
- * @return token剩余有效时间
- */
- public static long getTokenSessionTimeout() {
- return stpLogic.getTokenSessionTimeout();
- }
-
- /**
- * 获取当前 token [临时过期] 剩余有效时间 (单位: 秒)
- * @return token [临时过期] 剩余有效时间
- */
- public static long getTokenActivityTimeout() {
- return stpLogic.getTokenActivityTimeout();
- }
-
- /**
- * 对当前 Token 的 timeout 值进行续期
- * @param timeout 要修改成为的有效时间 (单位: 秒)
- */
- public static void renewTimeout(long timeout) {
- stpLogic.renewTimeout(timeout);
- }
-
- /**
- * 对指定 Token 的 timeout 值进行续期
- * @param tokenValue 指定token
- * @param timeout 要修改成为的有效时间 (单位: 秒)
- */
- public static void renewTimeout(String tokenValue, long timeout) {
- stpLogic.renewTimeout(tokenValue, timeout);
- }
-
-
- // ------------------- 角色验证操作 -------------------
+ * 检查当前 token 是否已被冻结，如果是则抛出异常
+ */
+ public static void checkActivityTimeout() {
+ stpLogic.checkActivityTimeout();
+ }
/**
- * 获取：当前账号的角色集合
+ * 续签当前 token：(将 [最后操作时间] 更新为当前时间戳)
+ *
+ * 请注意: 即使 token 已被冻结 也可续签成功，
+ * 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否冻结即可
+ *
+ */
+ public static void updateLastActivityToNow() {
+ stpLogic.updateLastActivityToNow();
+ }
+
+
+ // ------------------- 过期时间相关 -------------------
+
+ /**
+ * 获取当前会话 token 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+ *
+ * @return token剩余有效时间
+ */
+ public static long getTokenTimeout() {
+ return stpLogic.getTokenTimeout();
+ }
+
+ /**
+ * 获取指定 token 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+ *
+ * @param token 指定token
+ * @return token剩余有效时间
+ */
+ public static long getTokenTimeout(String token) {
+ return stpLogic.getTokenTimeout(token);
+ }
+
+ /**
+ * 获取当前登录账号的 Account-Session 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+ *
+ * @return token剩余有效时间
+ */
+ public static long getSessionTimeout() {
+ return stpLogic.getSessionTimeout();
+ }
+
+ /**
+ * 获取当前 token 的 Token-Session 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+ *
+ * @return token剩余有效时间
+ */
+ public static long getTokenSessionTimeout() {
+ return stpLogic.getTokenSessionTimeout();
+ }
+
+ /**
+ * 获取当前 token 剩余活跃有效期：当前 token 距离被冻结还剩多少时间（单位: 秒，返回 -1 代表永不冻结，-2 代表没有这个值或 token 已被冻结了）
+ *
+ * @return /
+ */
+ public static long getTokenActivityTimeout() {
+ return stpLogic.getTokenActivityTimeout();
+ }
+
+ /**
+ * 对当前 token 的 timeout 值进行续期
+ *
+ * @param timeout 要修改成为的有效时间 (单位: 秒)
+ */
+ public static void renewTimeout(long timeout) {
+ stpLogic.renewTimeout(timeout);
+ }
+
+ /**
+ * 对指定 token 的 timeout 值进行续期
+ *
+ * @param tokenValue 指定 token
+ * @param timeout 要修改成为的有效时间 (单位: 秒，填 -1 代表要续为永久有效)
+ */
+ public static void renewTimeout(String tokenValue, long timeout) {
+ stpLogic.renewTimeout(tokenValue, timeout);
+ }
+
+
+ // ------------------- 角色认证操作 -------------------
+
+ /**
+ * 获取：当前账号的角色集合
+ *
* @return /
*/
public static List
-步骤：先在配置文件里将`tokenSessionCheckLogin`配置为`false`，然后通过`StpUtil.getTokenSession()`获取Session
+`StpUtil.getSession()`获取的是`Account-Session`，必须登录后才能使用，如果需要在未登录状态下也使用Session功能，请使用`Token-Session`
+步骤：先在配置文件里将`tokenSessionCheckLogin`配置为`false`，然后通过`StpUtil.getTokenSession()`获取Session 。或者直接调用 `StpUtil.getAnonTokenSession()` 获取匿名 Token-Session。
### Q：我只使用header来传输token，还需要打开Cookie模式吗？
diff --git a/sa-token-doc/more/noun-intro.md b/sa-token-doc/more/noun-intro.md
index 67766d95..8d85314c 100644
--- a/sa-token-doc/more/noun-intro.md
+++ b/sa-token-doc/more/noun-intro.md
@@ -24,7 +24,7 @@ Sa-Token 无意发明任何晦涩概念提升逼格，但在处理 issue 、Q群
#### 三种Session：
-- User-Session：框架为每个账号分配的 Session 对象，也称：账号Session。
+- Account-Session：框架为每个账号分配的 Session 对象，也称：账号Session。
- Token-Session：框架为每个 Token 分配的 Session 对象，也称：令牌Session。
- Custom-Session：以一个特定的值作为SessionId，来分配的 Session 对象，也称：自定义Session。
diff --git a/sa-token-doc/up/mock-person.md b/sa-token-doc/up/mock-person.md
index 51fbf551..748cd384 100644
--- a/sa-token-doc/up/mock-person.md
+++ b/sa-token-doc/up/mock-person.md
@@ -3,7 +3,7 @@
以上介绍的 API 都是操作当前账号，对当前账号进行各种鉴权操作，你可能会问，我能不能对别的账号进行一些操作？
-比如：查看账号 10001 有无某个权限码、获取 账号 id=10002 的 `User-Session`，等等...
+比如：查看账号 10001 有无某个权限码、获取 账号 id=10002 的 `Account-Session`，等等...
Sa-Token 在 API 设计时充分考虑了这一点，暴露出多个api进行此类操作：
diff --git a/sa-token-doc/use/config.md b/sa-token-doc/use/config.md
index 5fdb8cd8..a4828da3 100644
--- a/sa-token-doc/use/config.md
+++ b/sa-token-doc/use/config.md
@@ -297,7 +297,7 @@ sa-token.oauth2.is-client=true
配置含义：同一账号最大登录数量。
在配置 `isConcurrent=true`, `isShare=false` 时，Sa-Token 将允许同一账号并发登录，且每次登录都会产生一个新Token，
-这些 Token 都会以 `TokenSign` 的形式记录在其 `User-Session` 之上，这就造成一个问题：
+这些 Token 都会以 `TokenSign` 的形式记录在其 `Account-Session` 之上，这就造成一个问题：
随着同一账号登录的次数越来越多，TokenSign 的列表也会越来越大，极端情况下，列表长度可能达到成百上千以上，严重拖慢数据处理速度，
为此 Sa-Token 对这个 TokenSign 列表的大小设定一个上限值，也就是 `maxLoginCount`，默认值=12。
@@ -310,7 +310,7 @@ sa-token.oauth2.is-client=true
在调用 `StpUtil.login(id)` 登录后，
-- 调用 `StpUtil.getSession()` 可以获取这个会话的 `User-Session` 对象。
+- 调用 `StpUtil.getSession()` 可以获取这个会话的 `Account-Session` 对象。
- 调用 `StpUtil.getTokenSession()` 可以获取这个会话 `Token-Session` 对象。
关于两种 Session 有何区别，可以参考这篇：[Session模型详解](/fun/session-model)，此处暂不赘述。
diff --git a/sa-token-doc/use/session.md b/sa-token-doc/use/session.md
index 7b60583d..27e9aad7 100644
--- a/sa-token-doc/use/session.md
+++ b/sa-token-doc/use/session.md
@@ -16,14 +16,14 @@ SysUser user = (SysUser) StpUtil.getSession().get("user");
在 Sa-Token 中，Session 分为三种，分别是：
-- `User-Session`: 指的是框架为每个 账号id 分配的 Session
+- `Account-Session`: 指的是框架为每个 账号id 分配的 Session
- `Token-Session`: 指的是框架为每个 token 分配的 Session
- `Custom-Session`: 指的是以一个 特定的值 作为SessionId，来分配的 Session
-> 有关User-Session与Token-Session的详细区别，可参考：[Session模型详解](/fun/session-model)
+> 有关Account-Session与Token-Session的详细区别，可参考：[Session模型详解](/fun/session-model)
-### User-Session
+### Account-Session
有关账号Session的API如下：
``` java
// 获取当前账号id的Session (必须是登录后才能调用)
diff --git a/sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/springboot/ManyLoginTest.java b/sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/springboot/ManyLoginTest.java
index e506175b..e1fe211a 100644
--- a/sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/springboot/ManyLoginTest.java
+++ b/sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/springboot/ManyLoginTest.java
@@ -99,7 +99,7 @@ public class ManyLoginTest {
// token1会被标记为：已被顶下线
Assertions.assertEquals(dao.get("satoken:login:token:" + token1), "-4");
- // User-Session里的 token1 签名会被移除
+ // Account-Session里的 token1 签名会被移除
List