lsm/sa-token
1
0
Fork 0
mirror of https://gitee.com/dromara/sa-token.git synced 2026-02-27 16:50:24 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

优化源码注释，更符合语义

Browse Source
This commit is contained in:
click33
2022-04-23 17:26:48 +08:00
parent 2c39fc7209
commit 210b92f3dc
25 changed files with 130 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@@ -75,8 +75,8 @@ StpUtil.hasPermission("user:add"); // 查询当前账号是否含有指定权
StpUtil.getSession(); // 获取当前账号id的Session StpUtil.getSession(); // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001); // 获取账号id为10001的Session StpUtil.getSessionByLoginId(10001); // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值 StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC"); // 指定设备标识登录，常用于“同端互斥登录” StpUtil.login(10001, "PC"); // 指定设备类型登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC"); // 指定账号指定设备标识踢下线 (不同端不受影响) StpUtil.kickout(10001, "PC"); // 指定账号指定设备类型踢下线 (不同端不受影响)
StpUtil.openSafe(120); // 在当前会话开启二级认证，有效期为120秒 StpUtil.openSafe(120); // 在当前会话开启二级认证，有效期为120秒
StpUtil.checkSafe(); // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常 StpUtil.checkSafe(); // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常
StpUtil.switchTo(10044); // 将当前会话身份临时切换为其它账号 StpUtil.switchTo(10044); // 将当前会话身份临时切换为其它账号

2
sa-token-core/src/main/java/cn/dev33/satoken/session/SaSession.java
View File

