lsm/sa-token
1
0
Fork 0
mirror of https://gitee.com/dromara/sa-token.git synced 2025-04-05 17:37:53 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

重构API

Browse Source
This commit is contained in:
click33 2021-06-16 16:24:39 +08:00
parent 316bb063d9
commit f6f4d337c9
55 changed files with 319 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -80,7 +80,7 @@ Sa-Token的API调用非常简单，有多简单呢？以登录验证为例，你
``` java
// 在登录时写入当前会话的账号id
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// 然后在任意需要校验登录处调用以下API
// 如果当前会话未登录，这句代码会抛出 `NotLoginException`异常
@ -112,7 +112,7 @@ StpUtil.logoutByLoginId(10001);
除了以上的示例，Sa-Token还可以一行代码完成以下功能：
``` java
StpUtil.setLoginId(10001); // 标记当前会话登录的账号id
StpUtil.login(10001); // 标记当前会话登录的账号id
StpUtil.getLoginId(); // 获取当前会话登录的账号id
StpUtil.isLogin(); // 获取当前会话是否已经登录, 返回true或false
StpUtil.logout(); // 当前会话注销登录
@ -122,7 +122,7 @@ StpUtil.hasPermission("user:add"); // 查询当前账号是否含有指
StpUtil.getSession(); // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001); // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值
StpUtil.setLoginId(10001, "PC"); // 指定设备标识登录
StpUtil.login(10001, "PC"); // 指定设备标识登录
StpUtil.logoutByLoginId(10001, "PC"); // 指定设备标识进行强制注销 (不同端不受影响)
StpUtil.switchTo(10044); // 将当前会话身份临时切换为其它账号
```

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

@ -39,7 +39,7 @@ public class SaManager {
SaFoxUtil.printSaToken();
}
// 调用一次StpUtil中的方法，保证其可以尽早的初始化 StpLogic
StpUtil.getLoginKey();
StpUtil.getLoginType();
}
public static SaTokenConfig getConfig() {
if (config == null) {
@ -173,31 +173,31 @@ public class SaManager {
* @param stpLogic StpLogic
*/
public static void putStpLogic(StpLogic stpLogic) {
stpLogicMap.put(stpLogic.getLoginKey(), stpLogic);
stpLogicMap.put(stpLogic.getLoginType(), stpLogic);
}
/**
* 根据 LoginKey 获取对应的StpLogic，如果不存在则抛出异常
* @param loginKey 对应的LoginKey
* 根据 LoginType 获取对应的StpLogic，如果不存在则抛出异常
* @param loginType 对应的账号类型
* @return 对应的StpLogic
*/
public static StpLogic getStpLogic(String loginKey) {
// 如果key为空则返回框架内置的
if(loginKey == null || loginKey.isEmpty()) {
public static StpLogic getStpLogic(String loginType) {
// 如果type为空则返回框架内置的
if(loginType == null || loginType.isEmpty()) {
return StpUtil.stpLogic;
}
// 从SaManager中获取
StpLogic stpLogic = stpLogicMap.get(loginKey);
StpLogic stpLogic = stpLogicMap.get(loginType);
if(stpLogic == null) {
/*
* 此时有两种情况会造成 StpLogic == null
* 1. LoginKey拼写错误，请改正 （建议使用常量）
* 1. loginType拼写错误，请改正 （建议使用常量）
* 2. 自定义StpUtil尚未初始化（静态类中的属性至少一次调用后才会初始化），解决方法两种
* (1) 从main方法里调用一次
* (2) 在自定义StpUtil类加上类似 @Component 的注解让容器启动时扫描到自动初始化
*/
throw new SaTokenException("未能获取对应StpLogic，key="+ loginKey);
throw new SaTokenException("未能获取对应StpLogic，type="+ loginType);
}
// 返回

4
sa-token-core/src/main/java/cn/dev33/satoken/action/SaTokenAction.java
View File

@ -16,10 +16,10 @@ public interface SaTokenAction {
/**
* 根据一定的算法生成一个token
* @param loginId 账号id
* @param loginKey 账号体系key
* @param loginType 账号类型
* @return 一个token
*/
public String createToken(Object loginId, String loginKey);
public String createToken(Object loginId, String loginType);
/**
* 根据 SessionId 创建一个 Session

8
sa-token-core/src/main/java/cn/dev33/satoken/action/SaTokenActionDefaultImpl.java
View File

@ -24,7 +24,7 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
* 根据一定的算法生成一个token
*/
@Override
public String createToken(Object loginId, String loginKey) {
public String createToken(Object loginId, String loginType) {
// 根据配置的tokenStyle生成不同风格的token
String tokenStyle = SaManager.getConfig().getTokenStyle();
// uuid
@ -111,19 +111,19 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
// 校验 @SaCheckLogin 注解
if(target.isAnnotationPresent(SaCheckLogin.class)) {
SaCheckLogin at = target.getAnnotation(SaCheckLogin.class);
SaManager.getStpLogic(at.key()).checkByAnnotation(at);
SaManager.getStpLogic(at.type()).checkByAnnotation(at);
}
// 校验 @SaCheckRole 注解
if(target.isAnnotationPresent(SaCheckRole.class)) {
SaCheckRole at = target.getAnnotation(SaCheckRole.class);
SaManager.getStpLogic(at.key()).checkByAnnotation(at);
SaManager.getStpLogic(at.type()).checkByAnnotation(at);
}
// 校验 @SaCheckPermission 注解
if(target.isAnnotationPresent(SaCheckPermission.class)) {
SaCheckPermission at = target.getAnnotation(SaCheckPermission.class);
SaManager.getStpLogic(at.key()).checkByAnnotation(at);
SaManager.getStpLogic(at.type()).checkByAnnotation(at);
}
}

2
sa-token-core/src/main/java/cn/dev33/satoken/annotation/SaCheckLogin.java
View File

@ -19,6 +19,6 @@ public @interface SaCheckLogin {
* 多账号体系下所属的账号体系标识
* @return see note
*/
String key() default "";
String type() default "";
}

2
sa-token-core/src/main/java/cn/dev33/satoken/annotation/SaCheckPermission.java
View File

@ -31,6 +31,6 @@ public @interface SaCheckPermission {
* 多账号体系下所属的账号体系标识
* @return see note
*/
String key() default "";
String type() default "";
}

5
sa-token-core/src/main/java/cn/dev33/satoken/annotation/SaCheckRole.java
View File

@ -28,9 +28,10 @@ public @interface SaCheckRole {
SaMode mode() default SaMode.AND;
/**
* 多账号体系下所属的账号体系标识
* 账号类型
* <p> 建议使用常量，避免因错误拼写带来的bug
* @return see note
*/
String key() default "";
String type() default "";
}

4
sa-token-core/src/main/java/cn/dev33/satoken/annotation/SaMode.java
View File

@ -8,12 +8,12 @@ package cn.dev33.satoken.annotation;
public enum SaMode {
/**
* 必须具有所有的选项
* 必须具有所有的元素
*/
AND,
/**
* 只需具有其中一个选项
* 只需具有其中一个元素
*/
OR

18
sa-token-core/src/main/java/cn/dev33/satoken/exception/DisableLoginException.java
View File

@ -19,9 +19,9 @@ public class DisableLoginException extends SaTokenException {
public static final String BE_MESSAGE = "此账号已被封禁";
/**
* LoginKey
* 账号类型
*/
private String loginKey;
private String loginType;
/**
* 被封禁的账号id
@ -34,12 +34,12 @@ public class DisableLoginException extends SaTokenException {
private long disableTime;
/**
* 获得LoginKey
* 获取账号类型
*
* @return See above
* @return See Note
*/
public String getLoginKey() {
return loginKey;
public String getLoginType() {
return loginType;
}
/**
@ -62,14 +62,14 @@ public class DisableLoginException extends SaTokenException {
/**
* 构造方法创建一个
*
* @param loginKey loginKey
* @param loginType 账号类型
* @param loginId 被封禁的账号id
* @param disableTime 封禁剩余时间，单位：秒
*/
public DisableLoginException(String loginKey, Object loginId, long disableTime) {
public DisableLoginException(String loginType, Object loginId, long disableTime) {
super(BE_MESSAGE);
this.loginId = loginId;
this.loginKey = loginKey;
this.loginType = loginType;
this.disableTime = disableTime;
}

26
sa-token-core/src/main/java/cn/dev33/satoken/exception/NotLoginException.java
View File

@ -67,38 +67,38 @@ public class NotLoginException extends SaTokenException {
/**
* loginKey
* 账号类型
*/
private String loginKey;
private String loginType;
/**
* 获得loginKey
* @return loginKey
* 获得账号类型
* @return 账号类型
*/
public String getLoginKey() {
return loginKey;
public String getLoginType() {
return loginType;
}
/**
* 构造方法创建一个
* @param message 异常消息
* @param loginKey loginKey
* @param loginType 账号类型
* @param type 类型
*/
public NotLoginException(String message, String loginKey, String type) {
public NotLoginException(String message, String loginType, String type) {
super(message);
this.loginKey = loginKey;
this.loginType = loginType;
this.type = type;
}
/**
* 静态方法构建一个NotLoginException
* @param loginKey loginKey
* @param type 场景类型
* @param loginType 账号类型
* @param type 账号类型
* @return 构建完毕的异常对象
*/
public static NotLoginException newInstance(String loginKey, String type) {
public static NotLoginException newInstance(String loginType, String type) {
String message = null;
if(NOT_TOKEN.equals(type)) {
message = NOT_TOKEN_MESSAGE;
@ -118,7 +118,7 @@ public class NotLoginException extends SaTokenException {
else {
message = DEFAULT_MESSAGE;
}
return new NotLoginException(message, loginKey, type);
return new NotLoginException(message, loginType, type);
}
}

18
sa-token-core/src/main/java/cn/dev33/satoken/exception/NotPermissionException.java
View File

@ -26,27 +26,27 @@ public class NotPermissionException extends SaTokenException {
}
/**
* loginKey
* 账号类型
*/
private String loginKey;
private String loginType;
/**
* 获得loginKey
* 获得账号类型
*
* @return loginKey
* @return 账号类型
*/
public String getLoginKey() {
return loginKey;
public String getLoginType() {
return loginType;
}
public NotPermissionException(String code) {
this(code, StpUtil.stpLogic.loginKey);
this(code, StpUtil.stpLogic.loginType);
}
public NotPermissionException(String code, String loginKey) {
public NotPermissionException(String code, String loginType) {
super("无此权限：" + code);
this.code = code;
this.loginKey = loginKey;
this.loginType = loginType;
}
}

18
sa-token-core/src/main/java/cn/dev33/satoken/exception/NotRoleException.java
View File

@ -26,27 +26,27 @@ public class NotRoleException extends SaTokenException {
}
/**
* loginKey
* 账号类型
*/
private String loginKey;
private String loginType;
/**
* 获得loginKey
* 获得账号类型
*
* @return loginKey
* @return 账号类型
*/
public String getLoginKey() {
return loginKey;
public String getLoginType() {
return loginType;
}
public NotRoleException(String role) {
this(role, StpUtil.stpLogic.loginKey);
this(role, StpUtil.stpLogic.loginType);
}
public NotRoleException(String role, String loginKey) {
public NotRoleException(String role, String loginType) {
super("无此角色：" + role);
this.role = role;
this.loginKey = loginKey;
this.loginType = loginType;
}
}

24
sa-token-core/src/main/java/cn/dev33/satoken/listener/SaTokenListener.java
View File

@ -12,52 +12,52 @@ public interface SaTokenListener {
/**
* 每次登录时触发
* @param loginKey 账号类别
* @param loginType 账号类别
* @param loginId 账号id
* @param loginModel 登录参数
*/
public void doLogin(String loginKey, Object loginId, SaLoginModel loginModel);
public void doLogin(String loginType, Object loginId, SaLoginModel loginModel);
/**
* 每次注销时触发
* @param loginKey 账号类别
* @param loginType 账号类别
* @param loginId 账号id
* @param tokenValue token值
*/
public void doLogout(String loginKey, Object loginId, String tokenValue);
public void doLogout(String loginType, Object loginId, String tokenValue);
/**
* 每次被踢下线时触发
* @param loginKey 账号类别
* @param loginType 账号类别
* @param loginId 账号id
* @param tokenValue token值
* @param device 设备标识
*/
public void doLogoutByLoginId(String loginKey, Object loginId, String tokenValue, String device);
public void doLogoutByLoginId(String loginType, Object loginId, String tokenValue, String device);
/**
* 每次被顶下线时触发
* @param loginKey 账号类别
* @param loginType 账号类别
* @param loginId 账号id
* @param tokenValue token值
* @param device 设备标识
*/
public void doReplaced(String loginKey, Object loginId, String tokenValue, String device);
public void doReplaced(String loginType, Object loginId, String tokenValue, String device);
/**
* 每次被封禁时触发
* @param loginKey 账号类别
* @param loginType 账号类别
* @param loginId 账号id
* @param disableTime 封禁时长，单位: 秒
*/
public void doDisable(String loginKey, Object loginId, long disableTime);
public void doDisable(String loginType, Object loginId, long disableTime);
/**
* 每次被解封时触发
* @param loginKey 账号类别
* @param loginType 账号类别
* @param loginId 账号id
*/
public void doUntieDisable(String loginKey, Object loginId);
public void doUntieDisable(String loginType, Object loginId);
/**
* 每次创建Session时触发

12
sa-token-core/src/main/java/cn/dev33/satoken/listener/SaTokenListenerDefaultImpl.java
View File

@ -17,7 +17,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
* 每次登录时触发
*/
@Override
public void doLogin(String loginKey, Object loginId, SaLoginModel loginModel) {
public void doLogin(String loginType, Object loginId, SaLoginModel loginModel) {
println("账号[" + loginId + "]登录成功");
}
@ -25,7 +25,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
* 每次注销时触发
*/
@Override
public void doLogout(String loginKey, Object loginId, String tokenValue) {
public void doLogout(String loginType, Object loginId, String tokenValue) {
println("账号[" + loginId + "]注销成功");
}
@ -33,7 +33,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
* 每次被踢下线时触发
*/
@Override
public void doLogoutByLoginId(String loginKey, Object loginId, String tokenValue, String device) {
public void doLogoutByLoginId(String loginType, Object loginId, String tokenValue, String device) {
println("账号[" + loginId + "]被踢下线 (终端: " + device + ")");
}
@ -41,7 +41,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
* 每次被顶下线时触发
*/
@Override
public void doReplaced(String loginKey, Object loginId, String tokenValue, String device) {
public void doReplaced(String loginType, Object loginId, String tokenValue, String device) {
println("账号[" + loginId + "]被顶下线 (终端: " + device + ")");
}
@ -49,7 +49,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
* 每次被封禁时触发
*/
@Override
public void doDisable(String loginKey, Object loginId, long disableTime) {
public void doDisable(String loginType, Object loginId, long disableTime) {
Date date = new Date(System.currentTimeMillis() + disableTime * 1000);
println("账号[" + loginId + "]被封禁 (解封时间: " + SaFoxUtil.formatDate(date) + ")");
}
@ -58,7 +58,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
* 每次被解封时触发
*/
@Override
public void doUntieDisable(String loginKey, Object loginId) {
public void doUntieDisable(String loginType, Object loginId) {
println("账号[" + loginId + "]被解除封禁");
}

2
sa-token-core/src/main/java/cn/dev33/satoken/router/SaRouterUtil.java
View File

@ -10,8 +10,8 @@ import cn.dev33.satoken.fun.IsRunFunction;
import cn.dev33.satoken.fun.SaFunction;
/**
* <h1> 本类设计已过时，未来版本可能移除此类，请及时更换为 SaRouter ，使用方式保持不变 </h1>
* 对路由匹配符相关操作的封装工具类
* <h1> 本类设计已过时，未来版本可能移除此类，请及时更换为 SaRouter ，所有方法不变 </h1>
* @author kong
*
*/

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

@ -20,8 +20,8 @@ public class SaTokenInfo {
/** 此token对应的LoginId，未登录时为null */
public Object loginId;
/** LoginKey账号体系标识 */
public String loginKey;
/** 账号类型 */
public String loginType;
/** token剩余有效期 (单位: 秒) */
public long tokenTimeout;
@ -95,17 +95,17 @@ public class SaTokenInfo {
}
/**
* @return LoginKey账号体系标识
* @return 账号类型
*/
public String getLoginKey() {
return loginKey;
public String getLoginType() {
return loginType;
}
/**
* @param loginKey LoginKey账号体系标识
* @param loginType 账号类型
*/
public void setLoginKey(String loginKey) {
this.loginKey = loginKey;
public void setLoginType(String loginType) {
this.loginType = loginType;
}
/**
@ -184,7 +184,7 @@ public class SaTokenInfo {
@Override
public String toString() {
return "SaTokenInfo [tokenName=" + tokenName + ", tokenValue=" + tokenValue + ", isLogin=" + isLogin
+ ", loginId=" + loginId + ", loginKey=" + loginKey + ", tokenTimeout=" + tokenTimeout
+ ", loginId=" + loginId + ", loginType=" + loginType + ", tokenTimeout=" + tokenTimeout
+ ", sessionTimeout=" + sessionTimeout + ", tokenSessionTimeout=" + tokenSessionTimeout
+ ", tokenActivityTimeout=" + tokenActivityTimeout + ", loginDevice=" + loginDevice + "]";
}

8
sa-token-core/src/main/java/cn/dev33/satoken/stp/StpInterface.java
View File

@ -13,18 +13,18 @@ public interface StpInterface {
* 返回指定 LoginId 所拥有的权限码集合
*
* @param loginId 账号id
* @param loginKey 账号体系标识
* @param loginType 账号类型
* @return 该账号id具有的权限码集合
*/
public List<String> getPermissionList(Object loginId, String loginKey);
public List<String> getPermissionList(Object loginId, String loginType);
/**
* 返回指定loginId所拥有的角色标识集合
*
* @param loginId 账号id
* @param loginKey 账号体系标识
* @param loginType 账号类型
* @return 该账号id具有的角色标识集合
*/
public List<String> getRoleList(Object loginId, String loginKey);
public List<String> getRoleList(Object loginId, String loginType);
}

4
sa-token-core/src/main/java/cn/dev33/satoken/stp/StpInterfaceDefaultImpl.java
View File

@ -13,12 +13,12 @@ import java.util.List;
public class StpInterfaceDefaultImpl implements StpInterface {
@Override
public List<String> getPermissionList(Object loginId, String loginKey) {
public List<String> getPermissionList(Object loginId, String loginType) {
return new ArrayList<String>();
}
@Override
public List<String> getRoleList(Object loginId, String loginKey) {
public List<String> getRoleList(Object loginId, String loginType) {
return new ArrayList<String>();
}

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

@ -27,43 +27,41 @@ import cn.dev33.satoken.util.SaFoxUtil;
import cn.dev33.satoken.util.SaTokenConsts;
/**
* sa-token 权限验证，逻辑实现类
* <p>
* (stp = sa-token-permission 的缩写 )
* Sa-Token 权限验证，逻辑实现类
* @author kong
*/
public class StpLogic {
/**
* 持久化的key前缀，多账号认证体系时以此值区分，比如：login、user、admin
* 账号类型，多账号体系时以此值区分，比如：login、user、admin
*/
public String loginKey;
public String loginType;
/**
* 初始化StpLogic, 并指定LoginKey
* @param loginKey 账号体系标识
* 初始化StpLogic, 并指定账号类型
* @param loginType 账号体系标识
*/
public StpLogic(String loginKey) {
this.loginKey = loginKey;
// 在 SaTokenManager 中记录下此 StpLogic，以便根据 LoginKey 进行查找此对象
public StpLogic(String loginType) {
this.loginType = loginType;
// 在 SaTokenManager 中记录下此 StpLogic，以便根据 LoginType 进行查找此对象
SaManager.putStpLogic(this);
}
/**
* 获取当前StpLogin的LoginKey
* @return 当前StpLogin的loginKey
* 获取当前 StpLogic 的账号类型
* @return See Note
*/
public String getLoginKey(){
return loginKey;
public String getLoginType(){
return loginType;
}
/**
* 写入当前StpLogin的LoginKey
* @param loginKey loginKey
* 设置当前账号类型
* @param loginType loginType
* @return 对象自身
*/
public StpLogic setLoginKey(String loginKey){
this.loginKey = loginKey;
public StpLogic setLoginType(String loginType){
this.loginType = loginType;
return this;
}
@ -84,7 +82,7 @@ public class StpLogic {
* @return 生成的tokenValue
*/
public String createTokenValue(Object loginId) {
return SaManager.getSaTokenAction().createToken(loginId, loginKey);
return SaManager.getSaTokenAction().createToken(loginId, loginType);
}
/**
@ -166,7 +164,7 @@ public class StpLogic {
info.tokenValue = getTokenValue();
info.isLogin = isLogin();
info.loginId = getLoginIdDefaultNull();
info.loginKey = getLoginKey();
info.loginType = getLoginType();
info.tokenTimeout = getTokenTimeout();
info.sessionTimeout = getSessionTimeout();
info.tokenSessionTimeout = getTokenSessionTimeout();
@ -184,8 +182,8 @@ public class StpLogic {
* 在当前会话上登录id
* @param loginId 登录id，建议的类型：（long | int | String）
*/
public void setLoginId(Object loginId) {
setLoginId(loginId, new SaLoginModel());
public void login(Object loginId) {
login(loginId, new SaLoginModel());
}
/**
@ -193,8 +191,8 @@ public class StpLogic {
* @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识
*/
public void setLoginId(Object loginId, String device) {
setLoginId(loginId, new SaLoginModel().setDevice(device));
public void login(Object loginId, String device) {
login(loginId, new SaLoginModel().setDevice(device));
}
/**
@ -202,8 +200,8 @@ public class StpLogic {
* @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
public void setLoginId(Object loginId, boolean isLastingCookie) {
setLoginId(loginId, new SaLoginModel().setIsLastingCookie(isLastingCookie));
public void login(Object loginId, boolean isLastingCookie) {
login(loginId, new SaLoginModel().setIsLastingCookie(isLastingCookie));
}
/**
@ -211,11 +209,11 @@ public class StpLogic {
* @param loginId 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
*/
public void setLoginId(Object loginId, SaLoginModel loginModel) {
public void login(Object loginId, SaLoginModel loginModel) {
// ------ 0、检查此账号是否已被封禁
if(isDisable(loginId)) {
throw new DisableLoginException(loginKey, loginId, getDisableTime(loginId));
throw new DisableLoginException(loginType, loginId, getDisableTime(loginId));
}
// ------ 1、获取相应对象
@ -246,7 +244,7 @@ public class StpLogic {
// 3. 清理user-session上的token签名记录
session.removeTokenSign(tokenSign.getValue());
// $$ 通知监听器
SaManager.getSaTokenListener().doReplaced(loginKey, loginId, tokenSign.getValue(), tokenSign.getDevice());
SaManager.getSaTokenListener().doReplaced(loginType, loginId, tokenSign.getValue(), tokenSign.getDevice());
}
}
}
@ -277,7 +275,7 @@ public class StpLogic {
setTokenValue(tokenValue, loginModel.getCookieTimeout());
// $$ 通知监听器
SaManager.getSaTokenListener().doLogin(loginKey, loginId, loginModel);
SaManager.getSaTokenListener().doLogin(loginType, loginId, loginModel);
}
/**
@ -315,7 +313,7 @@ public class StpLogic {
SaManager.getSaTokenDao().delete(splicingKeyTokenValue(tokenValue));
// $$ 通知监听器
SaManager.getSaTokenListener().doLogout(loginKey, loginId, tokenValue);
SaManager.getSaTokenListener().doLogout(loginType, loginId, tokenValue);
// 4. 尝试清理User-Session上的token签名 (如果为null或已被标记为异常, 那么无需继续执行 )
SaSession session = getSessionByLoginId(loginId, false);
@ -363,7 +361,7 @@ public class StpLogic {
// 4. 清理账号session上的token签名
session.removeTokenSign(tokenValue);
// $$ 通知监听器
SaManager.getSaTokenListener().doLogoutByLoginId(loginKey, loginId, tokenValue, tokenSign.getDevice());
SaManager.getSaTokenListener().doLogoutByLoginId(loginType, loginId, tokenValue, tokenSign.getDevice());
}
}
// 3. 尝试注销session
@ -381,7 +379,7 @@ public class StpLogic {
SaManager.getSaTokenDao().set(splicingKeyDisable(loginId), DisableLoginException.BE_VALUE, disableTime);
// $$ 通知监听器
SaManager.getSaTokenListener().doDisable(loginKey, loginId, disableTime);
SaManager.getSaTokenListener().doDisable(loginType, loginId, disableTime);
}
/**
@ -410,7 +408,7 @@ public class StpLogic {
SaManager.getSaTokenDao().delete(splicingKeyDisable(loginId));
// $$ 通知监听器
SaManager.getSaTokenListener().doUntieDisable(loginKey, loginId);
SaManager.getSaTokenListener().doUntieDisable(loginType, loginId);
}
@ -444,24 +442,24 @@ public class StpLogic {
// 如果获取不到token，则抛出: 无token
String tokenValue = getTokenValue();
if(tokenValue == null) {
throw NotLoginException.newInstance(loginKey, NotLoginException.NOT_TOKEN);
throw NotLoginException.newInstance(loginType, NotLoginException.NOT_TOKEN);
}
// 查找此token对应loginId, 如果找不到则抛出：无效token
String loginId = getLoginIdNotHandle(tokenValue);
if(loginId == null) {
throw NotLoginException.newInstance(loginKey, NotLoginException.INVALID_TOKEN);
throw NotLoginException.newInstance(loginType, NotLoginException.INVALID_TOKEN);
}
// 如果是已经过期，则抛出已经过期
if(loginId.equals(NotLoginException.TOKEN_TIMEOUT)) {
throw NotLoginException.newInstance(loginKey, NotLoginException.TOKEN_TIMEOUT);
throw NotLoginException.newInstance(loginType, NotLoginException.TOKEN_TIMEOUT);
}
// 如果是已经被顶替下去了, 则抛出：已被顶下线
if(loginId.equals(NotLoginException.BE_REPLACED)) {
throw NotLoginException.newInstance(loginKey, NotLoginException.BE_REPLACED);
throw NotLoginException.newInstance(loginType, NotLoginException.BE_REPLACED);
}
// 如果是已经被踢下线了, 则抛出：已被踢下线
if(loginId.equals(NotLoginException.KICK_OUT)) {
throw NotLoginException.newInstance(loginKey, NotLoginException.KICK_OUT);
throw NotLoginException.newInstance(loginType, NotLoginException.KICK_OUT);
}
// 检查是否已经 [临时过期]
checkActivityTimeout(tokenValue);
@ -744,7 +742,7 @@ public class StpLogic {
}
// -2 代表已过期，抛出异常
if(timeout == SaTokenDao.NOT_VALUE_EXPIRE) {
throw NotLoginException.newInstance(loginKey, NotLoginException.TOKEN_TIMEOUT);
throw NotLoginException.newInstance(loginType, NotLoginException.TOKEN_TIMEOUT);
}
// --- 至此，验证已通过
@ -885,7 +883,7 @@ public class StpLogic {
* @return 是否含有指定角色标识
*/
public boolean hasRole(Object loginId, String role) {
List<String> roleList = SaManager.getStpInterface().getRoleList(loginId, loginKey);
List<String> roleList = SaManager.getStpInterface().getRoleList(loginId, loginType);
return SaManager.getSaTokenAction().hasElement(roleList, role);
// return !(roleList == null || roleList.contains(role) == false);
}
@ -905,7 +903,7 @@ public class StpLogic {
*/
public void checkRole(String role) {
if(!hasRole(role)) {
throw new NotRoleException(role, this.loginKey);
throw new NotRoleException(role, this.loginType);
}
}
@ -915,10 +913,10 @@ public class StpLogic {
*/
public void checkRoleAnd(String... roleArray){
Object loginId = getLoginId();
List<String> roleList = SaManager.getStpInterface().getRoleList(loginId, loginKey);
List<String> roleList = SaManager.getStpInterface().getRoleList(loginId, loginType);
for (String role : roleArray) {
if(!SaManager.getSaTokenAction().hasElement(roleList, role)) {
throw new NotRoleException(role, this.loginKey);
throw new NotRoleException(role, this.loginType);
}
}
}
@ -929,7 +927,7 @@ public class StpLogic {
*/
public void checkRoleOr(String... roleArray){
Object loginId = getLoginId();
List<String> roleList = SaManager.getStpInterface().getRoleList(loginId, loginKey);
List<String> roleList = SaManager.getStpInterface().getRoleList(loginId, loginType);
for (String role : roleArray) {
if(SaManager.getSaTokenAction().hasElement(roleList, role)) {
// 有的话提前退出
@ -937,7 +935,7 @@ public class StpLogic {
}
}
if(roleArray.length > 0) {
throw new NotRoleException(roleArray[0], this.loginKey);
throw new NotRoleException(roleArray[0], this.loginType);
}
}
@ -951,7 +949,7 @@ public class StpLogic {
* @return 是否含有指定权限
*/
public boolean hasPermission(Object loginId, String permission) {
List<String> permissionList = SaManager.getStpInterface().getPermissionList(loginId, loginKey);
List<String> permissionList = SaManager.getStpInterface().getPermissionList(loginId, loginType);
return SaManager.getSaTokenAction().hasElement(permissionList, permission);
// return !(permissionList == null || permissionList.contains(permission) == false);
}
@ -971,7 +969,7 @@ public class StpLogic {
*/
public void checkPermission(String permission) {
if(hasPermission(permission) == false) {
throw new NotPermissionException(permission, this.loginKey);
throw new NotPermissionException(permission, this.loginType);
}
}
@ -981,10 +979,10 @@ public class StpLogic {
*/
public void checkPermissionAnd(String... permissionArray){
Object loginId = getLoginId();
List<String> permissionList = SaManager.getStpInterface().getPermissionList(loginId, loginKey);
List<String> permissionList = SaManager.getStpInterface().getPermissionList(loginId, loginType);
for (String permission : permissionArray) {
if(!SaManager.getSaTokenAction().hasElement(permissionList, permission)) {
throw new NotPermissionException(permission, this.loginKey);
throw new NotPermissionException(permission, this.loginType);
}
}
}
@ -995,7 +993,7 @@ public class StpLogic {
*/
public void checkPermissionOr(String... permissionArray){
Object loginId = getLoginId();
List<String> permissionList = SaManager.getStpInterface().getPermissionList(loginId, loginKey);
List<String> permissionList = SaManager.getStpInterface().getPermissionList(loginId, loginType);
for (String permission : permissionArray) {
if(SaManager.getSaTokenAction().hasElement(permissionList, permission)) {
// 有的话提前退出
@ -1003,7 +1001,7 @@ public class StpLogic {
}
}
if(permissionArray.length > 0) {
throw new NotPermissionException(permissionArray[0], this.loginKey);
throw new NotPermissionException(permissionArray[0], this.loginType);
}
}
@ -1148,7 +1146,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeyTokenValue(String tokenValue) {
return getConfig().getTokenName() + ":" + loginKey + ":token:" + tokenValue;
return getConfig().getTokenName() + ":" + loginType + ":token:" + tokenValue;
}
/**
@ -1157,7 +1155,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeySession(Object loginId) {
return getConfig().getTokenName() + ":" + loginKey + ":session:" + loginId;
return getConfig().getTokenName() + ":" + loginType + ":session:" + loginId;
}
/**
@ -1166,7 +1164,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeyTokenSession(String tokenValue) {
return getConfig().getTokenName() + ":" + loginKey + ":token-session:" + tokenValue;
return getConfig().getTokenName() + ":" + loginType + ":token-session:" + tokenValue;
}
/**
@ -1175,7 +1173,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeyLastActivityTime(String tokenValue) {
return getConfig().getTokenName() + ":" + loginKey + ":last-activity:" + tokenValue;
return getConfig().getTokenName() + ":" + loginType + ":last-activity:" + tokenValue;
}
/**
@ -1183,7 +1181,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeySwitch() {
return SaTokenConsts.SWITCH_TO_SAVE_KEY + loginKey;
return SaTokenConsts.SWITCH_TO_SAVE_KEY + loginType;
}
/**
@ -1191,7 +1189,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeyJustCreatedSave() {
return SaTokenConsts.JUST_CREATED_SAVE_KEY + loginKey;
return SaTokenConsts.JUST_CREATED_SAVE_KEY + loginType;
}
/**
@ -1200,7 +1198,7 @@ public class StpLogic {
* @return key
*/
public String splicingKeyDisable(Object loginId) {
return getConfig().getTokenName() + ":" + loginKey + ":disable:" + loginId;
return getConfig().getTokenName() + ":" + loginType + ":disable:" + loginId;
}
// =================== Bean对象代理 ===================

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

@ -6,27 +6,27 @@ import cn.dev33.satoken.fun.SaFunction;
import cn.dev33.satoken.session.SaSession;
/**
* 一个默认的实现
* Sa-Token 权限验证, 工具类
* @author kong
*/
public class StpUtil {
/**
* 账号体系标识
* 账号类型标识
*/
public static final String KEY = "login";
public static final String TYPE = "login";
/**
* 底层的 StpLogic 对象
*/
public static StpLogic stpLogic = new StpLogic(KEY);
public static StpLogic stpLogic = new StpLogic(TYPE);
/**
* 获取当前StpLogin的loginKey
* @return 当前StpLogin的loginKey
* 获取当前 StpLogic 的账号类型
* @return See Note
*/
public static String getLoginKey(){
return stpLogic.getLoginKey();
public static String getLoginType(){
return stpLogic.getLoginType();
}
@ -72,8 +72,8 @@ public class StpUtil {
* 在当前会话上登录id
* @param loginId 登录id，建议的类型：（long | int | String）
*/
public static void setLoginId(Object loginId) {
stpLogic.setLoginId(loginId);
public static void login(Object loginId) {
stpLogic.login(loginId);
}
/**
@ -81,8 +81,8 @@ public class StpUtil {
* @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识
*/
public static void setLoginId(Object loginId, String device) {
stpLogic.setLoginId(loginId, device);
public static void login(Object loginId, String device) {
stpLogic.login(loginId, device);
}
/**
@ -90,8 +90,8 @@ public class StpUtil {
* @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
public static void setLoginId(Object loginId, boolean isLastingCookie) {
stpLogic.setLoginId(loginId, isLastingCookie);
public static void login(Object loginId, boolean isLastingCookie) {
stpLogic.login(loginId, isLastingCookie);
}
/**
@ -99,8 +99,8 @@ public class StpUtil {
* @param loginId 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
*/
public static void setLoginId(Object loginId, SaLoginModel loginModel) {
stpLogic.setLoginId(loginId, loginModel);
public static void login(Object loginId, SaLoginModel loginModel) {
stpLogic.login(loginId, loginModel);
}
/**
@ -588,5 +588,60 @@ public class StpUtil {
stpLogic.switchTo(loginId, function);
}
// =================== 历史API，兼容旧版本 ===================
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.getLoginType() ，使用方式保持不变 </h1>
* 获取当前StpLogin的loginKey
* @return 当前StpLogin的loginKey
*/
@Deprecated
public static String getLoginKey(){
return stpLogic.getLoginType();
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* 在当前会话上登录id
* @param loginId 登录id，建议的类型：（long | int | String）
*/
@Deprecated
public static void setLoginId(Object loginId) {
stpLogic.login(loginId);
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* 在当前会话上登录id, 并指定登录设备
* @param loginId 登录id，建议的类型：（long | int | String）
* @param device 设备标识
*/
@Deprecated
public static void setLoginId(Object loginId, String device) {
stpLogic.login(loginId, device);
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* 在当前会话上登录id, 并指定登录设备
* @param loginId 登录id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
@Deprecated
public static void setLoginId(Object loginId, boolean isLastingCookie) {
stpLogic.login(loginId, isLastingCookie);
}
/**
* <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
* 在当前会话上登录id, 并指定所有登录参数Model
* @param loginId 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
*/
@Deprecated
public static void setLoginId(Object loginId, SaLoginModel loginModel) {
stpLogic.login(loginId, loginModel);
}
}

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

@ -67,7 +67,7 @@ public class SaFoxUtil {
}
/**
* 将日期格式化
* 将日期格式化 （yyyy-MM-dd HH:mm:ss）
* @param date 日期
* @return 格式化后的时间
*/

8
sa-token-demo/sa-token-demo-jwt/src/main/java/com/pj/satoken/jwt/SaTokenJwtUtil.java
View File

@ -90,10 +90,10 @@ public class SaTokenJwtUtil {
}
return String.valueOf(loginId);
} catch (ExpiredJwtException e) {
// throw NotLoginException.newInstance(StpUtil.stpLogic.loginKey, NotLoginException.TOKEN_TIMEOUT);
// throw NotLoginException.newInstance(StpUtil.TYPE, NotLoginException.TOKEN_TIMEOUT);
return NotLoginException.TOKEN_TIMEOUT;
} catch (MalformedJwtException e) {
throw NotLoginException.newInstance(StpUtil.stpLogic.loginKey, NotLoginException.INVALID_TOKEN);
throw NotLoginException.newInstance(StpUtil.stpLogic.loginType, NotLoginException.INVALID_TOKEN);
} catch (Exception e) {
throw new SaTokenException(e);
}
@ -122,7 +122,7 @@ public class SaTokenJwtUtil {
// 重写 (在当前会话上登录id )
@Override
public void setLoginId(Object loginId, SaLoginModel loginModel) {
public void login(Object loginId, SaLoginModel loginModel) {
// ------ 1、获取相应对象
SaStorage storage = SaManager.getSaTokenContext().getStorage();
SaTokenConfig config = getConfig();
@ -203,7 +203,7 @@ public class SaTokenJwtUtil {
info.tokenValue = getTokenValue();
info.isLogin = isLogin();
info.loginId = getLoginIdDefaultNull();
info.loginKey = getLoginKey();
info.loginType = getLoginType();
info.tokenTimeout = getTokenTimeout();
// info.sessionTimeout = getSessionTimeout();
// info.tokenSessionTimeout = getTokenSessionTimeout();

4
sa-token-demo/sa-token-demo-jwt/src/main/java/com/pj/test/TestJwtController.java
View File

@ -32,7 +32,7 @@ public class TestJwtController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号：" + StpUtil.getLoginIdDefaultNull());
StpUtil.setLoginId(id); // 在当前会话登录此账号
StpUtil.login(id); // 在当前会话登录此账号
System.out.println("登录成功");
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号：" + StpUtil.getLoginId());
@ -73,7 +73,7 @@ public class TestJwtController {
public AjaxJson test() {
System.out.println();
System.out.println("--------------进入请求--------------");
StpUtil.setLoginId(10001);
StpUtil.login(10001);
System.out.println(StpUtil.getTokenInfo().getTokenValue());
return AjaxJson.getSuccess();
}

4
sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/satoken/StpInterfaceImpl.java
View File

@ -17,7 +17,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的权限码集合
*/
@Override
public List<String> getPermissionList(Object loginId, String loginKey) {
public List<String> getPermissionList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限
List<String> list = new ArrayList<String>();
list.add("101");
@ -33,7 +33,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的角色标识集合
*/
@Override
public List<String> getRoleList(Object loginId, String loginKey) {
public List<String> getRoleList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询角色
List<String> list = new ArrayList<String>();
list.add("admin");

2
sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/test/SSOController.java
View File

@ -21,7 +21,7 @@ public class SSOController {
@Mapping("doLogin")
public AjaxJson doLogin(@Param(defaultValue = "10001") String id) {
System.out.println("---------------- 进行登录 ");
StpUtil.setLoginId(id);
StpUtil.login(id);
return AjaxJson.getSuccess("登录成功: " + id);
}

2
sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/test/StressTestController.java
View File

@ -38,7 +38,7 @@ public class StressTestController {
Ttime t = new Ttime().start();
// 每次登录的次数
for (int j = 1; j <= loginCount; j++) {
StpUtil.setLoginId("1000" + j, "PC-" + j);
StpUtil.login("1000" + j, "PC-" + j);
if(j % 1000 == 0) {
System.out.println("已登录：" + j);
}

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

@ -36,7 +36,7 @@ public class TestController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号：" + StpUtil.getLoginIdDefaultNull());
StpUtil.setLoginId(id); // 在当前会话登录此账号
StpUtil.login(id); // 在当前会话登录此账号
System.out.println("登录成功");
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号：" + StpUtil.getLoginId());
@ -183,7 +183,7 @@ public class TestController {
@Mapping("kickOut")
public AjaxJson kickOut() {
// 先登录上
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// 踢下线
StpUtil.logoutByLoginId(10001);
// 再尝试获取
@ -195,7 +195,7 @@ public class TestController {
// 测试登录接口, 按照设备登录， 浏览器访问： http://localhost:8081/test/login2
@Mapping("login2")
public AjaxJson login2(@Param(defaultValue="10001") String id, @Param(defaultValue="PC") String device) {
StpUtil.setLoginId(id, device);
StpUtil.login(id, device);
return AjaxJson.getSuccess();
}
@ -230,7 +230,7 @@ public class TestController {
@Mapping("loginByDevice")
public AjaxJson loginByDevice() {
System.out.println("--------------");
StpUtil.setLoginId(10001, "PC");
StpUtil.login(10001, "PC");
return AjaxJson.getSuccessData("登录成功");
}

2
sa-token-demo/sa-token-demo-solon/src/main/java/com/pj/test/UserController.java
View File

@ -18,7 +18,7 @@ public class UserController {
public String doLogin(String username, String password) {
// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对
if("zhang".equals(username) && "123456".equals(password)) {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
return "登录成功";
}
return "登录失败";

4
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/satoken/StpInterfaceImpl.java
View File

@ -17,7 +17,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的权限码集合
*/
@Override
public List<String> getPermissionList(Object loginId, String loginKey) {
public List<String> getPermissionList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限
List<String> list = new ArrayList<String>();
list.add("101");
@ -33,7 +33,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的角色标识集合
*/
@Override
public List<String> getRoleList(Object loginId, String loginKey) {
public List<String> getRoleList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询角色
List<String> list = new ArrayList<String>();
list.add("admin");

2
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/test/SSOController.java
View File

@ -20,7 +20,7 @@ public class SSOController {
@RequestMapping("doLogin")
public AjaxJson doLogin(@RequestParam(defaultValue = "10001") String id) {
System.out.println("---------------- 进行登录 ");
StpUtil.setLoginId(id);
StpUtil.login(id);
return AjaxJson.getSuccess("登录成功: " + id);
}

2
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/test/StressTestController.java
View File

@ -38,7 +38,7 @@ public class StressTestController {
Ttime t = new Ttime().start();
// 每次登录的次数
for (int j = 1; j <= loginCount; j++) {
StpUtil.setLoginId("1000" + j, "PC-" + j);
StpUtil.login("1000" + j, "PC-" + j);
if(j % 1000 == 0) {
System.out.println("已登录：" + j);
}

8
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/test/TestController.java
View File

@ -38,7 +38,7 @@ public class TestController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号：" + StpUtil.getLoginIdDefaultNull());
StpUtil.setLoginId(id); // 在当前会话登录此账号
StpUtil.login(id); // 在当前会话登录此账号
System.out.println("登录成功");
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号：" + StpUtil.getLoginId());
@ -185,7 +185,7 @@ public class TestController {
@RequestMapping("kickOut")
public AjaxJson kickOut() {
// 先登录上
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// 踢下线
StpUtil.logoutByLoginId(10001);
// 再尝试获取
@ -197,7 +197,7 @@ public class TestController {
// 测试登录接口, 按照设备登录， 浏览器访问： http://localhost:8081/test/login2
@RequestMapping("login2")
public AjaxJson login2(@RequestParam(defaultValue="10001") String id, @RequestParam(defaultValue="PC") String device) {
StpUtil.setLoginId(id, device);
StpUtil.login(id, device);
return AjaxJson.getSuccess();
}
@ -232,7 +232,7 @@ public class TestController {
@RequestMapping("loginByDevice")
public AjaxJson loginByDevice() {
System.out.println("--------------");
StpUtil.setLoginId(10001, "PC");
StpUtil.login(10001, "PC");
return AjaxJson.getSuccessData("登录成功");
}

2
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/test/UserController.java
View File

@ -19,7 +19,7 @@ public class UserController {
public String doLogin(String username, String password) {
// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对
if("zhang".equals(username) && "123456".equals(password)) {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
return "登录成功";
}
return "登录失败";

4
sa-token-demo/sa-token-demo-webflux/src/main/java/com/pj/satoken/StpInterfaceImpl.java
View File

@ -17,7 +17,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的权限码集合
*/
@Override
public List<String> getPermissionList(Object loginId, String loginKey) {
public List<String> getPermissionList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限
List<String> list = new ArrayList<String>();
list.add("101");
@ -33,7 +33,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的角色标识集合
*/
@Override
public List<String> getRoleList(Object loginId, String loginKey) {
public List<String> getRoleList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询角色
List<String> list = new ArrayList<String>();
list.add("admin");

2
sa-token-demo/sa-token-demo-webflux/src/main/java/com/pj/test/TestController.java
View File

@ -24,7 +24,7 @@ public class TestController {
// 测试登录接口 [同步模式]， 浏览器访问： http://localhost:8081/test/login
@RequestMapping("login")
public AjaxJson login(@RequestParam(defaultValue="10001") String id) {
StpUtil.setLoginId(id);
StpUtil.login(id);
return AjaxJson.getSuccess("登录成功");
}

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

@ -80,7 +80,7 @@ Sa-Token的API调用非常简单，有多简单呢？以登录验证为例，你
``` java
// 在登录时写入当前会话的账号id
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// 然后在任意需要校验登录处调用以下API
// 如果当前会话未登录，这句代码会抛出 `NotLoginException`异常
@ -112,7 +112,7 @@ StpUtil.logoutByLoginId(10001);
除了以上的示例，Sa-Token还可以一行代码完成以下功能：
``` java
StpUtil.setLoginId(10001); // 标记当前会话登录的账号id
StpUtil.login(10001); // 标记当前会话登录的账号id
StpUtil.getLoginId(); // 获取当前会话登录的账号id
StpUtil.isLogin(); // 获取当前会话是否已经登录, 返回true或false
StpUtil.logout(); // 当前会话注销登录
@ -122,7 +122,7 @@ StpUtil.hasPermission("user:add"); // 查询当前账号是否含有指
StpUtil.getSession(); // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001); // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001); // 获取账号id为10001的token令牌值
StpUtil.setLoginId(10001, "PC"); // 指定设备标识登录
StpUtil.login(10001, "PC"); // 指定设备标识登录
StpUtil.logoutByLoginId(10001, "PC"); // 指定设备标识进行强制注销 (不同端不受影响)
StpUtil.switchTo(10044); // 将当前会话身份临时切换为其它账号
```

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

