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

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

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
Show Stats 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.getSessionByLoginId(10001); // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC"); // 指定设备标识登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC"); // 指定账号指定设备标识踢下线 (不同端不受影响)
StpUtil.login(10001, "PC"); // 指定设备类型登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC"); // 指定账号指定设备类型踢下线 (不同端不受影响)
StpUtil.openSafe(120); // 在当前会话开启二级认证，有效期为120秒
StpUtil.checkSafe(); // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常
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签名
*
* @param tokenValue token值
* @param device 设备标识
* @param device 设备类型
*/
public void addTokenSign(String tokenValue, String 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 device;
@ -35,7 +35,7 @@ public class TokenSign implements Serializable {
* 构建一个
*
* @param value token值
* @param device 所在设备标识
* @param device 所属设备类型
*/
public TokenSign(String value, String device) {
this.value = value;
@ -50,7 +50,7 @@ public class TokenSign implements Serializable {
}
/**
* @return token登录设备
* @return 所属设备类型
*/
public String getDevice() {
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 {
/**
* @param device 此次登录的客户端设备标识
* @param device 此次登录的客户端设备类型
* @return SaLoginModel配置对象
*/
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 String device;
@ -42,14 +42,14 @@ public class SaLoginModel {
/**
* @return 此次登录的客户端设备标识
* @return 此次登录的客户端设备类型
*/
public String getDevice() {
return device;
}
/**
* @param device 此次登录的客户端设备标识
* @param device 此次登录的客户端设备类型
* @return 对象自身
*/
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剩余无操作有效时间 (单位: 秒) */
public long tokenActivityTimeout;
/** 登录设备标识 */
/** 登录设备类型 */
public String loginDevice;
/** 自定义数据 */
@ -170,14 +170,14 @@ public class SaTokenInfo {
}
/**
* @return 登录设备标识
* @return 登录设备类型
*/
public String getLoginDevice() {
return loginDevice;
}
/**
* @param loginDevice 登录设备标识
* @param loginDevice 登录设备类型
*/
public void setLoginDevice(String 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
* @param loginId loginId
* @param device 设备标识
* @param device 设备类型
* @param timeout 过期时间
* @param extraData 扩展信息
* @return 生成的tokenValue
@ -251,9 +251,9 @@ public class StpLogic {
}
/**
* 会话登录，并指定登录设备
* 会话登录，并指定登录设备类型
* @param id 账号id，建议的类型：（long | int | String）
* @param device 设备标识
* @param device 设备类型
*/
public void login(Object id, String device) {
login(id, new SaLoginModel().setDevice(device));
@ -385,10 +385,10 @@ public class StpLogic {
}
/**
* 会话注销，根据账号id 和 设备标识
* 会话注销，根据账号id 和 设备类型
*
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
* @param device 设备类型 (填null代表注销所有设备类型)
*/
public void logout(Object loginId, String device) {
clearTokenCommonMethod(loginId, device, tokenValue -> {
@ -444,11 +444,11 @@ public class StpLogic {
}
/**
* 踢人下线，根据账号id 和 设备标识
* 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
* @param device 设备标识 (填null代表踢出所有设备)
* @param device 设备类型 (填null代表踢出所有设备类型)
*/
public void kickout(Object loginId, String device) {
clearTokenCommonMethod(loginId, device, tokenValue -> {
@ -491,11 +491,11 @@ public class StpLogic {
}
/**
* 顶人下线，根据账号id 和 设备标识
* 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
*
* @param loginId 账号id
* @param device 设备标识 (填null代表顶替所有设备)
* @param device 设备类型 (填null代表顶替所有设备类型)
*/
public void replaced(Object loginId, String device) {
clearTokenCommonMethod(loginId, device, tokenValue -> {
@ -508,7 +508,7 @@ public class StpLogic {
/**
* 封装 注销、踢人、顶人 三个动作的相同代码（无API含义方法）
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @param appendFun 追加操作
* @param isLogoutSession 是否注销 User-Session
*/
@ -1347,11 +1347,11 @@ public class StpLogic {
}
/**
* 获取指定账号id指定设备端的tokenValue
* 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
* @param device 设备标识，填null代表不限设备
* @param device 设备类型，填null代表不限设备类型
* @return token值
*/
public String getTokenValueByLoginId(Object loginId, String device) {
@ -1369,9 +1369,9 @@ public class StpLogic {
}
/**
* 获取指定账号id指定设备端的tokenValue 集合
* 获取指定账号id指定设备类型端的tokenValue 集合
* @param loginId 账号id
* @param device 设备标识，填null代表不限设备
* @param device 设备类型，填null代表不限设备类型
* @return 此loginId的所有相关token
*/
public List<String> getTokenValueListByLoginId(Object loginId, String device) {
@ -1392,8 +1392,8 @@ public class StpLogic {
}
/**
* 返回当前会话的登录设备
* @return 当前令牌的登录设备
* 返回当前会话的登录设备类型
* @return 当前令牌的登录设备类型
*/
public String getLoginDevice() {
// 如果没有token，直接返回 null
@ -1799,10 +1799,10 @@ public class StpLogic {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout(id) ，使用方式保持不变 </h1>
*
* 会话注销，根据账号id and 设备标识 （踢人下线）
* 会话注销，根据账号id and 设备类型 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
* @param device 设备类型 (填null代表注销所有设备类型)
*/
@Deprecated
public void logoutByLoginId(Object loginId, String device) {
@ -1812,7 +1812,7 @@ public class StpLogic {
/**
* 创建一个TokenValue
* @param loginId loginId
* @param device 设备标识
* @param device 设备类型
* @param timeout 过期时间
* @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 device 设备标识
* @param device 设备类型
*/
public static void login(Object id, String device) {
stpLogic.login(id, device);
@ -169,10 +169,10 @@ public class StpUtil {
}
/**
* 会话注销，根据账号id 和 设备标识
* 会话注销，根据账号id 和 设备类型
*
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
* @param device 设备类型 (填null代表注销所有设备类型)
*/
public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device);
@ -198,11 +198,11 @@ public class StpUtil {
}
/**
* 踢人下线，根据账号id 和 设备标识
* 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
* @param device 设备标识 (填null代表踢出所有设备)
* @param device 设备类型 (填null代表踢出所有设备类型)
*/
public static void kickout(Object loginId, String device) {
stpLogic.kickout(loginId, device);
@ -219,11 +219,11 @@ public class StpUtil {
}
/**
* 顶人下线，根据账号id 和 设备标识
* 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
*
* @param loginId 账号id
* @param device 设备标识 (填null代表顶替所有设备)
* @param device 设备类型 (填null代表顶替所有设备类型)
*/
public static void replaced(Object loginId, String device) {
stpLogic.replaced(loginId, device);
@ -630,11 +630,11 @@ public class StpUtil {
}
/**
* 获取指定账号id指定设备端的tokenValue
* 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @return token值
*/
public static String getTokenValueByLoginId(Object loginId, String device) {
@ -651,9 +651,9 @@ public class StpUtil {
}
/**
* 获取指定账号id指定设备端的tokenValue 集合
* 获取指定账号id指定设备类型端的tokenValue 集合
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @return 此loginId的所有相关token
*/
public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
@ -661,8 +661,8 @@ public class StpUtil {
}
/**
* 返回当前会话的登录设备
* @return 当前令牌的登录设备
* 返回当前会话的登录设备类型
* @return 当前令牌的登录设备类型
*/
public static String getLoginDevice() {
return stpLogic.getLoginDevice();
@ -847,9 +847,9 @@ public class StpUtil {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
*
* 在当前会话上登录id, 并指定登录设备
* 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识
* @param device 设备类型
*/
@Deprecated
public static void setLoginId(Object loginId, String device) {
@ -859,7 +859,7 @@ public class StpUtil {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
*
* 在当前会话上登录id, 并指定登录设备
* 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
@ -895,10 +895,10 @@ public class StpUtil {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1>
*
* 会话注销，根据账号id and 设备标识 （踢人下线）
* 会话注销，根据账号id and 设备类型 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
* @param device 设备类型 (填null代表注销所有设备类型)
*/
@Deprecated
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_";
/**
* 常量key标记: 在登录时，默认使用的设备名称
* 常量key标记: 在登录时，默认使用的设备类型
*/
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();
}
// 测试登录接口, 按照设备登录， 浏览器访问： http://localhost:8081/test/login2
// 测试登录接口, 按照设备类型登录， 浏览器访问： http://localhost:8081/test/login2
@Mapping("login2")
public AjaxJson login2(@Param(defaultValue="10001") String id, @Param(defaultValue="PC") String device) {
StpUtil.login(id, device);
@ -226,7 +226,7 @@ public class TestController {
return AjaxJson.getSuccess();
}
// 测试指定设备登录 浏览器访问： http://localhost:8081/test/loginByDevice
// 测试指定设备类型登录 浏览器访问： http://localhost:8081/test/loginByDevice
@Mapping("loginByDevice")
public AjaxJson loginByDevice() {
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;
/**
* Sa-Token 权限认证工具类 (User版)
* Sa-Token 权限认证工具类 (user版)
* @author kong
*/
public class StpUserUtil {
@ -110,9 +110,9 @@ public class StpUserUtil {
}
/**
* 会话登录，并指定登录设备
* 会话登录，并指定登录设备类型
* @param id 账号id，建议的类型：（long | int | String）
* @param device 设备标识
* @param device 设备类型
*/
public static void login(Object id, String device) {
stpLogic.login(id, device);
@ -173,10 +173,10 @@ public class StpUserUtil {
}
/**
* 会话注销，根据账号id 和 设备标识
* 会话注销，根据账号id 和 设备类型
*
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
* @param device 设备类型 (填null代表注销所有设备类型)
*/
public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device);
@ -202,11 +202,11 @@ public class StpUserUtil {
}
/**
* 踢人下线，根据账号id 和 设备标识
* 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
* @param device 设备标识 (填null代表踢出所有设备)
* @param device 设备类型 (填null代表踢出所有设备类型)
*/
public static void kickout(Object loginId, String device) {
stpLogic.kickout(loginId, device);
@ -223,11 +223,11 @@ public class StpUserUtil {
}
/**
* 顶人下线，根据账号id 和 设备标识
* 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
*
* @param loginId 账号id
* @param device 设备标识 (填null代表顶替所有设备)
* @param device 设备类型 (填null代表顶替所有设备类型)
*/
public static void replaced(Object loginId, String device) {
stpLogic.replaced(loginId, device);
@ -309,7 +309,16 @@ public class StpUserUtil {
public static Object getLoginIdByToken(String tokenValue) {
return stpLogic.getLoginIdByToken(tokenValue);
}
/**
* 获取Token扩展信息（只在jwt模式下有效）
* @param key 键值
* @return 对应的扩展数据
*/
public static Object getExtra(String key) {
return stpLogic.getExtra(key);
}
// =================== User-Session 相关 ===================
@ -390,7 +399,7 @@ public class StpUserUtil {
/**
* 续签当前token：(将 [最后操作时间] 更新为当前时间戳)
* <h1>请注意: 即时token已经 [临时过期] 也可续签成功，
* <h1>请注意: 即使token已经 [临时过期] 也可续签成功，
* 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可 </h1>
*/
public static void updateLastActivityToNow() {
@ -431,8 +440,23 @@ public class StpUserUtil {
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);
}
// =================== 角色验证操作 ===================
@ -610,11 +634,11 @@ public class StpUserUtil {
}
/**
* 获取指定账号id指定设备端的tokenValue
* 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @return token值
*/
public static String getTokenValueByLoginId(Object loginId, String device) {
@ -631,9 +655,9 @@ public class StpUserUtil {
}
/**
* 获取指定账号id指定设备端的tokenValue 集合
* 获取指定账号id指定设备类型端的tokenValue 集合
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @return 此loginId的所有相关token
*/
public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
@ -641,8 +665,8 @@ public class StpUserUtil {
}
/**
* 返回当前会话的登录设备
* @return 当前令牌的登录设备
* 返回当前会话的登录设备类型
* @return 当前令牌的登录设备类型
*/
public static String getLoginDevice() {
return stpLogic.getLoginDevice();
@ -827,9 +851,9 @@ public class StpUserUtil {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
*
* 在当前会话上登录id, 并指定登录设备
* 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识
* @param device 设备类型
*/
@Deprecated
public static void setLoginId(Object loginId, String device) {
@ -839,7 +863,7 @@ public class StpUserUtil {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
*
* 在当前会话上登录id, 并指定登录设备
* 在当前会话上登录id, 并指定登录设备类型
* @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
@ -875,10 +899,10 @@ public class StpUserUtil {
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1>
*
* 会话注销，根据账号id and 设备标识 （踢人下线）
* 会话注销，根据账号id and 设备类型 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
* @param device 设备类型 (填null代表注销所有设备类型)
*/
@Deprecated
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.getSessionByLoginId(10001); // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC"); // 指定设备标识登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC"); // 指定账号指定设备标识踢下线 (不同端不受影响)
StpUtil.login(10001, "PC"); // 指定设备类型登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC"); // 指定账号指定设备类型踢下线 (不同端不受影响)
StpUtil.openSafe(120); // 在当前会话开启二级认证，有效期为120秒
StpUtil.checkSafe(); // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常
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剩余有效时间 (单位: 秒)
"tokenSessionTimeout": -2, // Token-Session剩余有效时间 (单位: 秒)
"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)` 来指定。
- device：登录设备端，例如：`PC`、`APP`，通过 `StpUtil.login(id, device)` 来指定。
- device：登录设备类型，例如：`PC`、`APP`，通过 `StpUtil.login(id, device)` 来指定。
- 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`
- 新增：新增 `StpUtil.getRoleList()` 和 `StpUtil.getPermissionList()` 方法
- 新增：新增 StpLogic 自动注入特性，可快速方便的扩展 StpLogic 对象
- 优化：优化同端互斥登录逻辑，如果登录时没有指定设备标识，则默认顶替所有设备下线
- 优化：优化同端互斥登录逻辑，如果登录时没有指定设备类型标识，则默认顶替所有设备类型下线
- 优化：在未登录时调用 hasRole 和 hasPermission 不再抛出异常，而是返回false
- 升级：升级注解鉴权算法，并提供更简单的重写方式
- 文档：新增常见报错排查，方便快速排查异常报错

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

@ -8,35 +8,35 @@
## 具体API
在 Sa-Token 中如何做到同端互斥登录? <br/>
首先在配置文件中，将 `isConcurrent` 配置为false，然后调用登录等相关接口时声明设备标识即可：
首先在配置文件中，将 `isConcurrent` 配置为false，然后调用登录等相关接口时声明设备类型即可：
#### 指定设备标识登录
#### 指定设备类型登录
``` java
// 指定`账号id`和`设备标识`进行登录
// 指定`账号id`和`设备类型`进行登录
StpUtil.login(10001, "PC");
```
调用此方法登录后，同设备的会被顶下线（不同设备不受影响），再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-4`
#### 指定设备标识强制注销
#### 指定设备类型强制注销
``` java
// 指定`账号id`和`设备标识`进行强制注销
// 指定`账号id`和`设备类型`进行强制注销
StpUtil.logout(10001, "PC");
```
如果第二个参数填写null或不填，代表将这个账号id所有在线端强制注销，被踢出者再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-2`
#### 查询当前登录的设备标识
#### 查询当前登录的设备类型
``` java
// 返回当前token的登录设备
// 返回当前token的登录设备类型
StpUtil.getLoginDevice();
```
#### Id 反查 Token
``` java
// 获取指定loginId指定设备端的tokenValue
// 获取指定loginId指定设备类型端的tokenValue
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：所有参数
// `SaLoginModel`为登录参数Model，其有诸多参数决定登录时的各种逻辑，例如：
StpUtil.login(10001, new SaLoginModel()
.setDevice("PC") // 此次登录的客户端设备标识, 用于[同端互斥登录]时指定此次登录的设备名称
.setDevice("PC") // 此次登录的客户端设备类型, 用于[同端互斥登录]时指定此次登录的设备类型
.setIsLastingCookie(true) // 是否为持久Cookie（临时Cookie在浏览器关闭时会自动删除，持久Cookie在重新打开后依然存在）
.setTimeout(60 * 60 * 24 * 7) // 指定此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
.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";
/**
* key：登录设备
* key：登录设备类型
*/
public static final String DEVICE = "device";
@ -73,7 +73,7 @@ public class SaJwtUtil {
* 创建 jwt （全参数方式）
* @param loginType 账号类型
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @param timeout token有效期 (单位 秒)
* @param extraData 扩展数据
* @param keyt 秘钥
@ -265,7 +265,7 @@ public class SaJwtUtil {
* 创建 jwt （全参数方式）
* @param loginType 账号类型
* @param loginId 账号id
* @param device 设备标识
* @param device 设备类型
* @param timeout token有效期 (单位 秒)
* @param keyt 秘钥
* @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
public void logout(Object loginId, String device) {
@ -129,7 +129,7 @@ public class StpLogicJwtForMix extends StpLogic {
}
/**
* [禁用] 踢人下线，根据账号id 和 设备标识
* [禁用] 踢人下线，根据账号id 和 设备类型
*/
@Override
public void kickout(Object loginId, String device) {
@ -145,7 +145,7 @@ public class StpLogicJwtForMix extends StpLogic {
}
/**
* [禁用] 顶人下线，根据账号id 和 设备标识
* [禁用] 顶人下线，根据账号id 和 设备类型
*/
@Override
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 相关操作 -------------------
/**
* 返回当前会话的登录设备
* @return 当前令牌的登录设备
* 返回当前会话的登录设备类型
* @return 当前令牌的登录设备类型
*/
@Override
public String getLoginDevice() {

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

@ -20,7 +20,7 @@
<!-- sa-token-spring-boot-starter -->
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-spring-boot-starter</artifactId>
<artifactId>sa-token-core</artifactId>
<version>${revision}</version>
</dependency>
<!-- 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.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// token 验证
JWT jwt = JWT.of(token);
JSONObject payloads = jwt.getPayloads();
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); // 账号类型
// 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.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// token 验证
JWT jwt = JWT.of(token);
JSONObject payloads = jwt.getPayloads();
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); // 账号类型
// 时间

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.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// 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.assertNotNull(token); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备
Assert.assertEquals(StpUtil.getLoginDevice(), SaTokenConsts.DEFAULT_LOGIN_DEVICE); // 登录设备类型
// db数据 验证
// token存在