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

优化注释

Browse Source
This commit is contained in:
click33 2021-06-18 23:53:16 +08:00
parent c6d3cda4a4
commit a73adf6727
53 changed files with 801 additions and 568 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -23,7 +23,7 @@ import cn.dev33.satoken.temp.SaTempDefaultImpl;
import cn.dev33.satoken.util.SaFoxUtil;
/**
* 管理sa-token所有接口对象
* 管理 Sa-Token 所有接口对象
* @author kong
*
*/

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

@ -6,7 +6,7 @@ import java.util.List;
import cn.dev33.satoken.session.SaSession;
/**
* sa-token逻辑代理接口
* Sa-Token 逻辑代理接口
* <p>此接口将会代理框架内部的一些关键性逻辑，方便开发者进行按需重写</p>
* @author kong
*
@ -14,22 +14,22 @@ import cn.dev33.satoken.session.SaSession;
public interface SaTokenAction {
/**
* 根据一定的算法生成一个token
* 创建一个Token
* @param loginId 账号id
* @param loginType 账号类型
* @return 一个token
* @return token
*/
public String createToken(Object loginId, String loginType);
/**
* 根据 SessionId 创建一个 Session
* 创建一个Session
* @param sessionId Session的Id
* @return 创建后的Session
*/
public SaSession createSession(String sessionId);
/**
* 指定集合是否包含指定元素（模糊匹配）
* 判断：集合中是否包含指定元素（模糊匹配）
* @param list 集合
* @param element 元素
* @return 是否包含

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

@ -9,19 +9,20 @@ import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.annotation.SaCheckLogin;
import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.dev33.satoken.annotation.SaCheckRole;
import cn.dev33.satoken.annotation.SaCheckSafe;
import cn.dev33.satoken.session.SaSession;
import cn.dev33.satoken.util.SaFoxUtil;
import cn.dev33.satoken.util.SaTokenConsts;
/**
* 对 SaTokenAction 接口的默认实现
* Sa-Token 逻辑代理接口 [默认实现类]
* @author kong
*
*/
public class SaTokenActionDefaultImpl implements SaTokenAction {
/**
* 根据一定的算法生成一个token
* 创建一个Token
*/
@Override
public String createToken(Object loginId, String loginType) {
@ -56,7 +57,7 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
}
/**
* 根据 SessionId 创建一个 Session
* 创建一个Session
*/
@Override
public SaSession createSession(String sessionId) {
@ -64,11 +65,12 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
}
/**
* 指定集合是否包含指定元素（模糊匹配）
* 判断：集合中是否包含指定元素（模糊匹配）
*/
@Override
public boolean hasElement(List<String> list, String element) {
// 集合为空直接返回false
// 空集合直接返回false
if(list == null || list.size() == 0) {
return false;
}
@ -90,7 +92,7 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
}
/**
* 对一个Method对象进行注解权限校验（注解鉴权逻辑内部实现）
* 对一个Method对象进行注解检查（注解鉴权内部实现）
*/
@Override
public void checkMethodAnnotation(Method method) {
@ -125,6 +127,12 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
SaCheckPermission at = target.getAnnotation(SaCheckPermission.class);
SaManager.getStpLogic(at.type()).checkByAnnotation(at);
}
// 校验 @SaCheckSafe 注解
if(target.isAnnotationPresent(SaCheckSafe.class)) {
SaCheckSafe at = target.getAnnotation(SaCheckSafe.class);
SaManager.getStpLogic(null).checkByAnnotation(at);
}
}
}

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

@ -6,8 +6,8 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 登录校验：标注在一个方法上，当前会话必须已经登录才能进入该方法
* <p> 可标注在类上，其效果等同于标注在此类的所有方法上
* 登录校验：只有登录之后才能进入该方法
* <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上）
* @author kong
*
*/

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

@ -6,8 +6,8 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 权限校验：标注在一个方法上，当前会话必须具有指定权限才能进入该方法
* <p> 可标注在类上，其效果等同于标注在此类的所有方法上
* 权限校验：必须具有指定权限才能进入该方法
* <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上）
* @author kong
*
*/

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

@ -6,8 +6,8 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 角色校验：标注在一个方法上，当前会话必须具有指定角色标识才能进入该方法
* <p> 可标注在类上，其效果等同于标注在此类的所有方法上
* 角色校验：必须具有指定角色标识才能进入该方法
* <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上）
* @author kong
*
*/

18
sa-token-core/src/main/java/cn/dev33/satoken/annotation/SaCheckSafe.java Normal file
View File

@ -0,0 +1,18 @@
package cn.dev33.satoken.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 二级认证校验：必须二级认证之后才能进入该方法
* <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上）
* @author kong
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD, ElementType.TYPE })
public @interface SaCheckSafe {
}

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

@ -1,7 +1,7 @@
package cn.dev33.satoken.config;
/**
* sa-token 配置类 Model
* Sa-Token 配置类 Model
* <p>
* 你可以通过yml、properties、java代码等形式配置本类参数，具体请查阅官方文档: http://sa-token.dev33.cn/
*

2
sa-token-core/src/main/java/cn/dev33/satoken/config/SaTokenConfigFactory.java
View File

@ -8,7 +8,7 @@ import java.util.Map;
import java.util.Properties;
/**
* sa-token配置文件的构建工厂类
* Sa-Token配置文件的构建工厂类
* <p>
* 只有在非IOC环境下才会用到此类
*

2
sa-token-core/src/main/java/cn/dev33/satoken/context/SaTokenContextForThreadLocal.java
View File

@ -5,7 +5,7 @@ import cn.dev33.satoken.context.model.SaResponse;
import cn.dev33.satoken.context.model.SaStorage;
/**
* 上下文环境 [ThreadLocal版本]
* Sa-Token 上下文处理器 [ThreadLocal版本]
* @author kong
*
*/

22
sa-token-core/src/main/java/cn/dev33/satoken/context/SaTokenContextForThreadLocalStorage.java
View File