@ -11,7 +11,7 @@ token信息Model: 用来描述一个token的常用参数
"tokenValue": "e67b99f1-3d7a-4a8d-bb2f-e888a0805633", // token值
"isLogin": true, // 此token是否已经登录
"loginId": "10001", // 此token对应的LoginId，未登录时为null
"loginKey": "login", // LoginKey账号体系标识
"loginType": "login", // 账号类型标识
"tokenTimeout": 2591977, // token剩余有效期 (单位: 秒)
"sessionTimeout": 2591977, // User-Session剩余有效时间 (单位: 秒)
"tokenSessionTimeout": -2, // Token-Session剩余有效时间 (单位: 秒)

2
sa-token-doc/doc/more/common-action.md
View File

@ -12,7 +12,7 @@ SaManager.getStpInterface(); // 获取权限认证对象
SaManager.getSaTokenAction(); // 获取框架行为对象
SaManager.getSaTokenContext(); // 获取上下文处理对象
SaManager.getSaTokenListener(); // 获取侦听器对象
SaManager.getStpLogic("key"); // 获取指定key的StpLogic对象
SaManager.getStpLogic("type"); // 获取指定账号类型的StpLogic对象
```

4
sa-token-doc/doc/more/common-questions.md
View File

@ -33,8 +33,8 @@
`SaRouter.match(Arrays.asList("/**"), Arrays.asList("/login", "/reg"), () -> StpUtil.checkLogin());`
### 为什么StpUtil.setLoginId() 不能直接写入一个User对象？
`StpUtil.setLoginId()`只是为了给当前会话做个唯一标记，通常写入`UserId`即可，如果要存储User对象，可以使用`StpUtil.getSession()`获取Session对象进行存储
### 为什么StpUtil.login() 不能直接写入一个User对象？
`StpUtil.login()`只是为了给当前会话做个唯一标记，通常写入`UserId`即可，如果要存储User对象，可以使用`StpUtil.getSession()`获取Session对象进行存储
### 前后台分离模式下和普通模式有何不同？

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

@ -1,7 +1,7 @@
# 更新日志
### 2021-5-10 @v1.19.0
- 新增：注解鉴权新增定制loginKey功能 **[重要]**
- 新增：注解鉴权新增定制loginType功能 **[重要]**
- 重构：重构目录结构，抽离`plugin`模块 **[重要]**
- 新增：新增 `sa-token-quick-login` 插件，零代码集成登录功能 **[重要]**
- 优化：所有函数式接口增加`@FunctionalInterface`注解，感谢群友`@MrXionGe`提供的建议
@ -65,7 +65,7 @@
### 2021-3-12 @v1.14.0
- 新增：新增`SaLoginModel`登录参数Model，适配 [记住我] 模式 **[重要]**
- 新增：新增 `StpUtil.setLoginId()` 时指定token有效期，可灵活控制用户的一次登录免验证时长
- 新增：新增 `StpUtil.login()` 时指定token有效期，可灵活控制用户的一次登录免验证时长
- 新增：新增Cookie时间判断，在`timeout`设置为-1时，`Cookie`有效期将为`Integer.MAX_VALUE` **[重要]**
- 新增：新增密码加密工具类，可快速MD5、SHA1、SHA256、AES、RSA加密 **[重要]**
- 新增：新增 OAuth2.0 模块 **[重要]**
@ -182,7 +182,7 @@
### 2020-5-2 @v1.3.0
- 新增：新增 `StpUtil.checkLogin()` 方法，更符合语义化的鉴权方法
- 新增：注册拦截器时可设置 `StpLogic` ，方便不同模块不同鉴权方式
- 新增：抛出异常时增加 `loginKey` 区分，方便多账号体系鉴权处理
- 新增：抛出异常时增加 `loginType` 区分，方便多账号体系鉴权处理
- 修复：修复启动时的版本字符画版本号打印不对的bug
- 修复：修复文档部分不正确之处
- 新增：新增文档的友情链接

2
sa-token-doc/doc/senior/sso.md
View File

@ -71,7 +71,7 @@ public class SSOController {
@RequestMapping("doLogin")
public AjaxJson doLogin(@RequestParam(defaultValue = "10001") String id) {
System.out.println("---------------- 进行登录 ");
StpUtil.setLoginId(id);
StpUtil.login(id);
return AjaxJson.getSuccess("登录成功: " + id);
}

2
sa-token-doc/doc/start/example.md
View File

@ -77,7 +77,7 @@ public class UserController {
public String doLogin(String username, String password) {
// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对
if("zhang".equals(username) && "123456".equals(password)) {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
return "登录成功";
}
return "登录失败";

2
sa-token-doc/doc/start/webflux-example.md
View File

@ -83,7 +83,7 @@ public class UserController {
public String doLogin(String username, String password) {
// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对
if("zhang".equals(username) && "123456".equals(password)) {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
return "登录成功";
}
return "登录失败";

12
sa-token-doc/doc/use/global-listener.md
View File

@ -21,37 +21,37 @@ public class MySaTokenListener implements SaTokenListener {
/** 每次登录时触发 */
@Override
public void doLogin(String loginKey, Object loginId, SaLoginModel loginModel) {
public void doLogin(String loginType, Object loginId, SaLoginModel loginModel) {
// ...
}
/** 每次注销时触发 */
@Override
public void doLogout(String loginKey, Object loginId, String tokenValue) {
public void doLogout(String loginType, Object loginId, String tokenValue) {
// ...
}
/** 每次被踢下线时触发 */
@Override
public void doLogoutByLoginId(String loginKey, Object loginId, String tokenValue, String device) {
public void doLogoutByLoginId(String loginType, Object loginId, String tokenValue, String device) {
// ...
}
/** 每次被顶下线时触发 */
@Override
public void doReplaced(String loginKey, Object loginId, String tokenValue, String device) {
public void doReplaced(String loginType, Object loginId, String tokenValue, String device) {
// ...
}
/** 每次被封禁时触发 */
@Override
public void doDisable(String loginKey, Object loginId, long disableTime) {
public void doDisable(String loginType, Object loginId, long disableTime) {
// ...
}
/** 每次被解封时触发 */
@Override
public void doUntieDisable(String loginKey, Object loginId) {
public void doUntieDisable(String loginType, Object loginId) {
// ...
}

8
sa-token-doc/doc/use/jur-auth.md
View File

@ -38,7 +38,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的权限码集合
*/
@Override
public List<String> getPermissionList(Object loginId, String loginKey) {
public List<String> getPermissionList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限
List<String> list = new ArrayList<String>();
list.add("101");
@ -54,7 +54,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的角色标识集合 (权限与角色可分开校验)
*/
@Override
public List<String> getRoleList(Object loginId, String loginKey) {
public List<String> getRoleList(Object loginId, String loginType) {
// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询角色
List<String> list = new ArrayList<String>();
list.add("admin");
@ -88,7 +88,7 @@ StpUtil.checkPermissionAnd("user-update", "user-delete");
StpUtil.checkPermissionOr("user-update", "user-delete");
```
扩展：`NotPermissionException` 对象可通过 `getLoginKey()` 方法获取具体是哪个 `StpLogic` 抛出的异常
扩展：`NotPermissionException` 对象可通过 `getLoginType()` 方法获取具体是哪个 `StpLogic` 抛出的异常
### 角色认证
@ -108,7 +108,7 @@ StpUtil.checkRoleAnd("super-admin", "shop-admin");
StpUtil.checkRoleOr("super-admin", "shop-admin");
```
扩展：`NotRoleException` 对象可通过 `getLoginKey()` 方法获取具体是哪个 `StpLogic` 抛出的异常
扩展：`NotRoleException` 对象可通过 `getLoginType()` 方法获取具体是哪个 `StpLogic` 抛出的异常

4
sa-token-doc/doc/use/login-auth.md
View File

@ -14,7 +14,7 @@
``` java
// 标记当前会话登录的账号id
// 建议的参数类型：long | int | String， 不可以传入复杂类型，如：User、Admin等等
StpUtil.setLoginId(Object loginId);
StpUtil.login(Object loginId);
// 当前会话注销登录
StpUtil.logout();
@ -26,7 +26,7 @@ StpUtil.isLogin();
StpUtil.checkLogin()
```
扩展：`NotLoginException` 对象可通过 `getLoginKey()` 方法获取具体是哪个 `StpLogic` 抛出的异常 <br>
扩展：`NotLoginException` 对象可通过 `getLoginType()` 方法获取具体是哪个 `StpLogic` 抛出的异常 <br>
扩展：`NotLoginException` 对象可通过 `getType()` 方法获取具体的场景值，详细参考章节：[未登录场景值](/fun/not-login-scene)

20
sa-token-doc/doc/use/many-account.md
View File

@ -17,7 +17,7 @@
这样做有两个优点:
- `StpLogic`类的所有函数都可以被重写，按需扩展
- 在构造方法时随意传入一个不同的 `loginKey`，就可以再造一套账号登录体系
- 在构造方法时随意传入一个不同的 `loginType`，就可以再造一套账号登录体系
### 操作示例
@ -25,7 +25,7 @@
比如说，对于原生`StpUtil`类，我们只做`admin账号`权限验证，而对于`user账号`，我们则：
1. 新建一个新的权限验证类，比如： `StpUserUtil.java`
2. 将`StpUtil.java`类的全部代码复制粘贴到 `StpUserUtil.java`里
3. 更改一下其 `LoginKey`， 比如：
3. 更改一下其 `LoginType`， 比如：
``` java
public class StpUserUtil {
@ -33,7 +33,7 @@ public class StpUserUtil {
/**
* 账号体系标识
*/
public static final String KEY = "user"; // 将 LoginKey 从`login`改为`user`
public static final String KEY = "user"; // 将 LoginType 从`login`改为`user`
// 其它代码 ...
@ -47,21 +47,21 @@ public class StpUserUtil {
### 在多账号模式下使用注解鉴权
框架默认的注解鉴权 如`@SaCheckLogin` 只针对原生`StpUtil`进行鉴权
例如，我们在一个方法上加上`@SaCheckLogin`注解，这个注解只会放行通过`StpUtil.setLoginId(id)`进行登录的会话，
而对于通过`StpUserUtil.setLoginId(id)`进行登录的都会话，则始终不会通过校验
例如，我们在一个方法上加上`@SaCheckLogin`注解，这个注解只会放行通过`StpUtil.login(id)`进行登录的会话，
而对于通过`StpUserUtil.login(id)`进行登录的都会话，则始终不会通过校验
那么如何告诉`@SaCheckLogin`要鉴别的是哪套账号的登录会话呢？很简单，你只需要指定一下注解的key属性即可：
那么如何告诉`@SaCheckLogin`要鉴别的是哪套账号的登录会话呢？很简单，你只需要指定一下注解的type属性即可：
``` java
// 通过key属性指定此注解校验的是我们自定义的`StpUserUtil`，而不是原生`StpUtil`
@SaCheckLogin(key = StpUserUtil.KEY)
// 通过type属性指定此注解校验的是我们自定义的`StpUserUtil`，而不是原生`StpUtil`
@SaCheckLogin(type = StpUserUtil.TYPE)
@RequestMapping("info")
public String info() {
return "查询用户信息";
}
```
注：`@SaCheckRole("xxx")`、`@SaCheckPermission("xxx")`同理，亦可根据key属性指定其校验的账号体系，此属性默认为`""`，代表使用原生`StpUtil`账号体系
注：`@SaCheckRole("xxx")`、`@SaCheckPermission("xxx")`同理，亦可根据type属性指定其校验的账号体系，此属性默认为`""`，代表使用原生`StpUtil`账号体系
@ -86,7 +86,7 @@ public static StpLogic stpLogic = new StpLogic("user") {
};
```
再次调用 `StpUserUtil.setLoginId(10001)` 进行登录授权时，token的名称将不再是 `satoken`，而是我们重写后的 `satoken-user`
再次调用 `StpUserUtil.login(10001)` 进行登录授权时，token的名称将不再是 `satoken`，而是我们重写后的 `satoken-user`

2
sa-token-doc/doc/use/mutex-login.md
View File

@ -14,7 +14,7 @@
#### 指定设备标识登录
``` java
// 指定`账号id`和`设备标识`进行登录
StpUtil.setLoginId(10001, "PC");
StpUtil.login(10001, "PC");
```
调用此方法登录后，同设备的会被顶下线(不同设备不受影响)，再次访问系统时会抛出 `NotLoginException` 异常，场景值=`-4`

2
sa-token-doc/doc/use/not-cookie.md
View File

@ -20,7 +20,7 @@
### 1、后端将 token 返回到前端
1. 首先调用 `StpUtil.setLoginId(Object loginId)` 进行登录
1. 首先调用 `StpUtil.login(Object loginId)` 进行登录
2. 调用 `StpUtil.getTokenInfo()` 返回当前会话的token详细参数
- 此方法返回一个对象，其有两个关键属性：`tokenName`和`tokenValue`（`token`的名称和`token`的值）
- 将此对象传递到前台，让前端人员将这两个值保存到本地

10
sa-token-doc/doc/use/remember-me.md
View File

@ -14,7 +14,7 @@ sa-token的登录授权，**默认就是`[记住我]`模式**，为了实现`[
``` java
// 设置登录账号id为10001，第二个参数指定是否为[记住我]，当此值为false后，关闭浏览器后再次打开需要重新登录
StpUtil.setLoginId(10001, false);
StpUtil.login(10001, false);
```
那么，sa-token实现`[记住我]`的具体原理是？
@ -26,8 +26,8 @@ Cookie作为浏览器提供的默认会话跟踪机制，其生命周期有两
- 永久Cookie：有效期为一个具体的时间，在时间未到期之前，即使用户关闭了浏览器Cookie也不会消失
利用Cookie的此特性，我们便可以轻松实现 [记住我] 模式：
- 勾选[记住我]按钮时：调用`StpUtil.setLoginId(10001, true)`，在浏览器写入一个`永久Cookie`储存token，此时用户即使重启浏览器token依然有效
- 不勾选[记住我]按钮时：调用`StpUtil.setLoginId(10001, false)`，在浏览器写入一个`临时Cookie`储存token，此时用户在重启浏览器后token便会消失，导致会话失效
- 勾选[记住我]按钮时：调用`StpUtil.login(10001, true)`，在浏览器写入一个`永久Cookie`储存token，此时用户即使重启浏览器token依然有效
- 不勾选[记住我]按钮时：调用`StpUtil.login(10001, false)`，在浏览器写入一个`临时Cookie`储存token，此时用户在重启浏览器后token便会消失，导致会话失效
### 前后台分离模式下如何实现[记住我]?
@ -64,11 +64,11 @@ Remember me, it's too easy!
``` java
// 示例1：
// 指定token有效期(单位: 秒)，如下所示token七天有效
StpUtil.setLoginId(10001, new SaLoginModel().setTimeout(60 * 60 * 24 * 7));
StpUtil.login(10001, new SaLoginModel().setTimeout(60 * 60 * 24 * 7));
// ----------------------- 示例2：所有参数
// `SaLoginModel`为登录参数Model，其有诸多参数决定登录时的各种逻辑，例如：
StpUtil.setLoginId(10001, new SaLoginModel()
StpUtil.login(10001, new SaLoginModel()
.setDevice("PC") // 此次登录的客户端设备标识, 用于[同端互斥登录]时指定此次登录的设备名称
.setIsLastingCookie(true) // 是否为持久Cookie（临时Cookie在浏览器关闭时会自动删除，持久Cookie在重新打开后依然存在）
.setTimeout(60 * 60 * 24 * 7) // 指定此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）

8
sa-token-doc/doc/use/token-style.md
View File

@ -55,13 +55,13 @@ import cn.dev33.satoken.action.SaTokenActionDefaultImpl;
public class MySaTokenAction extends SaTokenActionDefaultImpl {
// 重写token生成策略
@Override
public String createToken(Object loginId, String loginKey) {
public String createToken(Object loginId, String loginType) {
return SaTokenInsideUtil.getRandomString(60); // 随机60位字符串
}
}
```
2、再次调用 `StpUtil.setLoginId(10001)`方法进行登录，观察其生成的token样式:
2、再次调用 `StpUtil.login(10001)`方法进行登录，观察其生成的token样式:
``` html
gfuPSwZsnUhwgz08GTCH4wOgasWtc3odP4HLwXJ7NDGOximTvT4OlW19zeLH
```
@ -96,13 +96,13 @@ import cn.hutool.core.util.IdUtil;
public class MySaTokenAction extends SaTokenActionDefaultImpl {
// 重写token生成策略
@Override
public String createToken(Object loginId, String loginKey) {
public String createToken(Object loginId, String loginType) {
return IdUtil.getSnowflake(1, 1).nextIdStr(); // 以雪花算法生成token
}
}
```
3、再次调用 `StpUtil.setLoginId(10001)`方法进行登录，观察其生成的token样式:
3、再次调用 `StpUtil.login(10001)`方法进行登录，观察其生成的token样式:
``` html
1339604338175250432
```

2
sa-token-plugin/sa-token-quick-login/src/main/java/cn/dev33/satoken/quick/SaQuickBean.java
View File

@ -77,7 +77,7 @@ public class SaQuickBean implements WebMvcConfigurer {
e.printStackTrace();
}
// 抛出异常，不再继续执行
throw NotLoginException.newInstance(StpUtil.getLoginKey(), "");
throw NotLoginException.newInstance(StpUtil.getLoginType(), "");
}
}).

2
sa-token-plugin/sa-token-quick-login/src/main/java/cn/dev33/satoken/quick/web/SaQuickController.java
View File

@ -53,7 +53,7 @@ public class SaQuickController {
// 密码校验
SaQuickConfig config = SaQuickManager.getConfig();
if(name.equals(config.getName()) && pwd.equals(config.getPwd())) {
StpUtil.setLoginId(config.getName());
StpUtil.login(config.getName());
return getResult(200, "ok", StpUtil.getTokenInfo());
} else {
// 校验失败

26
sa-token-starter/sa-token-spring-boot-starter/src/test/java/com/pj/test/SaTokenSpringBootStarterTest.java
View File

@ -43,7 +43,7 @@ public class SaTokenSpringBootStarterTest {
@Test
public void testDoLogin() {
// 登录
StpUtil.setLoginId(10001);
StpUtil.login(10001);
Assert.assertTrue(StpUtil.isLogin());
Assert.assertNotNull(StpUtil.getTokenValue()); // token不为null
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001); // loginId=10001
@ -59,7 +59,7 @@ public class SaTokenSpringBootStarterTest {
// 测试：权限认证
@Test
public void testCheckPermission() {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// 权限认证
Assert.assertTrue(StpUtil.hasPermission("user-add"));
@ -72,7 +72,7 @@ public class SaTokenSpringBootStarterTest {
// 测试：角色认证
@Test
public void testCheckRole() {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// 角色认证
Assert.assertTrue(StpUtil.hasRole("admin"));
@ -84,13 +84,13 @@ public class SaTokenSpringBootStarterTest {
public void testKickOut() {
// 根据token踢人
StpUtil.setLoginId(10001);
StpUtil.login(10001);
Assert.assertTrue(StpUtil.isLogin());
StpUtil.logoutByTokenValue(StpUtil.getTokenValue());
Assert.assertFalse(StpUtil.isLogin());
// 根据账号id踢人
StpUtil.setLoginId(10001);
StpUtil.login(10001);
Assert.assertTrue(StpUtil.isLogin());
StpUtil.logoutByLoginId(10001);
Assert.assertFalse(StpUtil.isLogin());
@ -110,13 +110,13 @@ public class SaTokenSpringBootStarterTest {
// 封号后登陆 (会抛出 DisableLoginException 异常)
StpUtil.disable(10007, 200);
StpUtil.setLoginId(10007);
StpUtil.login(10007);
}
// 测试：Session会话
@Test
public void testSession() {
StpUtil.setLoginId(10001);
StpUtil.login(10001);
// Session 应该存在
Assert.assertNotNull(StpUtil.getSession(false));
@ -138,7 +138,7 @@ public class SaTokenSpringBootStarterTest {
@Test
public void testSwitch() {
// 登录
StpUtil.setLoginId(10001);
StpUtil.login(10001);
Assert.assertFalse(StpUtil.isSwitch());
Assert.assertEquals(StpUtil.getLoginIdAsLong(), 10001);
@ -157,11 +157,11 @@ public class SaTokenSpringBootStarterTest {
@Test
public void testSearchTokenValue() {
// 登录
StpUtil.setLoginId(10001);
StpUtil.setLoginId(10002);
StpUtil.setLoginId(10003);
StpUtil.setLoginId(10004);
StpUtil.setLoginId(10005);
StpUtil.login(10001);
StpUtil.login(10002);
StpUtil.login(10003);
StpUtil.login(10004);
StpUtil.login(10005);
// 查询
List<String> list = StpUtil.searchTokenValue("", 0, 10);

4
sa-token-starter/sa-token-spring-boot-starter/src/test/java/com/pj/test/satoken/StpInterfaceImpl.java
View File

@ -20,7 +20,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的权限码集合
*/
@Override
public List<String> getPermissionList(Object loginId, String loginKey) {
public List<String> getPermissionList(Object loginId, String loginType) {
return Arrays.asList("user*", "art-add", "art-delete", "art-update", "art-get");
}
@ -28,7 +28,7 @@ public class StpInterfaceImpl implements StpInterface {
* 返回一个账号所拥有的角色标识集合
*/
@Override
public List<String> getRoleList(Object loginId, String loginKey) {
public List<String> getRoleList(Object loginId, String loginType) {
return Arrays.asList("admin", "super-admin");
}