@@ -154,7 +154,7 @@ public class SaSession implements Serializable {
* 添加一个token签名 * 添加一个token签名
* *
* @param tokenValue token值 * @param tokenValue token值
* @param device 设备标识 * @param device 设备类型
*/ */
public void addTokenSign(String tokenValue, String device) { public void addTokenSign(String tokenValue, String device) {
addTokenSign(new TokenSign(tokenValue, device)); addTokenSign(new TokenSign(tokenValue, device));

6
sa-token-core/src/main/java/cn/dev33/satoken/session/TokenSign.java
View File

@@ -23,7 +23,7 @@ public class TokenSign implements Serializable {
private String value; private String value;
/** /**
* 所在设备标识 * 所属设备类型
*/ */
private String device; private String device;
@@ -35,7 +35,7 @@ public class TokenSign implements Serializable {
* 构建一个 * 构建一个
* *
* @param value token值 * @param value token值
* @param device 所在设备标识 * @param device 所属设备类型
*/ */
public TokenSign(String value, String device) { public TokenSign(String value, String device) {
this.value = value; this.value = value;
@@ -50,7 +50,7 @@ public class TokenSign implements Serializable {
} }
/** /**
* @return token登录设备 * @return 所属设备类型
*/ */
public String getDevice() { public String getDevice() {
return device; return device;

2
sa-token-core/src/main/java/cn/dev33/satoken/stp/SaLoginConfig.java
View File

@@ -12,7 +12,7 @@ import java.util.Map;
public class SaLoginConfig { public class SaLoginConfig {
/** /**
* @param device 此次登录的客户端设备标识 * @param device 此次登录的客户端设备类型
* @return SaLoginModel配置对象 * @return SaLoginModel配置对象
*/ */
public static SaLoginModel setDevice(String device) { public static SaLoginModel setDevice(String device) {

6
sa-token-core/src/main/java/cn/dev33/satoken/stp/SaLoginModel.java
View File

@@ -16,7 +16,7 @@ import cn.dev33.satoken.util.SaTokenConsts;
public class SaLoginModel { public class SaLoginModel {
/** /**
* 此次登录的客户端设备标识 * 此次登录的客户端设备类型
*/ */
public String device; public String device;
@@ -42,14 +42,14 @@ public class SaLoginModel {
/** /**
* @return 此次登录的客户端设备标识 * @return 此次登录的客户端设备类型
*/ */
public String getDevice() { public String getDevice() {
return device; return device;
} }
/** /**
* @param device 此次登录的客户端设备标识 * @param device 此次登录的客户端设备类型
* @return 对象自身 * @return 对象自身
*/ */
public SaLoginModel setDevice(String device) { public SaLoginModel setDevice(String device) {

6
sa-token-core/src/main/java/cn/dev33/satoken/stp/SaTokenInfo.java
View File

@@ -35,7 +35,7 @@ public class SaTokenInfo {
/** token剩余无操作有效时间 (单位: 秒) */ /** token剩余无操作有效时间 (单位: 秒) */
public long tokenActivityTimeout; public long tokenActivityTimeout;
/** 登录设备标识 */ /** 登录设备类型 */
public String loginDevice; public String loginDevice;
/** 自定义数据 */ /** 自定义数据 */
@@ -170,14 +170,14 @@ public class SaTokenInfo {
} }
/** /**
* @return 登录设备标识 * @return 登录设备类型
*/ */
public String getLoginDevice() { public String getLoginDevice() {
return loginDevice; return loginDevice;
} }
/** /**
* @param loginDevice 登录设备标识 * @param loginDevice 登录设备类型
*/ */
public void setLoginDevice(String loginDevice) { public void setLoginDevice(String loginDevice) {
this.loginDevice = loginDevice; this.loginDevice = loginDevice;

38
sa-token-core/src/main/java/cn/dev33/satoken/stp/StpLogic.java
View File

@@ -84,7 +84,7 @@ public class StpLogic {
/** /**
* 创建一个TokenValue * 创建一个TokenValue
* @param loginId loginId * @param loginId loginId
* @param device 设备标识 * @param device 设备类型
* @param timeout 过期时间 * @param timeout 过期时间
* @param extraData 扩展信息 * @param extraData 扩展信息
* @return 生成的tokenValue * @return 生成的tokenValue
@@ -251,9 +251,9 @@ public class StpLogic {
} }
/** /**
* 会话登录，并指定登录设备 * 会话登录，并指定登录设备类型
* @param id 账号id，建议的类型：（long | int | String） * @param id 账号id，建议的类型：（long | int | String）
* @param device 设备标识 * @param device 设备类型
*/ */
public void login(Object id, String device) { public void login(Object id, String device) {
login(id, new SaLoginModel().setDevice(device)); login(id, new SaLoginModel().setDevice(device));
@@ -385,10 +385,10 @@ public class StpLogic {
} }
/** /**
* 会话注销，根据账号id 和 设备标识 * 会话注销，根据账号id 和 设备类型
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备) * @param device 设备类型 (填null代表注销所有设备类型)
*/ */
public void logout(Object loginId, String device) { public void logout(Object loginId, String device) {
clearTokenCommonMethod(loginId, device, tokenValue -> { clearTokenCommonMethod(loginId, device, tokenValue -> {
@@ -444,11 +444,11 @@ public class StpLogic {
} }
/** /**
* 踢人下线，根据账号id 和 设备标识 * 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表踢出所有设备) * @param device 设备类型 (填null代表踢出所有设备类型)
*/ */
public void kickout(Object loginId, String device) { public void kickout(Object loginId, String device) {
clearTokenCommonMethod(loginId, device, tokenValue -> { clearTokenCommonMethod(loginId, device, tokenValue -> {
@@ -491,11 +491,11 @@ public class StpLogic {
} }
/** /**
* 顶人下线，根据账号id 和 设备标识 * 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表顶替所有设备) * @param device 设备类型 (填null代表顶替所有设备类型)
*/ */
public void replaced(Object loginId, String device) { public void replaced(Object loginId, String device) {
clearTokenCommonMethod(loginId, device, tokenValue -> { clearTokenCommonMethod(loginId, device, tokenValue -> {
@@ -508,7 +508,7 @@ public class StpLogic {
/** /**
* 封装 注销、踢人、顶人 三个动作的相同代码（无API含义方法） * 封装 注销、踢人、顶人 三个动作的相同代码（无API含义方法）
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @param appendFun 追加操作 * @param appendFun 追加操作
* @param isLogoutSession 是否注销 User-Session * @param isLogoutSession 是否注销 User-Session
*/ */
@@ -1347,11 +1347,11 @@ public class StpLogic {
} }
/** /**
* 获取指定账号id指定设备端的tokenValue * 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token， * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识，填null代表不限设备 * @param device 设备类型，填null代表不限设备类型
* @return token值 * @return token值
*/ */
public String getTokenValueByLoginId(Object loginId, String device) { public String getTokenValueByLoginId(Object loginId, String device) {
@@ -1369,9 +1369,9 @@ public class StpLogic {
} }
/** /**
* 获取指定账号id指定设备端的tokenValue 集合 * 获取指定账号id指定设备类型端的tokenValue 集合
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识，填null代表不限设备 * @param device 设备类型，填null代表不限设备类型
* @return 此loginId的所有相关token * @return 此loginId的所有相关token
*/ */
public List<String> getTokenValueListByLoginId(Object loginId, String device) { public List<String> getTokenValueListByLoginId(Object loginId, String device) {
@@ -1392,8 +1392,8 @@ public class StpLogic {
} }
/** /**
* 返回当前会话的登录设备 * 返回当前会话的登录设备类型
* @return 当前令牌的登录设备 * @return 当前令牌的登录设备类型
*/ */
public String getLoginDevice() { public String getLoginDevice() {
// 如果没有token，直接返回 null // 如果没有token，直接返回 null
@@ -1799,10 +1799,10 @@ public class StpLogic {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout(id) ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout(id) ，使用方式保持不变 </h1>
* *
* 会话注销，根据账号id and 设备标识 （踢人下线） * 会话注销，根据账号id and 设备类型 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备) * @param device 设备类型 (填null代表注销所有设备类型)
*/ */
@Deprecated @Deprecated
public void logoutByLoginId(Object loginId, String device) { public void logoutByLoginId(Object loginId, String device) {
@@ -1812,7 +1812,7 @@ public class StpLogic {
/** /**
* 创建一个TokenValue * 创建一个TokenValue
* @param loginId loginId * @param loginId loginId
* @param device 设备标识 * @param device 设备类型
* @param timeout 过期时间 * @param timeout 过期时间
* @return 生成的tokenValue * @return 生成的tokenValue
*/ */

38
sa-token-core/src/main/java/cn/dev33/satoken/stp/StpUtil.java
View File

@@ -106,9 +106,9 @@ public class StpUtil {
} }
/** /**
* 会话登录，并指定登录设备 * 会话登录，并指定登录设备类型
* @param id 账号id，建议的类型：（long | int | String） * @param id 账号id，建议的类型：（long | int | String）
* @param device 设备标识 * @param device 设备类型
*/ */
public static void login(Object id, String device) { public static void login(Object id, String device) {
stpLogic.login(id, device); stpLogic.login(id, device);
@@ -169,10 +169,10 @@ public class StpUtil {
} }
/** /**
* 会话注销，根据账号id 和 设备标识 * 会话注销，根据账号id 和 设备类型
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备) * @param device 设备类型 (填null代表注销所有设备类型)
*/ */
public static void logout(Object loginId, String device) { public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device); stpLogic.logout(loginId, device);
@@ -198,11 +198,11 @@ public class StpUtil {
} }
/** /**
* 踢人下线，根据账号id 和 设备标识 * 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表踢出所有设备) * @param device 设备类型 (填null代表踢出所有设备类型)
*/ */
public static void kickout(Object loginId, String device) { public static void kickout(Object loginId, String device) {
stpLogic.kickout(loginId, device); stpLogic.kickout(loginId, device);
@@ -219,11 +219,11 @@ public class StpUtil {
} }
/** /**
* 顶人下线，根据账号id 和 设备标识 * 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表顶替所有设备) * @param device 设备类型 (填null代表顶替所有设备类型)
*/ */
public static void replaced(Object loginId, String device) { public static void replaced(Object loginId, String device) {
stpLogic.replaced(loginId, device); stpLogic.replaced(loginId, device);
@@ -630,11 +630,11 @@ public class StpUtil {
} }
/** /**
* 获取指定账号id指定设备端的tokenValue * 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token， * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @return token值 * @return token值
*/ */
public static String getTokenValueByLoginId(Object loginId, String device) { public static String getTokenValueByLoginId(Object loginId, String device) {
@@ -651,9 +651,9 @@ public class StpUtil {
} }
/** /**
* 获取指定账号id指定设备端的tokenValue 集合 * 获取指定账号id指定设备类型端的tokenValue 集合
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @return 此loginId的所有相关token * @return 此loginId的所有相关token
*/ */
public static List<String> getTokenValueListByLoginId(Object loginId, String device) { public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
@@ -661,8 +661,8 @@ public class StpUtil {
} }
/** /**
* 返回当前会话的登录设备 * 返回当前会话的登录设备类型
* @return 当前令牌的登录设备 * @return 当前令牌的登录设备类型
*/ */
public static String getLoginDevice() { public static String getLoginDevice() {
return stpLogic.getLoginDevice(); return stpLogic.getLoginDevice();
@@ -847,9 +847,9 @@ public class StpUtil {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* *
* 在当前会话上登录id, 并指定登录设备 * 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String） * @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识 * @param device 设备类型
*/ */
@Deprecated @Deprecated
public static void setLoginId(Object loginId, String device) { public static void setLoginId(Object loginId, String device) {
@@ -859,7 +859,7 @@ public class StpUtil {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* *
* 在当前会话上登录id, 并指定登录设备 * 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String） * @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie * @param isLastingCookie 是否为持久Cookie
*/ */
@@ -895,10 +895,10 @@ public class StpUtil {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1>
* *
* 会话注销，根据账号id and 设备标识 （踢人下线） * 会话注销，根据账号id and 设备类型 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备) * @param device 设备类型 (填null代表注销所有设备类型)
*/ */
@Deprecated @Deprecated
public static void logoutByLoginId(Object loginId, String device) { public static void logoutByLoginId(Object loginId, String device) {

2
sa-token-core/src/main/java/cn/dev33/satoken/util/SaTokenConsts.java
View File

@@ -43,7 +43,7 @@ public class SaTokenConsts {
public static final String TOKEN_ACTIVITY_TIMEOUT_CHECKED_KEY = "TOKEN_ACTIVITY_TIMEOUT_CHECKED_KEY_"; public static final String TOKEN_ACTIVITY_TIMEOUT_CHECKED_KEY = "TOKEN_ACTIVITY_TIMEOUT_CHECKED_KEY_";
/** /**
* 常量key标记: 在登录时，默认使用的设备名称 * 常量key标记: 在登录时，默认使用的设备类型
*/ */
public static final String DEFAULT_LOGIN_DEVICE = "default-device"; public static final String DEFAULT_LOGIN_DEVICE = "default-device";

4
sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/test/TestController.java
View File

@@ -192,7 +192,7 @@ public class TestController {
return AjaxJson.getSuccess(); return AjaxJson.getSuccess();
} }
// 测试登录接口, 按照设备登录， 浏览器访问： http://localhost:8081/test/login2 // 测试登录接口, 按照设备类型登录， 浏览器访问： http://localhost:8081/test/login2
@Mapping("login2") @Mapping("login2")
public AjaxJson login2(@Param(defaultValue="10001") String id, @Param(defaultValue="PC") String device) { public AjaxJson login2(@Param(defaultValue="10001") String id, @Param(defaultValue="PC") String device) {
StpUtil.login(id, device); StpUtil.login(id, device);
@@ -226,7 +226,7 @@ public class TestController {
return AjaxJson.getSuccess(); return AjaxJson.getSuccess();
} }
// 测试指定设备登录 浏览器访问： http://localhost:8081/test/loginByDevice // 测试指定设备类型登录 浏览器访问： http://localhost:8081/test/loginByDevice
@Mapping("loginByDevice") @Mapping("loginByDevice")
public AjaxJson loginByDevice() { public AjaxJson loginByDevice() {
System.out.println("--------------"); System.out.println("--------------");

70
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/satoken/at/StpUserUtil.java
View File

@@ -11,7 +11,7 @@ import cn.dev33.satoken.stp.StpLogic;
import cn.dev33.satoken.stp.StpUtil; import cn.dev33.satoken.stp.StpUtil;
/** /**
* Sa-Token 权限认证工具类 (User版) * Sa-Token 权限认证工具类 (user版)
* @author kong * @author kong
*/ */
public class StpUserUtil { public class StpUserUtil {
@@ -110,9 +110,9 @@ public class StpUserUtil {
} }
/** /**
* 会话登录，并指定登录设备 * 会话登录，并指定登录设备类型
* @param id 账号id，建议的类型：（long | int | String） * @param id 账号id，建议的类型：（long | int | String）
* @param device 设备标识 * @param device 设备类型
*/ */
public static void login(Object id, String device) { public static void login(Object id, String device) {
stpLogic.login(id, device); stpLogic.login(id, device);
@@ -173,10 +173,10 @@ public class StpUserUtil {
} }
/** /**
* 会话注销，根据账号id 和 设备标识 * 会话注销，根据账号id 和 设备类型
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备) * @param device 设备类型 (填null代表注销所有设备类型)
*/ */
public static void logout(Object loginId, String device) { public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device); stpLogic.logout(loginId, device);
@@ -202,11 +202,11 @@ public class StpUserUtil {
} }
/** /**
* 踢人下线，根据账号id 和 设备标识 * 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表踢出所有设备) * @param device 设备类型 (填null代表踢出所有设备类型)
*/ */
public static void kickout(Object loginId, String device) { public static void kickout(Object loginId, String device) {
stpLogic.kickout(loginId, device); stpLogic.kickout(loginId, device);
@@ -223,11 +223,11 @@ public class StpUserUtil {
} }
/** /**
* 顶人下线，根据账号id 和 设备标识 * 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
* *
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表顶替所有设备) * @param device 设备类型 (填null代表顶替所有设备类型)
*/ */
public static void replaced(Object loginId, String device) { public static void replaced(Object loginId, String device) {
stpLogic.replaced(loginId, device); stpLogic.replaced(loginId, device);
@@ -309,7 +309,16 @@ public class StpUserUtil {
public static Object getLoginIdByToken(String tokenValue) { public static Object getLoginIdByToken(String tokenValue) {
return stpLogic.getLoginIdByToken(tokenValue); return stpLogic.getLoginIdByToken(tokenValue);
} }
/**
* 获取Token扩展信息（只在jwt模式下有效）
* @param key 键值
* @return 对应的扩展数据
*/
public static Object getExtra(String key) {
return stpLogic.getExtra(key);
}
// =================== User-Session 相关 =================== // =================== User-Session 相关 ===================
@@ -390,7 +399,7 @@ public class StpUserUtil {
/** /**
* 续签当前token：(将 [最后操作时间] 更新为当前时间戳) * 续签当前token：(将 [最后操作时间] 更新为当前时间戳)
* <h1>请注意: 即时token已经 [临时过期] 也可续签成功， * <h1>请注意: 即使token已经 [临时过期] 也可续签成功，
* 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可 </h1> * 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可 </h1>
*/ */
public static void updateLastActivityToNow() { public static void updateLastActivityToNow() {
@@ -431,8 +440,23 @@ public class StpUserUtil {
public static long getTokenActivityTimeout() { public static long getTokenActivityTimeout() {
return stpLogic.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);
}
// =================== 角色验证操作 =================== // =================== 角色验证操作 ===================
@@ -610,11 +634,11 @@ public class StpUserUtil {
} }
/** /**
* 获取指定账号id指定设备端的tokenValue * 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token， * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @return token值 * @return token值
*/ */
public static String getTokenValueByLoginId(Object loginId, String device) { public static String getTokenValueByLoginId(Object loginId, String device) {
@@ -631,9 +655,9 @@ public class StpUserUtil {
} }
/** /**
* 获取指定账号id指定设备端的tokenValue 集合 * 获取指定账号id指定设备类型端的tokenValue 集合
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @return 此loginId的所有相关token * @return 此loginId的所有相关token
*/ */
public static List<String> getTokenValueListByLoginId(Object loginId, String device) { public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
@@ -641,8 +665,8 @@ public class StpUserUtil {
} }
/** /**
* 返回当前会话的登录设备 * 返回当前会话的登录设备类型
* @return 当前令牌的登录设备 * @return 当前令牌的登录设备类型
*/ */
public static String getLoginDevice() { public static String getLoginDevice() {
return stpLogic.getLoginDevice(); return stpLogic.getLoginDevice();
@@ -827,9 +851,9 @@ public class StpUserUtil {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* *
* 在当前会话上登录id, 并指定登录设备 * 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String） * @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识 * @param device 设备类型
*/ */
@Deprecated @Deprecated
public static void setLoginId(Object loginId, String device) { public static void setLoginId(Object loginId, String device) {
@@ -839,7 +863,7 @@ public class StpUserUtil {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* *
* 在当前会话上登录id, 并指定登录设备 * 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String） * @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie * @param isLastingCookie 是否为持久Cookie
*/ */
@@ -875,10 +899,10 @@ public class StpUserUtil {
/** /**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1> * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1>
* *
* 会话注销，根据账号id and 设备标识 （踢人下线） * 会话注销，根据账号id and 设备类型 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p> * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备) * @param device 设备类型 (填null代表注销所有设备类型)
*/ */
@Deprecated @Deprecated
public static void logoutByLoginId(Object loginId, String device) { public static void logoutByLoginId(Object loginId, String device) {

4
sa-token-doc/doc/README.md
View File

@@ -74,8 +74,8 @@ StpUtil.hasPermission("user:add"); // 查询当前账号是否含有指定权
StpUtil.getSession(); // 获取当前账号id的Session StpUtil.getSession(); // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001); // 获取账号id为10001的Session StpUtil.getSessionByLoginId(10001); // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值 StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC"); // 指定设备标识登录，常用于“同端互斥登录” StpUtil.login(10001, "PC"); // 指定设备类型登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC"); // 指定账号指定设备标识踢下线 (不同端不受影响) StpUtil.kickout(10001, "PC"); // 指定账号指定设备类型踢下线 (不同端不受影响)
StpUtil.openSafe(120); // 在当前会话开启二级认证，有效期为120秒 StpUtil.openSafe(120); // 在当前会话开启二级认证，有效期为120秒
StpUtil.checkSafe(); // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常 StpUtil.checkSafe(); // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常
StpUtil.switchTo(10044); // 将当前会话身份临时切换为其它账号 StpUtil.switchTo(10044); // 将当前会话身份临时切换为其它账号

2
sa-token-doc/doc/fun/token-info.md
View File

@@ -16,7 +16,7 @@ token信息Model: 用来描述一个token的常用参数
"sessionTimeout": 2591977, // User-Session剩余有效时间 (单位: 秒) "sessionTimeout": 2591977, // User-Session剩余有效时间 (单位: 秒)
"tokenSessionTimeout": -2, // Token-Session剩余有效时间 (单位: 秒) "tokenSessionTimeout": -2, // Token-Session剩余有效时间 (单位: 秒)
"tokenActivityTimeout": -1, // token剩余无操作有效时间 (单位: 秒) "tokenActivityTimeout": -1, // token剩余无操作有效时间 (单位: 秒)
"loginDevice": "default-device" // 登录设备标识 "loginDevice": "default-device" // 登录设备类型
}, },
} }
``` ```

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

@@ -33,7 +33,7 @@ Sa-Token 无意发明任何晦涩概念提升逼格，但在处理 issues 、Q
#### 账号标识： #### 账号标识：
- loginId：账号id，用来区分不同账号，通过 `StpUtil.login(id)` 来指定。 - loginId：账号id，用来区分不同账号，通过 `StpUtil.login(id)` 来指定。
- device：登录设备端，例如：`PC`、`APP`，通过 `StpUtil.login(id, device)` 来指定。 - device：登录设备类型，例如：`PC`、`APP`，通过 `StpUtil.login(id, device)` 来指定。
- loginType：账号类型，用来区分不同体系的账号，如同一系统的 `User账号` 和 `Admin账号`，详见：[多账号认证](/up/many-account) - loginType：账号类型，用来区分不同体系的账号，如同一系统的 `User账号` 和 `Admin账号`，详见：[多账号认证](/up/many-account)

2
sa-token-doc/doc/more/update-log.md
View File

@@ -49,7 +49,7 @@
- 新增：角色认证增加API：`StpUtil.hasRoleAnd`、`StpUtil.hasRoleOr` - 新增：角色认证增加API：`StpUtil.hasRoleAnd`、`StpUtil.hasRoleOr`
- 新增：新增 `StpUtil.getRoleList()` 和 `StpUtil.getPermissionList()` 方法 - 新增：新增 `StpUtil.getRoleList()` 和 `StpUtil.getPermissionList()` 方法
- 新增：新增 StpLogic 自动注入特性，可快速方便的扩展 StpLogic 对象 - 新增：新增 StpLogic 自动注入特性，可快速方便的扩展 StpLogic 对象
- 优化：优化同端互斥登录逻辑，如果登录时没有指定设备标识，则默认顶替所有设备下线 - 优化：优化同端互斥登录逻辑，如果登录时没有指定设备类型标识，则默认顶替所有设备类型下线
- 优化：在未登录时调用 hasRole 和 hasPermission 不再抛出异常，而是返回false - 优化：在未登录时调用 hasRole 和 hasPermission 不再抛出异常，而是返回false
- 升级：升级注解鉴权算法，并提供更简单的重写方式 - 升级：升级注解鉴权算法，并提供更简单的重写方式
- 文档：新增常见报错排查，方便快速排查异常报错 - 文档：新增常见报错排查，方便快速排查异常报错

16
sa-token-doc/doc/up/mutex-login.md
View File

@@ -8,35 +8,35 @@
## 具体API ## 具体API
在 Sa-Token 中如何做到同端互斥登录? <br/> 在 Sa-Token 中如何做到同端互斥登录? <br/>
首先在配置文件中，将 `isConcurrent` 配置为false，然后调用登录等相关接口时声明设备标识即可： 首先在配置文件中，将 `isConcurrent` 配置为false，然后调用登录等相关接口时声明设备类型即可：
#### 指定设备标识登录 #### 指定设备类型登录
``` java ``` java
// 指定`账号id`和`设备标识`进行登录 // 指定`账号id`和`设备类型`进行登录
StpUtil.login(10001, "PC"); StpUtil.login(10001, "PC");
``` ```
调用此方法登录后，同设备的会被顶下线（不同设备不受影响），再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-4` 调用此方法登录后，同设备的会被顶下线（不同设备不受影响），再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-4`
#### 指定设备标识强制注销 #### 指定设备类型强制注销
``` java ``` java
// 指定`账号id`和`设备标识`进行强制注销 // 指定`账号id`和`设备类型`进行强制注销
StpUtil.logout(10001, "PC"); StpUtil.logout(10001, "PC");
``` ```
如果第二个参数填写null或不填，代表将这个账号id所有在线端强制注销，被踢出者再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-2` 如果第二个参数填写null或不填，代表将这个账号id所有在线端强制注销，被踢出者再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-2`
#### 查询当前登录的设备标识 #### 查询当前登录的设备类型
``` java ``` java
// 返回当前token的登录设备 // 返回当前token的登录设备类型
StpUtil.getLoginDevice(); StpUtil.getLoginDevice();
``` ```
#### Id 反查 Token #### Id 反查 Token
``` java ``` java
// 获取指定loginId指定设备端的tokenValue // 获取指定loginId指定设备类型端的tokenValue
StpUtil.getTokenValueByLoginId(10001, "APP"); StpUtil.getTokenValueByLoginId(10001, "APP");
``` ```

2
sa-token-doc/doc/up/remember-me.md
View File

@@ -69,7 +69,7 @@ StpUtil.login(10001, new SaLoginModel().setTimeout(60 * 60 * 24 * 7));
// ----------------------- 示例2：所有参数 // ----------------------- 示例2：所有参数
// `SaLoginModel`为登录参数Model，其有诸多参数决定登录时的各种逻辑，例如： // `SaLoginModel`为登录参数Model，其有诸多参数决定登录时的各种逻辑，例如：
StpUtil.login(10001, new SaLoginModel() StpUtil.login(10001, new SaLoginModel()
.setDevice("PC") // 此次登录的客户端设备标识, 用于[同端互斥登录]时指定此次登录的设备名称 .setDevice("PC") // 此次登录的客户端设备类型, 用于[同端互斥登录]时指定此次登录的设备类型
.setIsLastingCookie(true) // 是否为持久Cookie（临时Cookie在浏览器关闭时会自动删除，持久Cookie在重新打开后依然存在） .setIsLastingCookie(true) // 是否为持久Cookie（临时Cookie在浏览器关闭时会自动删除，持久Cookie在重新打开后依然存在）
.setTimeout(60 * 60 * 24 * 7) // 指定此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值） .setTimeout(60 * 60 * 24 * 7) // 指定此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
.setToken("xxxx-xxxx-xxxx-xxxx") // 预定此次登录的生成的Token .setToken("xxxx-xxxx-xxxx-xxxx") // 预定此次登录的生成的Token

6
sa-token-plugin/sa-token-jwt/src/main/java/cn/dev33/satoken/jwt/SaJwtUtil.java
View File

@@ -28,7 +28,7 @@ public class SaJwtUtil {
public static final String LOGIN_ID = "loginId"; public static final String LOGIN_ID = "loginId";
/** /**
* key：登录设备 * key：登录设备类型
*/ */
public static final String DEVICE = "device"; public static final String DEVICE = "device";
@@ -73,7 +73,7 @@ public class SaJwtUtil {
* 创建 jwt （全参数方式） * 创建 jwt （全参数方式）
* @param loginType 账号类型 * @param loginType 账号类型
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @param timeout token有效期 (单位 秒) * @param timeout token有效期 (单位 秒)
* @param extraData 扩展数据 * @param extraData 扩展数据
* @param keyt 秘钥 * @param keyt 秘钥
@@ -265,7 +265,7 @@ public class SaJwtUtil {
* 创建 jwt （全参数方式） * 创建 jwt （全参数方式）
* @param loginType 账号类型 * @param loginType 账号类型
* @param loginId 账号id * @param loginId 账号id
* @param device 设备标识 * @param device 设备类型
* @param timeout token有效期 (单位 秒) * @param timeout token有效期 (单位 秒)
* @param keyt 秘钥 * @param keyt 秘钥
* @return jwt-token * @return jwt-token

6
sa-token-plugin/sa-token-jwt/src/main/java/cn/dev33/satoken/jwt/StpLogicJwtForMix.java
View File

@@ -113,7 +113,7 @@ public class StpLogicJwtForMix extends StpLogic {
} }
/** /**
* [禁用] 会话注销，根据账号id 和 设备标识 * [禁用] 会话注销，根据账号id 和 设备类型
*/ */
@Override @Override
public void logout(Object loginId, String device) { public void logout(Object loginId, String device) {
@@ -129,7 +129,7 @@ public class StpLogicJwtForMix extends StpLogic {
} }
/** /**
* [禁用] 踢人下线，根据账号id 和 设备标识 * [禁用] 踢人下线，根据账号id 和 设备类型
*/ */
@Override @Override
public void kickout(Object loginId, String device) { public void kickout(Object loginId, String device) {
@@ -145,7 +145,7 @@ public class StpLogicJwtForMix extends StpLogic {
} }
/** /**
* [禁用] 顶人下线，根据账号id 和 设备标识 * [禁用] 顶人下线，根据账号id 和 设备类型
*/ */
@Override @Override
public void replaced(Object loginId, String device) { public void replaced(Object loginId, String device) {

4
sa-token-plugin/sa-token-jwt/src/main/java/cn/dev33/satoken/jwt/StpLogicJwtForStateless.java
View File

@@ -158,8 +158,8 @@ public class StpLogicJwtForStateless extends StpLogic {
// ------------------- id 反查 token 相关操作 ------------------- // ------------------- id 反查 token 相关操作 -------------------
/** /**
* 返回当前会话的登录设备 * 返回当前会话的登录设备类型
* @return 当前令牌的登录设备 * @return 当前令牌的登录设备类型
*/ */
@Override @Override
public String getLoginDevice() { public String getLoginDevice() {

2
sa-token-plugin/sa-token-spring-aop/pom.xml
View File

@@ -20,7 +20,7 @@
<!-- sa-token-spring-boot-starter --> <!-- sa-token-spring-boot-starter -->
<dependency> <dependency>
<groupId>cn.dev33</groupId> <groupId>cn.dev33</groupId>
<artifactId>sa-token-spring-boot-starter</artifactId> <artifactId>sa-token-core</artifactId>
<version>${revision}</version> <version>${revision}</version>
</dependency> </dependency>
<!-- spring-boot-starter-aop --> <!-- spring-boot-starter-aop -->

4
sa-token-test/sa-token-jwt-test/src/test/java/com/pj/test/JwtForMixTest.java
View File

@@ -61,13 +61,13 @@ public class JwtForMixTest {
Assert.assertTrue(StpUtil.isLogin()); Assert.assertTrue(StpUtil.isLogin());
Assert.assertNotNull(token); // token不为null Assert.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001 Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备 Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// token 验证 // token 验证
JWT jwt = JWT.of(token); JWT jwt = JWT.of(token);
JSONObject payloads = jwt.getPayloads(); JSONObject payloads = jwt.getPayloads();
Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_ID), "10001"); // 账号 Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_ID), "10001"); // 账号
Assert.assertEquals(payloads.getStr(SaJwtUtil.DEVICE), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备 Assert.assertEquals(payloads.getStr(SaJwtUtil.DEVICE), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_TYPE), StpUtil.TYPE); // 账号类型 Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_TYPE), StpUtil.TYPE); // 账号类型
// db数据 验证 // db数据 验证

4
sa-token-test/sa-token-jwt-test/src/test/java/com/pj/test/JwtForStatelessTest.java
View File

@@ -57,13 +57,13 @@ public class JwtForStatelessTest {
Assert.assertTrue(StpUtil.isLogin()); Assert.assertTrue(StpUtil.isLogin());
Assert.assertNotNull(token); // token不为null Assert.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001 Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备 Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// token 验证 // token 验证
JWT jwt = JWT.of(token); JWT jwt = JWT.of(token);
JSONObject payloads = jwt.getPayloads(); JSONObject payloads = jwt.getPayloads();
Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_ID), "10001"); // 账号 Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_ID), "10001"); // 账号
Assert.assertEquals(payloads.getStr(SaJwtUtil.DEVICE), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备 Assert.assertEquals(payloads.getStr(SaJwtUtil.DEVICE), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_TYPE), StpUtil.TYPE); // 账号类型 Assert.assertEquals(payloads.getStr(SaJwtUtil.LOGIN_TYPE), StpUtil.TYPE); // 账号类型
// 时间 // 时间

2
sa-token-test/sa-token-jwt-test/src/test/java/com/pj/test/JwtForStyleTest.java
View File

@@ -55,7 +55,7 @@ public class JwtForStyleTest {
Assert.assertTrue(StpUtil.isLogin()); Assert.assertTrue(StpUtil.isLogin());
Assert.assertNotNull(token); // token不为null Assert.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001 Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备 Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// token 验证 // token 验证
JWT jwt = JWT.of(token); JWT jwt = JWT.of(token);

2
sa-token-test/sa-token-springboot-test/src/test/java/com/pj/test/BasicsTest.java
View File

@@ -59,7 +59,7 @@ public class BasicsTest {
Assert.assertTrue(StpUtil.isLogin()); Assert.assertTrue(StpUtil.isLogin());
Assert.assertNotNull(token); // token不为null Assert.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001 Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备 Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// db数据 验证 // db数据 验证
// token存在 // token存在