@ -6,19 +6,19 @@ import cn.dev33.satoken.context.model.SaStorage;
import cn.dev33.satoken.exception.SaTokenException;
/**
* 基于ThreadLocal的上下文对象存储器
* Sa-Token 上下文处理器 [ThreadLocal版本] ---- 对象存储器
* @author kong
*
*/
public class SaTokenContextForThreadLocalStorage {
/**
* 基于 ThreadLocal 的上下文
* 基于 ThreadLocal 的 [Box存储器]
*/
static ThreadLocal<Box> boxThreadLocal = new InheritableThreadLocal<Box>();
public static ThreadLocal<Box> boxThreadLocal = new InheritableThreadLocal<Box>();
/**
* 初始化 [容器]
* 初始化 [Box存储器]
* @param request {@link SaRequest}
* @param response {@link SaResponse}
* @param storage {@link SaStorage}
@ -29,14 +29,14 @@ public class SaTokenContextForThreadLocalStorage {
};
/**
* 清除 [容器]
* 清除 [Box存储器]
*/
public static void clearBox() {
boxThreadLocal.remove();
};
/**
* 获取 [容器]
* 获取 [Box存储器]
* @return see note
*/
public static Box getBox() {
@ -44,7 +44,7 @@ public class SaTokenContextForThreadLocalStorage {
};
/**
* 获取 [容器], 如果为空则抛出异常
* 获取 [Box存储器], 如果为空则抛出异常
* @return see note
*/
public static Box getBoxNotNull() {
@ -56,7 +56,7 @@ public class SaTokenContextForThreadLocalStorage {
};
/**
* 在 [上下文容器] 获取 [Request] 对象
* 在 [Box存储器] 获取 [Request] 对象
*
* @return see note
*/
@ -65,7 +65,7 @@ public class SaTokenContextForThreadLocalStorage {
}
/**
* 在 [上下文容器] 获取 [Response] 对象
* 在 [Box存储器] 获取 [Response] 对象
*
* @return see note
*/
@ -74,7 +74,7 @@ public class SaTokenContextForThreadLocalStorage {
}
/**
* 在 [上下文容器] 获取 [存储器] 对象
* 在 [Box存储器] 获取 [存储器] 对象
*
* @return see note
*/
@ -84,7 +84,7 @@ public class SaTokenContextForThreadLocalStorage {
/**
* 临时内部类，存储三个对象
* 临时内部类，用于存储[request、response、storage]三个对象
* @author kong
*/
/**

10
sa-token-core/src/main/java/cn/dev33/satoken/context/model/SaCookie.java
View File

@ -1,10 +0,0 @@
package cn.dev33.satoken.context.model;
/**
* Cookie 包装类
* @author kong
*
*/
public class SaCookie {
}

2
sa-token-core/src/main/java/cn/dev33/satoken/context/model/SaRequest.java
View File

@ -1,7 +1,7 @@
package cn.dev33.satoken.context.model;
/**
* Request包装类
* Request 包装类
* @author kong
*
*/

58
sa-token-core/src/main/java/cn/dev33/satoken/dao/SaTokenDao.java
View File

@ -5,7 +5,7 @@ import java.util.List;
import cn.dev33.satoken.session.SaSession;
/**
* sa-token持久层的接口
* Sa-Token持久层接口
* @author kong
*/
public interface SaTokenDao {
@ -17,101 +17,101 @@ public interface SaTokenDao {
public static final long NOT_VALUE_EXPIRE = -2;
// --------------------- token相关 ---------------------
// --------------------- 字符串读写 ---------------------
/**
* 根据key获取value，如果没有，则返回空
* 获取Value，如无返空
* @param key 键名称
* @return value
*/
public String get(String key);
/**
* 写入指定key-value键值对，并设定过期时间 (单位: 秒)
* 写入Value，并设定存活时间 (单位: 秒)
* @param key 键名称
* @param value 值
* @param timeout 过期时间 (单位: 秒)
* @param timeout 过期时间
*/
public void set(String key, String value, long timeout);
/**
* 修改指定key-value键值对 (过期时间不变)
* 更新Value (过期时间不变)
* @param key 键名称
* @param value 值
*/
public void update(String key, String value);
/**
* 删除一个指定的key
* 删除Value
* @param key 键名称
*/
public void delete(String key);
/**
* 获取指定key的剩余存活时间 (单位: 秒)
* 获取Value的剩余存活时间 (单位: 秒)
* @param key 指定key
* @return 这个key的剩余存活时间
*/
public long getTimeout(String key);
/**
* 修改指定key的剩余存活时间 (单位: 秒)
* 修改Value的剩余存活时间 (单位: 秒)
* @param key 指定key
* @param timeout 过期时间
*/
public void updateTimeout(String key, long timeout);
// --------------------- Object相关 ---------------------
// --------------------- 对象读写 ---------------------
/**
* 根据key获取Object，如果没有，则返回空
* 获取Object，如无返空
* @param key 键名称
* @return object
*/
public Object getObject(String key);
/**
* 写入指定键值对，并设定过期时间 (单位: 秒)
* 写入Object，并设定存活时间 (单位: 秒)
* @param key 键名称
* @param object 值
* @param timeout 过期时间 (单位: 秒)
* @param timeout 存活时间
*/
public void setObject(String key, Object object, long timeout);
/**
* 修改指定键值对 (过期时间不变)
* 更新Object (过期时间不变)
* @param key 键名称
* @param object 值
*/
public void updateObject(String key, Object object);
/**
* 删除一个指定的Object
* 删除Object
* @param key 键名称
*/
public void deleteObject(String key);
/**
* 获取指定key的剩余存活时间 (单位: 秒)
* 获取Object的剩余存活时间 (单位: 秒)
* @param key 指定key
* @return 这个key的剩余存活时间
*/
public long getObjectTimeout(String key);
/**
* 修改指定key的剩余存活时间 (单位: 秒)
* 修改Object的剩余存活时间 (单位: 秒)
* @param key 指定key
* @param timeout 过期时间
*/
public void updateObjectTimeout(String key, long timeout);
// --------------------- Session相关 ---------------------
// --------------------- Session读写 ---------------------
/**
* 根据指定key的Session，如果没有，则返回空
* @param sessionId 键名称
* 获取Session，如无返空
* @param sessionId sessionId
* @return SaSession
*/
public default SaSession getSession(String sessionId) {
@ -119,8 +119,8 @@ public interface SaTokenDao {
}
/**
* 将指定Session持久化
* @param session 要保存的session对象
* 写入Session，并设定存活时间 (单位: 秒)
* @param session 要保存的Session对象
* @param timeout 过期时间 (单位: 秒)
*/
public default void setSession(SaSession session, long timeout) {
@ -128,7 +128,7 @@ public interface SaTokenDao {
}
/**
* 更新指定session
* 更新Session
* @param session 要更新的session对象
*/
public default void updateSession(SaSession session) {
@ -136,7 +136,7 @@ public interface SaTokenDao {
}
/**
* 删除一个指定的session
* 删除Session
* @param sessionId sessionId
*/
public default void deleteSession(String sessionId) {
@ -144,17 +144,17 @@ public interface SaTokenDao {
}
/**
* 获取指定SaSession的剩余存活时间 (单位: 秒)
* @param sessionId 指定SaSession
* @return 这个SaSession的剩余存活时间 (单位: 秒)
* 获取Session剩余存活时间 (单位: 秒)
* @param sessionId 指定Session
* @return 这个Session的剩余存活时间
*/
public default long getSessionTimeout(String sessionId) {
return getObjectTimeout(sessionId);
}
/**
* 修改指定SaSession的剩余存活时间 (单位: 秒)
* @param sessionId sessionId
* 修改Session剩余存活时间 (单位: 秒)
* @param sessionId 指定Session
* @param timeout 过期时间
*/
public default void updateSessionTimeout(String sessionId, long timeout) {

2
sa-token-core/src/main/java/cn/dev33/satoken/dao/SaTokenDaoDefaultImpl.java
View File

@ -10,7 +10,7 @@ import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.util.SaFoxUtil;
/**
* sa-token持久层默认的实现类 , 基于内存Map
* Sa-Token持久层接口 [默认实现类, 基于内存Map]
* @author kong
*
*/

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

@ -60,7 +60,7 @@ public class DisableLoginException extends SaTokenException {
}
/**
* 构造方法创建一个
* 一个异常：代表账号已被封禁
*
* @param loginType 账号类型
* @param loginId 被封禁的账号id
@ -73,6 +73,4 @@ public class DisableLoginException extends SaTokenException {
this.disableTime = disableTime;
}
}

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

@ -4,7 +4,7 @@ import java.util.Arrays;
import java.util.List;
/**
* 一个异常：代表用户没有登录
* 一个异常：代表会话未能通过登录认证
* @author kong
*/
public class NotLoginException extends SaTokenException {

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

@ -3,7 +3,7 @@ package cn.dev33.satoken.exception;
import cn.dev33.satoken.stp.StpUtil;
/**
* 没有指定权限码，抛出的异常
* 一个异常：代表会话未能通过权限认证
*
* @author kong
*

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

@ -3,7 +3,7 @@ package cn.dev33.satoken.exception;
import cn.dev33.satoken.stp.StpUtil;
/**
* 没有指定角色标识，抛出的异常
* 一个异常：代表会话未能通过角色认证
*
* @author kong
*

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

@ -0,0 +1,25 @@
package cn.dev33.satoken.exception;
/**
* 一个异常：代表会话未能通过二级认证
*
* @author kong
*/
public class NotSafeException extends SaTokenException {
/**
* 序列化版本号
*/
private static final long serialVersionUID = 6806129545290130144L;
/** 异常提示语 */
public static final String BE_MESSAGE = "二级认证失败";
/**
* 一个异常：代表会话未通过二级认证
*/
public NotSafeException() {
super(BE_MESSAGE);
}
}

4
sa-token-core/src/main/java/cn/dev33/satoken/exception/SaTokenException.java
View File

@ -1,8 +1,8 @@
package cn.dev33.satoken.exception;
/**
* sa-token框架内部逻辑发生错误抛出的异常
* (自定义此异常可方便开发者在做全局异常处理时分辨异常类型)
* Sa-Token框架内部逻辑发生错误抛出的异常
* (自定义此异常方便开发者在做全局异常处理时分辨异常类型)
*
* @author kong
*

2
sa-token-core/src/main/java/cn/dev33/satoken/filter/SaFilterAuthStrategy.java
View File

@ -1,7 +1,7 @@
package cn.dev33.satoken.filter;
/**
* sa-token全局过滤器-认证策略
* Sa-Token全局过滤器-认证策略
* @author kong
*
*/

2
sa-token-core/src/main/java/cn/dev33/satoken/filter/SaFilterErrorStrategy.java
View File

@ -1,7 +1,7 @@
package cn.dev33.satoken.filter;
/**
* sa-token全局过滤器-异常处理策略
* Sa-Token全局过滤器-异常处理策略
* @author kong
*
*/

2
sa-token-core/src/main/java/cn/dev33/satoken/fun/IsRunFunction.java
View File

@ -1,7 +1,7 @@
package cn.dev33.satoken.fun;
/**
* 根据boolean变量，决定是否执行一个函数
* 根据Boolean变量，决定是否执行一个函数
*
* @author kong
*

3
sa-token-core/src/main/java/cn/dev33/satoken/fun/SaRetFunction.java
View File

@ -5,14 +5,13 @@ package cn.dev33.satoken.fun;
* @author kong
*
*/
@FunctionalInterface
public interface SaRetFunction {
/**
* 执行的方法
* @return 返回值
*/
public Object run();
}

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

@ -3,7 +3,7 @@ package cn.dev33.satoken.listener;
import cn.dev33.satoken.stp.SaLoginModel;
/**
* Sa-Token的侦听器
* Sa-Token 侦听器
* <p> 你可以通过实现此接口在用户登陆、退出等关键性操作时进行一些AOP操作
* @author kong
*

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

@ -4,7 +4,7 @@ import cn.dev33.satoken.context.model.SaRequest;
import cn.dev33.satoken.context.model.SaResponse;
/**
* 执行验证方法的辅助类
* 路由拦截器验证方法Lambda
*
* @author kong
*

28
sa-token-core/src/main/java/cn/dev33/satoken/router/SaRouter.java
View File

@ -10,7 +10,7 @@ import cn.dev33.satoken.fun.IsRunFunction;
import cn.dev33.satoken.fun.SaFunction;
/**
* 对路由匹配符相关操作的封装工具类
* 路由匹配操作工具类
* @author kong
*
*/
@ -19,9 +19,9 @@ public class SaRouter {
// -------------------- 路由匹配相关 --------------------
/**
* 校验指定路由匹配符是否可以匹配成功指定路径
* 路由匹配
* @param pattern 路由匹配符
* @param path 需要匹配的路径
* @param path 被匹配的路由
* @return 是否匹配成功
*/
public static boolean isMatch(String pattern, String path) {
@ -29,9 +29,9 @@ public class SaRouter {
}
/**
* 校验指定路由匹配符是否可以匹配成功指定路径
* @param patterns 路由匹配符
* @param path 需要匹配的路径集合
* 路由匹配
* @param patterns 路由匹配符集合
* @param path 被匹配的路由
* @return 是否匹配成功
*/
public static boolean isMatch(List<String> patterns, String path) {
@ -44,7 +44,7 @@ public class SaRouter {
}
/**
* 校验指定路由匹配符是否可以匹配成功当前URI
* 路由匹配 (使用当前URI)
* @param pattern 路由匹配符
* @return 是否匹配成功
*/
@ -53,8 +53,8 @@ public class SaRouter {
}
/**
* 校验指定路由匹配符是否可以匹配成功当前URI
* @param patterns 路由匹配符
* 路由匹配 (使用当前URI)
* @param patterns 路由匹配符集合
* @return 是否匹配成功
*/
public static boolean isMatchCurrURI(List<String> patterns) {
@ -65,7 +65,7 @@ public class SaRouter {
// -------------------- 执行相关 --------------------
/**
* 使用路由匹配符与当前URI执行匹配，如果匹配成功则执行验证函数
* 路由匹配，如果匹配成功则执行认证函数
* @param pattern 路由匹配符
* @param function 要执行的方法
*/
@ -76,7 +76,7 @@ public class SaRouter {
}
/**
* 使用路由匹配符与当前URI执行匹配 (并指定排除匹配符)，如果匹配成功则执行验证函数
* 路由匹配 (并指定排除匹配符)，如果匹配成功则执行认证函数
* @param pattern 路由匹配符
* @param excludePattern 要排除的路由匹配符
* @param function 要执行的方法
@ -90,7 +90,7 @@ public class SaRouter {
}
/**
* 使用路由匹配符集合与当前URI执行匹配，如果匹配成功则执行验证函数
* 路由匹配，如果匹配成功则执行认证函数
* @param patterns 路由匹配符集合
* @param function 要执行的方法
*/
@ -101,7 +101,7 @@ public class SaRouter {
}
/**
* 使用路由匹配符集合与当前URI执行匹配 (并指定排除匹配符)，如果匹配成功则执行验证函数
* 路由匹配 (并指定排除匹配符)，如果匹配成功则执行认证函数
* @param patterns 路由匹配符集合
* @param excludePatterns 要排除的路由匹配符集合
* @param function 要执行的方法
@ -116,7 +116,7 @@ public class SaRouter {
/**
* 使用路由匹配符集合与当前URI执行匹配，如果匹配成功则执行验证函数
* 路由匹配，如果匹配成功则执行认证函数
* @param patterns 路由匹配符集合
* @return 匹配结果包装对象
*/

3
sa-token-core/src/main/java/cn/dev33/satoken/secure/SaBase64Util.java
View File

@ -4,7 +4,7 @@ import java.io.UnsupportedEncodingException;
import java.util.Base64;
/**
* Base64工具类
* Sa-Token Base64工具类
* @author kong
*
*/
@ -57,5 +57,4 @@ public class SaBase64Util {
}
}
}

2
sa-token-core/src/main/java/cn/dev33/satoken/secure/SaSecureUtil.java
View File

@ -26,7 +26,7 @@ import javax.crypto.spec.SecretKeySpec;
import cn.dev33.satoken.exception.SaTokenException;
/**
* sa-token 常见加密算法工具类
* Sa-Token 常见加密算法工具类
*
* @author kong
*

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

@ -36,7 +36,11 @@ public class SaSession implements Serializable {
* 构建一个Session对象
*/
public SaSession() {
this(null);
/*
* 当Session从Redis中反序列化取出时，框架会误以为创建了新的Session，
* 因此此处不可以调用this(null); 避免监听器收到错误的通知
*/
// this(null);
}
/**
@ -147,100 +151,6 @@ public class SaSession implements Serializable {
}
}
// ----------------------- 存取值
/**
* 写入一个值
*
* @param key 名称
* @param value 值
*/
public void setAttribute(String key, Object value) {
dataMap.put(key, value);
update();
}
/**
* 取出一个值
*
* @param key 名称
* @return 值
*/
public Object getAttribute(String key) {
return dataMap.get(key);
}
/**
* 取值，并指定取不到值时的默认值
*
* @param key 名称
* @param defaultValue 取不到值的时候返回的默认值
* @return value
*/
public Object getAttribute(String key, Object defaultValue) {
Object value = getAttribute(key);
if (value != null) {
return value;
}
return defaultValue;
}
/**
* 移除一个值
*
* @param key 要移除的值的名字
*/
public void removeAttribute(String key) {
dataMap.remove(key);
update();
}
/**
* 清空所有值
*/
public void clearAttribute() {
dataMap.clear();
update();
}
/**
* 是否含有指定key
*
* @param key 是否含有指定值
* @return 是否含有
*/
public boolean containsAttribute(String key) {
return dataMap.containsKey(key);
}
/**
* 返回当前session会话所有key
*
* @return 所有值的key列表
*/
public Set<String> attributeKeys() {
return dataMap.keySet();
}
/**
* 获取数据挂载集合（如果更新map里的值，请调用session.update()方法避免产生脏数据 ）
*
* @return 返回底层储存值的map对象
*/
public Map<String, Object> getDataMap() {
return dataMap;
}
/**
* 写入数据集合 (不改变底层对象，只将此dataMap所有数据进行替换)
* @param dataMap 数据集合
*/
public void refreshDataMap(Map<String, Object> dataMap) {
this.dataMap.clear();
this.dataMap.putAll(dataMap);
this.update();
}
// ----------------------- 一些操作
@ -422,6 +332,15 @@ public class SaSession implements Serializable {
return SaFoxUtil.getValueByType(value, cs);
}
/**
* 返回当前Session的所有key
*
* @return 所有值的key列表
*/
public Set<String> keys() {
return dataMap.keySet();
}
// ---- 其他
/**
* 写值
@ -468,7 +387,34 @@ public class SaSession implements Serializable {
update();
return this;
}
/**
* 清空所有值
*/
public void clear() {
dataMap.clear();
update();
}
/**
* 获取数据挂载集合（如果更新map里的值，请调用session.update()方法避免产生脏数据 ）
*
* @return 返回底层储存值的map对象
*/
public Map<String, Object> getDataMap() {
return dataMap;
}
/**
* 写入数据集合 (不改变底层对象，只将此dataMap所有数据进行替换)
* @param dataMap 数据集合
*/
public void refreshDataMap(Map<String, Object> dataMap) {
this.dataMap.clear();
this.dataMap.putAll(dataMap);
this.update();
}
// --------- 工具方法
@ -503,4 +449,96 @@ public class SaSession implements Serializable {
// ----------------------- 旧API
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.set(key) </h1>
* 写入一个值
*
* @param key 名称
* @param value 值
*/
@Deprecated
public void setAttribute(String key, Object value) {
dataMap.put(key, value);
update();
}
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.get(key) </h1>
* 取出一个值
*
* @param key 名称
* @return 值
*/
@Deprecated
public Object getAttribute(String key) {
return dataMap.get(key);
}
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.get(key, defaultValue) </h1>
* 取值，并指定取不到值时的默认值
*
* @param key 名称
* @param defaultValue 取不到值的时候返回的默认值
* @return value
*/
@Deprecated
public Object getAttribute(String key, Object defaultValue) {
Object value = getAttribute(key);
if (value != null) {
return value;
}
return defaultValue;
}
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.delete(key) </h1>
* 移除一个值
*
* @param key 要移除的值的名字
*/
@Deprecated
public void removeAttribute(String key) {
dataMap.remove(key);
update();
}
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.clear() </h1>
* 清空所有值
*/
@Deprecated
public void clearAttribute() {
dataMap.clear();
update();
}
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.has(key) </h1>
* 是否含有指定key
*
* @param key 是否含有指定值
* @return 是否含有
*/
@Deprecated
public boolean containsAttribute(String key) {
return dataMap.containsKey(key);
}
/**
* <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.keys() </h1>
* 返回当前session会话所有key
*
* @return 所有值的key列表
*/
@Deprecated
public Set<String> attributeKeys() {
return dataMap.keySet();
}
}

10
sa-token-core/src/main/java/cn/dev33/satoken/session/SaSessionCustomUtil.java
View File

@ -11,12 +11,12 @@ import cn.dev33.satoken.SaManager;
public class SaSessionCustomUtil {
/**
* 添加上指定前缀，防止恶意伪造session
* 添加上指定前缀，防止恶意伪造Session
*/
public static String sessionKey = "custom";
/**
* 组织一下自定义Session的id
* 拼接Key: 自定义Session的Id
*
* @param sessionId 会话id
* @return sessionId
@ -26,9 +26,9 @@ public class SaSessionCustomUtil {
}
/**
* 验证指定key的Session是否存在
* 指定key的Session是否存在
*
* @param sessionId session的id
* @param sessionId Session的id
* @return 是否存在
*/
public static boolean isExists(String sessionId) {
@ -62,7 +62,7 @@ public class SaSessionCustomUtil {
}
/**
* 删除指定key的session
* 删除指定key的Session
*
* @param sessionId 指定key
*/

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

@ -3,7 +3,7 @@ package cn.dev33.satoken.session;
import java.io.Serializable;
/**
* token签名 Model
* Token签名 Model
*
* 挂在到SaSession上的token签名
*

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

@ -30,14 +30,14 @@ public class SaLoginModel {
/**
* @return device
* @return 参考 {@link #device}
*/
public String getDevice() {
return device;
}
/**
* @param device 要设置的 device
* @param device 参考 {@link #device}
* @return 对象自身
*/
public SaLoginModel setDevice(String device) {
@ -46,14 +46,14 @@ public class SaLoginModel {
}
/**
* @return isLastingCookie
* @return 参考 {@link #isLastingCookie}
*/
public Boolean getIsLastingCookie() {
return isLastingCookie;
}
/**
* @param isLastingCookie 要设置的 isLastingCookie
* @param isLastingCookie 参考 {@link #isLastingCookie}
* @return 对象自身
*/
public SaLoginModel setIsLastingCookie(Boolean isLastingCookie) {
@ -62,14 +62,14 @@ public class SaLoginModel {
}
/**
* @return timeout
* @return 参考 {@link #timeout}
*/
public Long getTimeout() {
return timeout;
}
/**
* @param timeout 要设置的 timeout
* @param timeout 参考 {@link #timeout}
* @return 对象自身
*/
public SaLoginModel setTimeout(long timeout) {
@ -79,7 +79,7 @@ public class SaLoginModel {
/**
* @return cookie时长
* @return Cookie时长
*/
public int getCookieTimeout() {
if(isLastingCookie == false) {
@ -91,7 +91,6 @@ public class SaLoginModel {
return (int)(long)timeout;
}
/**
* 构建对象，初始化默认值
* @return 对象自身
@ -118,7 +117,6 @@ public class SaLoginModel {
return this;
}
/**
* 静态方法获取一个 SaLoginModel 对象
* @return SaLoginModel 对象
@ -127,7 +125,6 @@ public class SaLoginModel {
return new SaLoginModel();
}
/**
* toString
*/
@ -136,7 +133,4 @@ public class SaLoginModel {
return "SaLoginModel [device=" + device + ", isLastingCookie=" + isLastingCookie + ", timeout=" + timeout + "]";
}
}

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

@ -1,7 +1,7 @@
package cn.dev33.satoken.stp;
/**
* token信息Model: 用来描述一个token的常用参数
* Token信息Model: 用来描述一个Token的常用参数
*
* @author kong
*
@ -38,6 +38,11 @@ public class SaTokenInfo {
/** 登录设备标识 */
public String loginDevice;
/** 自定义数据 */
public String tag;
/**
* @return token名称
*/
@ -178,6 +183,20 @@ public class SaTokenInfo {
this.loginDevice = loginDevice;
}
/**
* @return 自定义数据
*/
public String getTag() {
return tag;
}
/**
* @param tag 自定义数据
*/
public void setTag(String tag) {
this.tag = tag;
}
/**
* toString
*/
@ -186,7 +205,10 @@ public class SaTokenInfo {
return "SaTokenInfo [tokenName=" + tokenName + ", tokenValue=" + tokenValue + ", isLogin=" + isLogin
+ ", loginId=" + loginId + ", loginType=" + loginType + ", tokenTimeout=" + tokenTimeout
+ ", sessionTimeout=" + sessionTimeout + ", tokenSessionTimeout=" + tokenSessionTimeout
+ ", tokenActivityTimeout=" + tokenActivityTimeout + ", loginDevice=" + loginDevice + "]";
+ ", tokenActivityTimeout=" + tokenActivityTimeout + ", loginDevice=" + loginDevice + ", tag=" + tag
+ "]";
}
}

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

@ -10,7 +10,7 @@ import java.util.List;
public interface StpInterface {
/**
* 返回指定 LoginId 所拥有的权限码集合
* 返回指定账号id所拥有的权限码集合
*
* @param loginId 账号id
* @param loginType 账号类型
@ -19,7 +19,7 @@ public interface StpInterface {
public List<String> getPermissionList(Object loginId, String loginType);
/**
* 返回指定loginId所拥有的角色标识集合
* 返回指定账号id所拥有的角色标识集合
*
* @param loginId 账号id
* @param loginType 账号类型

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

@ -4,7 +4,7 @@ import java.util.ArrayList;
import java.util.List;
/**
* 对StpInterface接口默认的实现类
* 对 {@link StpInterface} 接口默认的实现类
* <p>
* 如果开发者没有实现StpInterface接口，则使用此默认实现
*

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

@ -9,6 +9,7 @@ import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.annotation.SaCheckLogin;
import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.dev33.satoken.annotation.SaCheckRole;
import cn.dev33.satoken.annotation.SaCheckSafe;
import cn.dev33.satoken.annotation.SaMode;
import cn.dev33.satoken.config.SaTokenConfig;
import cn.dev33.satoken.context.SaHolder;
@ -20,6 +21,7 @@ import cn.dev33.satoken.exception.DisableLoginException;
import cn.dev33.satoken.exception.NotLoginException;
import cn.dev33.satoken.exception.NotPermissionException;
import cn.dev33.satoken.exception.NotRoleException;
import cn.dev33.satoken.exception.NotSafeException;
import cn.dev33.satoken.fun.SaFunction;
import cn.dev33.satoken.session.SaSession;
import cn.dev33.satoken.session.TokenSign;
@ -66,7 +68,7 @@ public class StpLogic {
}
// =================== 获取token 相关 ===================
// ------------------- 获取token 相关 -------------------
/**
* 返回token名称
@ -77,7 +79,7 @@ public class StpLogic {
}
/**
* 创建一个tokenValue
* 创建一个TokenValue
* @param loginId loginId
* @return 生成的tokenValue
*/
@ -86,14 +88,16 @@ public class StpLogic {
}
/**
* 在当前会话写入当前tokenValue
* 在当前会话写入当前TokenValue
* @param tokenValue token值
* @param cookieTimeout Cookie存活时间(秒)
*/
public void setTokenValue(String tokenValue, int cookieTimeout){
SaTokenConfig config = getConfig();
// 将token保存到[存储器]里
SaStorage storage = SaHolder.getStorage();
// 判断是否配置了token前缀
String tokenPrefix = config.getTokenPrefix();
if(SaFoxUtil.isEmpty(tokenPrefix)) {
@ -111,7 +115,7 @@ public class StpLogic {
}
/**
* 获取当前tokenValue
* 获取当前TokenValue
* @return 当前tokenValue
*/
public String getTokenValue(){
@ -155,7 +159,7 @@ public class StpLogic {
}
/**
* 获取当前会话的token信息
* 获取当前会话的Token信息
* @return token信息
*/
public SaTokenInfo getTokenInfo() {
@ -174,7 +178,7 @@ public class StpLogic {
}
// =================== 登录相关操作 ===================
// ------------------- 登录相关操作 -------------------
// 登录与注销
@ -279,7 +283,7 @@ public class StpLogic {
}
/**
* 当前会话注销登录
* 会话注销
*/
public void logout() {
// 如果连token都没有，那么无需执行任何操作
@ -295,7 +299,7 @@ public class StpLogic {
}
/**
* 指定token的会话注销登录
* 会话注销，根据指定Token
* @param tokenValue 指定token
*/
public void logoutByTokenValue(String tokenValue) {
@ -327,7 +331,7 @@ public class StpLogic {
}
/**
* 指定账号id的会话注销登录（踢人下线）
* 会话注销，根据账号id （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
* @param loginId 账号id
*/
@ -336,7 +340,7 @@ public class StpLogic {
}
/**
* 指定账号id指定设备的会话注销登录（踢人下线）
* 会话注销，根据账号id & 设备标识 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
* @param loginId 账号id
* @param device 设备标识 (填null代表所有注销设备)
@ -368,54 +372,10 @@ public class StpLogic {
session.logoutByTokenSignCountToZero();
}
/**
* 封禁指定账号
* <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常
* @param loginId 指定账号id
* @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public void disable(Object loginId, long disableTime) {
// 标注为已被封禁
SaManager.getSaTokenDao().set(splicingKeyDisable(loginId), DisableLoginException.BE_VALUE, disableTime);
// $$ 通知监听器
SaManager.getSaTokenListener().doDisable(loginType, loginId, disableTime);
}
/**
* 指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
* @param loginId 账号id
* @return see note
*/
public boolean isDisable(Object loginId) {
return SaManager.getSaTokenDao().get(splicingKeyDisable(loginId)) != null;
}
/**
* 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
* @param loginId 账号id
* @return see note
*/
public long getDisableTime(Object loginId) {
return SaManager.getSaTokenDao().getTimeout(splicingKeyDisable(loginId));
}
/**
* 解封指定账号
* @param loginId 账号id
*/
public void untieDisable(Object loginId) {
SaManager.getSaTokenDao().delete(splicingKeyDisable(loginId));
// $$ 通知监听器
SaManager.getSaTokenListener().doUntieDisable(loginType, loginId);
}
// 查询相关
/**
* 获取当前会话是否已经登录
* 当前会话是否已经登录
* @return 是否已登录
*/
public boolean isLogin() {
@ -472,7 +432,7 @@ public class StpLogic {
}
/**
* 获取当前会话登录id, 如果未登录，则返回默认值
* 获取当前会话账号id, 如果未登录，则返回默认值
* @param <T> 返回类型
* @param defaultValue 默认值
* @return 登录id
@ -498,7 +458,7 @@ public class StpLogic {
}
/**
* 获取当前会话登录id, 如果未登录，则返回null
* 获取当前会话账号id, 如果未登录，则返回null
* @return 账号id
*/
public Object getLoginIdDefaultNull() {
@ -525,7 +485,7 @@ public class StpLogic {
}
/**
* 获取当前会话登录id, 并转换为String
* 获取当前会话账号id, 并转换为String类型
* @return 账号id
*/
public String getLoginIdAsString() {
@ -533,7 +493,7 @@ public class StpLogic {
}
/**
* 获取当前会话登录id, 并转换为int
* 获取当前会话账号id, 并转换为int类型
* @return 账号id
*/
public int getLoginIdAsInt() {
@ -541,7 +501,7 @@ public class StpLogic {
}
/**
* 获取当前会话登录id, 并转换为long
* 获取当前会话账号id, 并转换为long类型
* @return 账号id
*/
public long getLoginIdAsLong() {
@ -549,9 +509,9 @@ public class StpLogic {
}
/**
* 获取指定token对应的登录id，如果未登录，则返回 null
* 获取指定Token对应的账号id，如果未登录，则返回 null
* @param tokenValue token
* @return 登录id
* @return 账号id
*/
public Object getLoginIdByToken(String tokenValue) {
if(tokenValue == null) {
@ -561,22 +521,22 @@ public class StpLogic {
}
/**
* 获取指定token对应的登录id (不做任何特殊处理)
* 获取指定Token对应的账号id (不做任何特殊处理)
* @param tokenValue token值
* @return loginId
* @return 账号id
*/
public String getLoginIdNotHandle(String tokenValue) {
return SaManager.getSaTokenDao().get(splicingKeyTokenValue(tokenValue));
}
// =================== session相关 ===================
// ------------------- Session相关 -------------------
/**
* 获取指定key的session, 如果session尚未创建，isCreate=是否新建并返回
* @param sessionId sessionId
* 获取指定key的Session, 如果Session尚未创建，isCreate=是否新建并返回
* @param sessionId SessionId
* @param isCreate 是否新建
* @return session对象
* @return Session对象
*/
public SaSession getSessionBySessionId(String sessionId, boolean isCreate) {
SaSession session = SaManager.getSaTokenDao().getSession(sessionId);
@ -588,76 +548,76 @@ public class StpLogic {
}
/**
* 获取指定key的session, 如果session尚未创建，则返回null
* @param sessionId sessionId
* @return session对象
* 获取指定key的Session, 如果Session尚未创建，则返回null
* @param sessionId SessionId
* @return Session对象
*/
public SaSession getSessionBySessionId(String sessionId) {
return getSessionBySessionId(sessionId, false);
}
/**
* 获取指定loginId的session, 如果session尚未创建，isCreate=是否新建并返回
* 获取指定账号id的Session, 如果Session尚未创建，isCreate=是否新建并返回
* @param loginId 账号id
* @param isCreate 是否新建
* @return SaSession
* @return Session对象
*/
public SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
return getSessionBySessionId(splicingKeySession(loginId), isCreate);
}
/**
* 获取指定loginId的session，如果session尚未创建，则新建并返回
* 获取指定账号id的Session，如果Session尚未创建，则新建并返回
* @param loginId 账号id
* @return session会话
* @return Session对象
*/
public SaSession getSessionByLoginId(Object loginId) {
return getSessionByLoginId(loginId, true);
}
/**
* 获取当前会话的session, 如果session尚未创建，isCreate=是否新建并返回
* 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回
* @param isCreate 是否新建
* @return 当前会话的session
* @return Session对象
*/
public SaSession getSession(boolean isCreate) {
return getSessionByLoginId(getLoginId(), isCreate);
}
/**
* 获取当前会话的session，如果session尚未创建，则新建并返回
* @return 当前会话的session
* 获取当前会话的Session，如果Session尚未创建，则新建并返回
* @return Session对象
*/
public SaSession getSession() {
return getSession(true);
}
// =================== token专属session ===================
// ------------------- token专属session -------------------
/**
* 获取指定token的专属session，如果session尚未创建，isCreate代表是否新建并返回
* 获取指定Token-Session，如果Session尚未创建，isCreate代表是否新建并返回
* @param tokenValue token值
* @param isCreate 是否新建
* @return session会话
* @return session对象
*/
public SaSession getTokenSessionByToken(String tokenValue, boolean isCreate) {
return getSessionBySessionId(splicingKeyTokenSession(tokenValue), isCreate);
}
/**
* 获取指定token的专属session，如果session尚未创建，则新建并返回
* @param tokenValue token值
* @return session会话
* 获取指定Token-Session，如果Session尚未创建，则新建并返回
* @param tokenValue Token值
* @return Session对象
*/
public SaSession getTokenSessionByToken(String tokenValue) {
return getSessionBySessionId(splicingKeyTokenSession(tokenValue), true);
}
/**
* 获取当前token的专属-session，如果session尚未创建，isCreate代表是否新建并返回
* 获取当前Token-Session，如果Session尚未创建，isCreate代表是否新建并返回
* @param isCreate 是否新建
* @return session会话
* @return Session对象
*/
public SaSession getTokenSession(boolean isCreate) {
// 如果配置了需要校验登录状态，则验证一下
@ -681,15 +641,15 @@ public class StpLogic {
}
/**
* 获取当前token的专属-session，如果session尚未创建，则新建并返回
* @return session会话
* 获取当前Token-Session，如果Session尚未创建，则新建并返回
* @return Session对象
*/
public SaSession getTokenSession() {
return getTokenSession(true);
}
// =================== [临时过期] 验证相关 ===================
// ------------------- [临时过期] 验证相关 -------------------
/**
* 写入指定token的 [最后操作时间] 为当前时间戳
@ -779,7 +739,7 @@ public class StpLogic {
}
// =================== 过期时间相关 ===================
// ------------------- 过期时间相关 -------------------
/**
* 获取当前登录者的token剩余有效时间 (单位: 秒)
@ -874,7 +834,7 @@ public class StpLogic {
}
// =================== 角色验证操作 ===================
// ------------------- 角色验证操作 -------------------
/**
* 指定账号id是否含有角色标识, 返回true或false
@ -940,7 +900,7 @@ public class StpLogic {
}
// =================== 权限验证操作 ===================
// ------------------- 权限验证操作 -------------------
/**
* 指定账号id是否含有指定权限, 返回true或false
@ -1006,10 +966,10 @@ public class StpLogic {
}
// =================== id 反查token 相关操作 ===================
// ------------------- id 反查token 相关操作 -------------------
/**
* 获取指定loginId的tokenValue
* 获取指定账号id的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
@ -1020,7 +980,7 @@ public class StpLogic {
}
/**
* 获取指定loginId指定设备端的tokenValue
* 获取指定账号id指定设备端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
@ -1033,7 +993,7 @@ public class StpLogic {
}
/**
* 获取指定loginId的tokenValue集合
* 获取指定账号id的tokenValue集合
* @param loginId 账号id
* @return 此loginId的所有相关token
*/
@ -1042,7 +1002,7 @@ public class StpLogic {
}
/**
* 获取指定loginId指定设备端的tokenValue 集合
* 获取指定账号id指定设备端的tokenValue 集合
* @param loginId 账号id
* @param device 设备标识
* @return 此loginId的所有相关token
@ -1065,7 +1025,7 @@ public class StpLogic {
}
/**
* 返回当前token的登录设备
* 返回当前会话的登录设备
* @return 当前令牌的登录设备
*/
public String getLoginDevice() {
@ -1094,10 +1054,10 @@ public class StpLogic {
}
// =================== 会话管理 ===================
// ------------------- 会话管理 -------------------
/**
* 根据条件查询token
* 根据条件查询Token
* @param keyword 关键字
* @param start 开始处索引 (-1代表查询所有)
* @param size 获取数量
@ -1119,7 +1079,7 @@ public class StpLogic {
}
/**
* 根据条件查询token专属Session的Id
* 根据条件查询Token专属Session的Id
* @param keyword 关键字
* @param start 开始处索引 (-1代表查询所有)
* @param size 获取数量
@ -1130,90 +1090,7 @@ public class StpLogic {
}
// =================== 返回相应key ===================
/**
* 获取key：客户端 tokenName
* @return key
*/
public String splicingKeyTokenName() {
return getConfig().getTokenName();
}
/**
* 获取key： tokenValue 持久化 token-id
* @param tokenValue token值
* @return key
*/
public String splicingKeyTokenValue(String tokenValue) {
return getConfig().getTokenName() + ":" + loginType + ":token:" + tokenValue;
}
/**
* 获取key： session 持久化
* @param loginId 账号id
* @return key
*/
public String splicingKeySession(Object loginId) {
return getConfig().getTokenName() + ":" + loginType + ":session:" + loginId;
}
/**
* 获取key： tokenValue的专属session
* @param tokenValue token值
* @return key
*/
public String splicingKeyTokenSession(String tokenValue) {
return getConfig().getTokenName() + ":" + loginType + ":token-session:" + tokenValue;
}
/**
* 获取key： 指定token的最后操作时间 持久化
* @param tokenValue token值
* @return key
*/
public String splicingKeyLastActivityTime(String tokenValue) {
return getConfig().getTokenName() + ":" + loginType + ":last-activity:" + tokenValue;
}
/**
* 在进行身份切换时，使用的存储key
* @return key
*/
public String splicingKeySwitch() {
return SaTokenConsts.SWITCH_TO_SAVE_KEY + loginType;
}
/**
* 如果token为本次请求新创建的，则以此字符串为key存储在当前request中
* @return key
*/
public String splicingKeyJustCreatedSave() {
return SaTokenConsts.JUST_CREATED_SAVE_KEY + loginType;
}
/**
* 拼接key： 账号封禁
* @param loginId 账号id
* @return key
*/
public String splicingKeyDisable(Object loginId) {
return getConfig().getTokenName() + ":" + loginType + ":disable:" + loginId;
}
// =================== Bean对象代理 ===================
/**
* 返回配置对象
* @return 配置对象
*/
public SaTokenConfig getConfig() {
// 为什么再次代理一层? 为某些极端业务场景下[需要不同StpLogic不同配置]提供便利
return SaManager.getConfig();
}
// =================== 其它方法 ===================
// ------------------- 其它方法 -------------------
/**
* 根据注解(@SaCheckLogin)鉴权
@ -1249,11 +1126,65 @@ public class StpLogic {
}
}
/**
* 根据注解(@SaCheckSafe)鉴权
* @param at 注解对象
*/
public void checkByAnnotation(SaCheckSafe at) {
this.checkSafe();
}
// =================== 身份切换 ===================
// ------------------- 账号封禁 -------------------
/**
* 临时切换身份为指定loginId
* 封禁指定账号
* <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常
* @param loginId 指定账号id
* @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public void disable(Object loginId, long disableTime) {
// 标注为已被封禁
SaManager.getSaTokenDao().set(splicingKeyDisable(loginId), DisableLoginException.BE_VALUE, disableTime);
// $$ 通知监听器
SaManager.getSaTokenListener().doDisable(loginType, loginId, disableTime);
}
/**
* 指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
* @param loginId 账号id
* @return see note
*/
public boolean isDisable(Object loginId) {
return SaManager.getSaTokenDao().get(splicingKeyDisable(loginId)) != null;
}
/**
* 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
* @param loginId 账号id
* @return see note
*/
public long getDisableTime(Object loginId) {
return SaManager.getSaTokenDao().getTimeout(splicingKeyDisable(loginId));
}
/**
* 解封指定账号
* @param loginId 账号id
*/
public void untieDisable(Object loginId) {
SaManager.getSaTokenDao().delete(splicingKeyDisable(loginId));
// $$ 通知监听器
SaManager.getSaTokenListener().doUntieDisable(loginType, loginId);
}
// ------------------- 身份切换 -------------------
/**
* 临时切换身份为指定账号id
* @param loginId 指定loginId
*/
public void switchTo(Object loginId) {
@ -1284,8 +1215,8 @@ public class StpLogic {
}
/**
* 在一个代码段里方法内，临时切换身份为指定loginId
* @param loginId 指定loginId
* 在一个代码段里方法内，临时切换身份为指定账号id
* @param loginId 指定账号id
* @param function 要执行的方法
*/
public void switchTo(Object loginId, SaFunction function) {
@ -1298,6 +1229,142 @@ public class StpLogic {
endSwitch();
}
}
// ------------------- 二级认证 -------------------
/**
* 在当前会话 开启二级认证
* @param timeout 维持时间 (单位: 秒)
*/
public void openSafe(long safeTime) {
long eff = System.currentTimeMillis() + safeTime * 1000;
getTokenSession().set(SaTokenConsts.SAFE_AUTH_SAVE_KEY, eff);
}
/**
* 当前会话 是否处于二级认证时间内
* @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public boolean isSafe() {
long eff = getTokenSession().get(SaTokenConsts.SAFE_AUTH_SAVE_KEY, 0L);
if(eff == 0 || eff < System.currentTimeMillis()) {
return false;
}
return true;
}
/**
* 检查当前会话是否已通过二级认证，如未通过则抛出异常
*/
public void checkSafe() {
if (isSafe() == false) {
throw new NotSafeException();
}
}
/**
* 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
* @return
*/
public long getSafeTime() {
long eff = getTokenSession().get(SaTokenConsts.SAFE_AUTH_SAVE_KEY, 0L);
if(eff == 0 || eff < System.currentTimeMillis()) {
return SaTokenDao.NOT_VALUE_EXPIRE;
}
return (eff - System.currentTimeMillis()) / 1000;
}
/**
* 在当前会话 结束二级认证
*/
public void closeSafe() {
getTokenSession().delete(SaTokenConsts.SAFE_AUTH_SAVE_KEY);
}
// ------------------- 返回相应key -------------------
/**
* 拼接key：客户端 tokenName
* @return key
*/
public String splicingKeyTokenName() {
return getConfig().getTokenName();
}
/**
* 拼接key： tokenValue 持久化 token-id
* @param tokenValue token值
* @return key
*/
public String splicingKeyTokenValue(String tokenValue) {
return getConfig().getTokenName() + ":" + loginType + ":token:" + tokenValue;
}
/**
* 拼接key： Session 持久化
* @param loginId 账号id
* @return key
*/
public String splicingKeySession(Object loginId) {
return getConfig().getTokenName() + ":" + loginType + ":session:" + loginId;
}
/**
* 拼接key： tokenValue的专属session
* @param tokenValue token值
* @return key
*/
public String splicingKeyTokenSession(String tokenValue) {
return getConfig().getTokenName() + ":" + loginType + ":token-session:" + tokenValue;
}
/**
* 拼接key： 指定token的最后操作时间 持久化
* @param tokenValue token值
* @return key
*/
public String splicingKeyLastActivityTime(String tokenValue) {
return getConfig().getTokenName() + ":" + loginType + ":last-activity:" + tokenValue;
}
/**
* 在进行身份切换时，使用的存储key
* @return key
*/
public String splicingKeySwitch() {
return SaTokenConsts.SWITCH_TO_SAVE_KEY + loginType;
}
/**
* 如果token为本次请求新创建的，则以此字符串为key存储在当前request中
* @return key
*/
public String splicingKeyJustCreatedSave() {
return SaTokenConsts.JUST_CREATED_SAVE_KEY + loginType;
}
/**
* 拼接key： 账号封禁
* @param loginId 账号id
* @return key
*/
public String splicingKeyDisable(Object loginId) {
return getConfig().getTokenName() + ":" + loginType + ":disable:" + loginId;
}
// ------------------- Bean对象代理 -------------------
/**
* 返回配置对象
* @return 配置对象
*/
public SaTokenConfig getConfig() {
// 为什么再次代理一层? 为某些极端业务场景下[需要不同StpLogic不同配置]提供便利
return SaManager.getConfig();
}
}

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

@ -41,7 +41,7 @@ public class StpUtil {
}
/**
* 在当前会话写入当前tokenValue
* 在当前会话写入当前TokenValue
* @param tokenValue token值
* @param cookieTimeout Cookie存活时间(秒)
*/
@ -50,7 +50,7 @@ public class StpUtil {
}
/**
* 获取当前tokenValue
* 获取当前TokenValue
* @return 当前tokenValue
*/
public static String getTokenValue() {
@ -58,7 +58,7 @@ public class StpUtil {
}
/**
* 获取当前会话的token信息
* 获取当前会话的Token信息
* @return token信息
*/
public static SaTokenInfo getTokenInfo() {
@ -104,14 +104,14 @@ public class StpUtil {
}
/**
* 当前会话注销登录
* 会话注销
*/
public static void logout() {
stpLogic.logout();
}
/**
* 指定token的会话注销登录
* 会话注销，根据指定Token
* @param tokenValue 指定token
*/
public static void logoutByTokenValue(String tokenValue) {
@ -119,7 +119,7 @@ public class StpUtil {
}
/**
* 指定账号id的会话注销登录（踢人下线）
* 会话注销，根据账号id （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
* @param loginId 账号id
*/
@ -128,7 +128,7 @@ public class StpUtil {
}
/**
* 指定账号id指定设备的会话注销登录（踢人下线）
* 会话注销，根据账号id & 设备标识 （踢人下线）
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
* @param loginId 账号id
* @param device 设备标识
@ -137,53 +137,17 @@ public class StpUtil {
stpLogic.logoutByLoginId(loginId, device);
}
/**
* 封禁指定账号
* <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常
* @param loginId 指定账号id
* @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, long disableTime) {
stpLogic.disable(loginId, disableTime);
}
/**
* 指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
* @param loginId 账号id
* @return see note
*/
public static boolean isDisable(Object loginId) {
return stpLogic.isDisable(loginId);
}
/**
* 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
* @param loginId 账号id
* @return see note
*/
public static long getDisableTime(Object loginId) {
return stpLogic.getDisableTime(loginId);
}
/**
* 解封指定账号
* @param loginId 账号id
*/
public static void untieDisable(Object loginId) {
stpLogic.untieDisable(loginId);
}
// 查询相关
/**
* 获取当前会话是否已经登录
/**
* 当前会话是否已经登录
* @return 是否已登录
*/
public static boolean isLogin() {
return stpLogic.isLogin();
}
/**
/**
* 检验当前会话是否已经登录，如未登录，则抛出异常
*/
public static void checkLogin() {
@ -199,7 +163,7 @@ public class StpUtil {
}
/**
* 获取当前会话登录id, 如果未登录，则返回默认值
* 获取当前会话账号id, 如果未登录，则返回默认值
* @param <T> 返回类型
* @param defaultValue 默认值
* @return 登录id
@ -209,7 +173,7 @@ public class StpUtil {
}
/**
* 获取当前会话登录id, 如果未登录，则返回null
* 获取当前会话账号id, 如果未登录，则返回null
* @return 账号id
*/
public static Object getLoginIdDefaultNull() {
@ -217,7 +181,7 @@ public class StpUtil {
}
/**
* 获取当前会话登录id, 并转换为String
* 获取当前会话账号id, 并转换为String类型
* @return 账号id
*/
public static String getLoginIdAsString() {
@ -225,7 +189,7 @@ public class StpUtil {
}
/**
* 获取当前会话登录id, 并转换为int
* 获取当前会话账号id, 并转换为int类型
* @return 账号id
*/
public static int getLoginIdAsInt() {
@ -233,17 +197,17 @@ public class StpUtil {
}
/**
* 获取当前会话登录id, 并转换为long
* 获取当前会话账号id, 并转换为long类型
* @return 账号id
*/
public static long getLoginIdAsLong() {
return stpLogic.getLoginIdAsLong();
}
/**
* 获取指定token对应的登录id，如果未登录，则返回 null
/**
* 获取指定Token对应的账号id，如果未登录，则返回 null
* @param tokenValue token
* @return 登录id
* @return 账号id
*/
public static Object getLoginIdByToken(String tokenValue) {
return stpLogic.getLoginIdByToken(tokenValue);
@ -252,46 +216,46 @@ public class StpUtil {
// =================== session相关 ===================
/**
* 获取指定loginId的session, 如果session尚未创建，isCreate=是否新建并返回
/**
* 获取指定账号id的Session, 如果Session尚未创建，isCreate=是否新建并返回
* @param loginId 账号id
* @param isCreate 是否新建
* @return SaSession
* @return Session对象
*/
public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
return stpLogic.getSessionByLoginId(loginId, isCreate);
}
/**
* 获取指定key的session, 如果session尚未创建，则返回null
* @param sessionId sessionId
* @return session对象
* 获取指定key的Session, 如果Session尚未创建，则返回null
* @param sessionId SessionId
* @return Session对象
*/
public static SaSession getSessionBySessionId(String sessionId) {
return stpLogic.getSessionBySessionId(sessionId);
}
/**
* 获取指定loginId的session，如果session尚未创建，则新建并返回
* 获取指定账号id的Session，如果Session尚未创建，则新建并返回
* @param loginId 账号id
* @return session会话
* @return Session对象
*/
public static SaSession getSessionByLoginId(Object loginId) {
return stpLogic.getSessionByLoginId(loginId);
}
/**
* 获取当前会话的session, 如果session尚未创建，isCreate=是否新建并返回
* 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回
* @param isCreate 是否新建
* @return 当前会话的session
* @return Session对象
*/
public static SaSession getSession(boolean isCreate) {
return stpLogic.getSession(isCreate);
}
/**
* 获取当前会话的session，如果session尚未创建，则新建并返回
* @return 当前会话的session
* 获取当前会话的Session，如果Session尚未创建，则新建并返回
* @return Session对象
*/
public static SaSession getSession() {
return stpLogic.getSession();
@ -301,17 +265,17 @@ public class StpUtil {
// =================== token专属session ===================
/**
* 获取指定token的专属session，如果session尚未创建，则新建并返回
* @param tokenValue token值
* @return session会话
* 获取指定Token-Session，如果Session尚未创建，则新建并返回
* @param tokenValue Token值
* @return Session对象
*/
public static SaSession getTokenSessionByToken(String tokenValue) {
return stpLogic.getTokenSessionByToken(tokenValue);
}
/**
* 获取当前token的专属-session，如果session尚未创建，则新建并返回
* @return session会话
* 获取当前Token-Session，如果Session尚未创建，则新建并返回
* @return Session对象
*/
public static SaSession getTokenSession() {
return stpLogic.getTokenSession();
@ -320,7 +284,7 @@ public class StpUtil {
// =================== [临时过期] 验证相关 ===================
/**
/**
* 检查当前token 是否已经[临时过期]，如果已经过期则抛出异常
*/
public static void checkActivityTimeout() {
@ -376,7 +340,7 @@ public class StpUtil {
// =================== 角色验证操作 ===================
/**
* 指定账号id是否含有角色标识, 返回true或false
* 指定账号id是否含有角色标识, 返回true或false
* @param loginId 账号id
* @param role 角色标识
* @return 是否含有指定角色标识
@ -468,7 +432,7 @@ public class StpUtil {
// =================== id 反查token 相关操作 ===================
/**
* 获取指定loginId的tokenValue
* 获取指定账号id的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
@ -479,7 +443,7 @@ public class StpUtil {
}
/**
* 获取指定loginId指定设备端的tokenValue
* 获取指定账号id指定设备端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
* @param loginId 账号id
@ -490,8 +454,8 @@ public class StpUtil {
return stpLogic.getTokenValueByLoginId(loginId, device);
}
/**
* 获取指定loginId的tokenValue集合
/**
* 获取指定账号id的tokenValue集合
* @param loginId 账号id
* @return 此loginId的所有相关token
*/
@ -499,8 +463,8 @@ public class StpUtil {
return stpLogic.getTokenValueListByLoginId(loginId);
}
/**
* 获取指定loginId指定设备端的tokenValue集合
/**
* 获取指定账号id指定设备端的tokenValue 集合
* @param loginId 账号id
* @param device 设备标识
* @return 此loginId的所有相关token
@ -510,7 +474,7 @@ public class StpUtil {
}
/**
* 返回当前token的登录设备
* 返回当前会话的登录设备
* @return 当前令牌的登录设备
*/
public static String getLoginDevice() {
@ -521,7 +485,7 @@ public class StpUtil {
// =================== 会话管理 ===================
/**
* 根据条件查询token
* 根据条件查询Token
* @param keyword 关键字
* @param start 开始处索引 (-1代表查询所有)
* @param size 获取数量
@ -543,7 +507,7 @@ public class StpUtil {
}
/**
* 根据条件查询token专属Session的Id
* 根据条件查询Token专属Session的Id
* @param keyword 关键字
* @param start 开始处索引 (-1代表查询所有)
* @param size 获取数量
@ -552,12 +516,51 @@ public class StpUtil {
public static List<String> searchTokenSessionId(String keyword, int start, int size) {
return stpLogic.searchTokenSessionId(keyword, start, size);
}
// ------------------- 账号封禁 -------------------
/**
* 封禁指定账号
* <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常
* @param loginId 指定账号id
* @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, long disableTime) {
stpLogic.disable(loginId, disableTime);
}
/**
* 指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
* @param loginId 账号id
* @return see note
*/
public static boolean isDisable(Object loginId) {
return stpLogic.isDisable(loginId);
}
/**
* 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
* @param loginId 账号id
* @return see note
*/
public static long getDisableTime(Object loginId) {
return stpLogic.getDisableTime(loginId);
}
/**
* 解封指定账号
* @param loginId 账号id
*/
public static void untieDisable(Object loginId) {
stpLogic.untieDisable(loginId);
}
// =================== 身份切换 ===================
/**
* 临时切换身份为指定loginId
* 临时切换身份为指定账号id
* @param loginId 指定loginId
*/
public static void switchTo(Object loginId) {
@ -580,8 +583,8 @@ public class StpUtil {
}
/**
* 在一个代码段里方法内，临时切换身份为指定loginId
* @param loginId 指定loginId
* 在一个代码段里方法内，临时切换身份为指定账号id
* @param loginId 指定账号id
* @param function 要执行的方法
*/
public static void switchTo(Object loginId, SaFunction function) {
@ -589,6 +592,47 @@ public class StpUtil {
}
// ------------------- 二级认证 -------------------
/**
* 在当前会话 开启二级认证
* @param timeout 维持时间 (单位: 秒)
*/
public static void openSafe(long safeTime) {
stpLogic.openSafe(safeTime);
}
/**
* 当前会话 是否处于二级认证时间内
* @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe() {
return stpLogic.isSafe();
}
/**
* 检查当前会话是否已通过二级认证，如未通过则抛出异常
*/
public static void checkSafe() {
stpLogic.checkSafe();
}
/**
* 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
* @return
*/
public static long getSafeTime() {
return stpLogic.getSafeTime();
}
/**
* 在当前会话 结束二级认证
*/
public static void closeSafe() {
stpLogic.closeSafe();
}
// =================== 历史API，兼容旧版本 ===================
/**

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

@ -18,7 +18,7 @@ import java.util.regex.Pattern;
public class SaFoxUtil {
/**
* 打印 sa-token 版本字符画
* 打印 Sa-Token 版本字符画
*/
public static void printSaToken() {
String str = "____ ____ ___ ____ _ _ ____ _ _ \r\n" + "[__ |__| __ | | | |_/ |___ |\\ | \r\n"

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

@ -1,7 +1,7 @@
package cn.dev33.satoken.util;
/**
* sa-token常量类
* Sa-Token常量类
* @author kong
*
*/
@ -11,17 +11,17 @@ public class SaTokenConsts {
// =================== sa-token版本信息 ===================
/**
* sa-token 当前版本号
* Sa-Token 当前版本号
*/
public static final String VERSION_NO = "v1.20.0";
/**
* sa-token 开源地址
* Sa-Token 开源地址
*/
public static final String GITHUB_URL = "https://github.com/dromara/sa-token";
/**
* sa-token 开发文档地址
* Sa-Token 开发文档地址
*/
public static final String DEV_DOC_URL = "http://sa-token.dev33.cn";
@ -47,36 +47,41 @@ public class SaTokenConsts {
*/
public static final String SWITCH_TO_SAVE_KEY = "SWITCH_TO_SAVE_KEY_";
/**
* 常量key标记: 在进行Token二级验证时使用的key
*/
public static final String SAFE_AUTH_SAVE_KEY = "SAFE_AUTH_SAVE_KEY_";
// =================== token-style 相关 ===================
/**
* token风格: uuid
* Token风格: uuid
*/
public static final String TOKEN_STYLE_UUID = "uuid";
/**
* token风格: 简单uuid (不带下划线)
* Token风格: 简单uuid (不带下划线)
*/
public static final String TOKEN_STYLE_SIMPLE_UUID = "simple-uuid";
/**
* token风格: 32位随机字符串
* Token风格: 32位随机字符串
*/
public static final String TOKEN_STYLE_RANDOM_32 = "random-32";
/**
* token风格: 64位随机字符串
* Token风格: 64位随机字符串
*/
public static final String TOKEN_STYLE_RANDOM_64 = "random-64";
/**
* token风格: 128位随机字符串
* Token风格: 128位随机字符串
*/
public static final String TOKEN_STYLE_RANDOM_128 = "random-128";
/**
* token风格: tik风格 (2_14_16)
* Token风格: tik风格 (2_14_16)
*/
public static final String TOKEN_STYLE_TIK = "tik";
@ -84,7 +89,7 @@ public class SaTokenConsts {
// =================== 其它 ===================
/**
* 连接token前缀和token值的字符
* 连接Token前缀和Token值的字符
*/
public static final String TOKEN_CONNECTOR_CHAT = " ";

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

@ -60,9 +60,9 @@ public class TestJwtController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
StpUtil.getSession().setAttribute("name", new Date()); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
StpUtil.getSession().set("name", new Date()); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
System.out.println( new ObjectMapper().writeValueAsString(StpUtil.getSession()));
return AjaxJson.getSuccess();
}

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

@ -107,9 +107,9 @@ public class TestController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
StpUtil.getSession().setAttribute("name", new Date()); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
StpUtil.getSession().set("name", new Date()); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
System.out.println( ONode.stringify(StpUtil.getSession()));
return AjaxJson.getSuccess();
}
@ -120,10 +120,10 @@ public class TestController {
System.out.println("======================= 进入方法，测试自定义session接口 ========================= ");
// 自定义session就是无需登录也可以使用 的session ：比如拿用户的手机号当做 key， 来获取 session
System.out.println("自定义 session的id为：" + SaSessionCustomUtil.getSessionById("1895544896").getId());
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").getAttribute("name"));
SaSessionCustomUtil.getSessionById("1895544896").setAttribute("name", "张三"); // 写入值
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").getAttribute("name"));
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").getAttribute("name"));
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").get("name"));
SaSessionCustomUtil.getSessionById("1895544896").set("name", "张三"); // 写入值
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").get("name"));
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").get("name"));
return AjaxJson.getSuccess();
}
@ -135,9 +135,9 @@ public class TestController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前token专属session: " + StpUtil.getTokenSession().getId());
System.out.println("测试取值name：" + StpUtil.getTokenSession().getAttribute("name"));
StpUtil.getTokenSession().setAttribute("name", "张三"); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getTokenSession().getAttribute("name"));
System.out.println("测试取值name：" + StpUtil.getTokenSession().get("name"));
StpUtil.getTokenSession().set("name", "张三"); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getTokenSession().get("name"));
return AjaxJson.getSuccess();
}

4
sa-token-demo/sa-token-demo-springboot/pom.xml
View File

@ -59,11 +59,11 @@
</dependency> -->
<!-- sa-token整合SpringAOP实现注解鉴权 -->
<!-- <dependency>
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-spring-aop</artifactId>
<version>${sa-token-version}</version>
</dependency> -->
</dependency>
<!-- @ConfigurationProperties -->
<dependency>

3
sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/satoken/SaTokenConfigure.java
View File

@ -41,8 +41,7 @@ public class SaTokenConfigure implements WebMvcConfigurer {
// 认证函数: 每次请求执行
.setAuth(r -> {
System.out.println("---------- sa全局认证");
System.out.println(SaHolder.getRequest().getRequestPath());
// System.out.println("---------- sa全局认证");
// SaRouter.match("/test/test", () -> new Object());
})

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

@ -109,9 +109,9 @@ public class TestController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
StpUtil.getSession().setAttribute("name", new Date()); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
StpUtil.getSession().set("name", new Date()); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
System.out.println( new ObjectMapper().writeValueAsString(StpUtil.getSession()));
return AjaxJson.getSuccess();
}
@ -122,10 +122,10 @@ public class TestController {
System.out.println("======================= 进入方法，测试自定义session接口 ========================= ");
// 自定义session就是无需登录也可以使用 的session ：比如拿用户的手机号当做 key， 来获取 session
System.out.println("自定义 session的id为：" + SaSessionCustomUtil.getSessionById("1895544896").getId());
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").getAttribute("name"));
SaSessionCustomUtil.getSessionById("1895544896").setAttribute("name", "张三"); // 写入值
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").getAttribute("name"));
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").getAttribute("name"));
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").get("name"));
SaSessionCustomUtil.getSessionById("1895544896").set("name", "张三"); // 写入值
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").get("name"));
System.out.println("测试取值name：" + SaSessionCustomUtil.getSessionById("1895544896").get("name"));
return AjaxJson.getSuccess();
}
@ -137,9 +137,9 @@ public class TestController {
System.out.println("当前是否登录：" + StpUtil.isLogin());
System.out.println("当前token专属session: " + StpUtil.getTokenSession().getId());
System.out.println("测试取值name：" + StpUtil.getTokenSession().getAttribute("name"));
StpUtil.getTokenSession().setAttribute("name", "张三"); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getTokenSession().getAttribute("name"));
System.out.println("测试取值name：" + StpUtil.getTokenSession().get("name"));
StpUtil.getTokenSession().set("name", "张三"); // 写入一个值
System.out.println("测试取值name：" + StpUtil.getTokenSession().get("name"));
return AjaxJson.getSuccess();
}

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

@ -1,7 +1,7 @@
# 更新日志
### 2021-5-10 @v1.20.0
### 2021-6-17 @v1.20.0
- 新增：新增Solon适配插件，感谢大佬 `@刘西东` 提供的pr **[重要]**
- 新增：新增`SaRouter.stop()`函数，用于一次性跳出匹配链功能 **[重要]**
- 新增：新增单元测试 **[重要]**

4
sa-token-doc/doc/use/password-secure.md
View File

@ -80,4 +80,6 @@ System.out.println("Base64解码后：" + text2);
```
<br>
如需更多加密算法请提交pr
如需更多加密算法，可参考 [Hutool-crypto: 加密](https://hutool.cn/docs/#/crypto/%E6%A6%82%E8%BF%B0)

26
sa-token-plugin/sa-token-dao-redis-jackson/src/main/java/cn/dev33/satoken/dao/SaTokenDaoRedisJackson.java
View File

@ -20,7 +20,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import cn.dev33.satoken.util.SaFoxUtil;
/**
* sa-token持久层的实现类, 基于redis (使用 jackson 序列化方式)
* Sa-Token持久层接口 [Redis版] (使用 jackson 序列化方式)
*
* @author kong
*
@ -73,7 +73,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
/**
* 根据key获取value，如果没有，则返回空
* 获取Value，如无返空
*/
@Override
public String get(String key) {
@ -81,7 +81,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 写入指定key-value键值对，并设定过期时间(单位：秒)
* 写入Value，并设定存活时间 (单位: 秒)
*/
@Override
public void set(String key, String value, long timeout) {
@ -94,7 +94,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 修改指定key-value键值对 (过期时间不变)
* 修修改指定key-value键值对 (过期时间不变)
*/
@Override
public void update(String key, String value) {
@ -107,7 +107,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 删除一个指定的key
* 删除Value
*/
@Override
public void delete(String key) {
@ -115,7 +115,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 根据key获取value，如果没有，则返回空
* 获取Value的剩余存活时间 (单位: 秒)
*/
@Override
public long getTimeout(String key) {
@ -123,7 +123,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 修改指定key的剩余存活时间 (单位: 秒)
* 修改Value的剩余存活时间 (单位: 秒)
*/
@Override
public void updateTimeout(String key, long timeout) {
@ -144,7 +144,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
/**
* 根据key获取Object，如果没有，则返回空
* 获取Object，如无返空
*/
@Override
public Object getObject(String key) {
@ -152,7 +152,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 写入指定键值对，并设定过期时间 (单位: 秒)
* 写入Object，并设定存活时间 (单位: 秒)
*/
@Override
public void setObject(String key, Object object, long timeout) {
@ -165,7 +165,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 修改指定键值对 (过期时间不变)
* 更新Object (过期时间不变)
*/
@Override
public void updateObject(String key, Object object) {
@ -178,7 +178,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 删除一个指定的object
* 删除Object
*/
@Override
public void deleteObject(String key) {
@ -186,7 +186,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 获取指定key的剩余存活时间 (单位: 秒)
* 获取Object的剩余存活时间 (单位: 秒)
*/
@Override
public long getObjectTimeout(String key) {
@ -194,7 +194,7 @@ public class SaTokenDaoRedisJackson implements SaTokenDao {
}
/**
* 修改指定key的剩余存活时间 (单位: 秒)
* 修改Object的剩余存活时间 (单位: 秒)
*/
@Override
public void updateObjectTimeout(String key, long timeout) {

24
sa-token-plugin/sa-token-dao-redis/src/main/java/cn/dev33/satoken/dao/SaTokenDaoRedis.java
View File

@ -16,7 +16,7 @@ import org.springframework.stereotype.Component;
import cn.dev33.satoken.util.SaFoxUtil;
/**
* sa-token持久层的实现类, 基于redis
* Sa-Token持久层接口 [Redis版 (使用JDK默认序列化方式)]
*
* @author kong
*
@ -54,7 +54,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
/**
* 根据key获取value，如果没有，则返回空
* 获取Value，如无返空
*/
@Override
public String get(String key) {
@ -62,7 +62,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 写入指定key-value键值对，并设定过期时间(单位：秒)
* 写入Value，并设定存活时间 (单位: 秒)
*/
@Override
public void set(String key, String value, long timeout) {
@ -88,7 +88,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 删除一个指定的key
* 删除Value
*/
@Override
public void delete(String key) {
@ -96,7 +96,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 根据key获取value，如果没有，则返回空
* 获取Value的剩余存活时间 (单位: 秒)
*/
@Override
public long getTimeout(String key) {
@ -104,7 +104,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 修改指定key的剩余存活时间 (单位: 秒)
* 修改Value的剩余存活时间 (单位: 秒)
*/
@Override
public void updateTimeout(String key, long timeout) {
@ -124,7 +124,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
/**
* 根据key获取Object，如果没有，则返回空
* 获取Object，如无返空
*/
@Override
public Object getObject(String key) {
@ -132,7 +132,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 写入指定键值对，并设定过期时间 (单位: 秒)
* 写入Object，并设定存活时间 (单位: 秒)
*/
@Override
public void setObject(String key, Object object, long timeout) {
@ -145,7 +145,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 修改指定键值对 (过期时间不变)
* 更新Object (过期时间不变)
*/
@Override
public void updateObject(String key, Object object) {
@ -158,7 +158,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 删除一个指定的object
* 删除Object
*/
@Override
public void deleteObject(String key) {
@ -166,7 +166,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 获取指定key的剩余存活时间 (单位: 秒)
* 获取Object的剩余存活时间 (单位: 秒)
*/
@Override
public long getObjectTimeout(String key) {
@ -174,7 +174,7 @@ public class SaTokenDaoRedis implements SaTokenDao {
}
/**
* 修改指定key的剩余存活时间 (单位: 秒)
* 修改Object的剩余存活时间 (单位: 秒)
*/
@Override
public void updateObjectTimeout(String key, long timeout) {

3
sa-token-plugin/sa-token-spring-aop/src/main/java/cn/dev33/satoken/aop/SaCheckAspect.java
View File

@ -33,7 +33,8 @@ public class SaCheckAspect {
public static final String POINTCUT_SIGN =
"@within(cn.dev33.satoken.annotation.SaCheckLogin) || @annotation(cn.dev33.satoken.annotation.SaCheckLogin) || "
+ "@within(cn.dev33.satoken.annotation.SaCheckRole) || @annotation(cn.dev33.satoken.annotation.SaCheckRole) || "
+ "@within(cn.dev33.satoken.annotation.SaCheckPermission) || @annotation(cn.dev33.satoken.annotation.SaCheckPermission)";
+ "@within(cn.dev33.satoken.annotation.SaCheckPermission) || @annotation(cn.dev33.satoken.annotation.SaCheckPermission) || "
+ "@within(cn.dev33.satoken.annotation.SaCheckSafe) || @annotation(cn.dev33.satoken.annotation.SaCheckSafe)";
/**
* 声明AOP签名

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

@ -10,6 +10,7 @@ import cn.dev33.satoken.action.SaTokenAction;
import cn.dev33.satoken.annotation.SaCheckLogin;
import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.dev33.satoken.annotation.SaCheckRole;
import cn.dev33.satoken.annotation.SaCheckSafe;
import cn.dev33.satoken.config.SaTokenConfig;
import cn.dev33.satoken.dao.SaTokenDao;
import cn.dev33.satoken.listener.SaTokenListener;
@ -29,6 +30,7 @@ public class XPluginImp implements Plugin {
Aop.context().beanAroundAdd(SaCheckPermission.class, SaTokenMethodInterceptor.INSTANCE);
Aop.context().beanAroundAdd(SaCheckRole.class, SaTokenMethodInterceptor.INSTANCE);
Aop.context().beanAroundAdd(SaCheckLogin.class, SaTokenMethodInterceptor.INSTANCE);
Aop.context().beanAroundAdd(SaCheckSafe.class, SaTokenMethodInterceptor.INSTANCE);
//集成初始化

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

@ -183,5 +183,27 @@ public class SaTokenSpringBootStarterTest {
long timeout = SaTempUtil.getTimeout(token);
Assert.assertTrue(timeout > 195);
}
// 测试：二级认证
@Test
public void testSafe() throws InterruptedException {
// 登录
StpUtil.login(10001);
Assert.assertFalse(StpUtil.isSafe());
// 开启二级认证
StpUtil.openSafe(2);
Assert.assertTrue(StpUtil.isSafe());
Assert.assertTrue(StpUtil.getSafeTime() > 0);
// 自然结束
Thread.sleep(2500);
Assert.assertFalse(StpUtil.isSafe());
// 手动结束
StpUtil.openSafe(2);
StpUtil.closeSafe();
Assert.assertFalse(StpUtil.isSafe());
}
}