diff --git a/pom.xml b/pom.xml
index 4f087cf5..d1d2fe36 100644
--- a/pom.xml
+++ b/pom.xml
@@ -256,35 +256,35 @@
             <dependency>
                 <groupId>cn.dev33</groupId>
                 <artifactId>sa-token-core</artifactId>
-                <version>1.37.0</version>
+                <version>1.44.0</version>
             </dependency>
 
             <!-- sa-token -->
             <dependency>
                 <groupId>cn.dev33</groupId>
                 <artifactId>sa-token-spring-boot3-starter</artifactId>
-                <version>1.37.0</version>
+                <version>1.44.0</version>
             </dependency>
 
             <!-- sa-token 整合 redis （使用jackson序列化方式） -->
             <dependency>
                 <groupId>cn.dev33</groupId>
                 <artifactId>sa-token-redis-jackson</artifactId>
-                <version>1.37.0</version>
+                <version>1.44.0</version>
             </dependency>
 
             <!-- Sa-Token插件：权限缓存与业务缓存分离 -->
             <dependency>
                 <groupId>cn.dev33</groupId>
                 <artifactId>sa-token-alone-redis</artifactId>
-                <version>1.37.0</version>
+                <version>1.44.0</version>
             </dependency>
 
             <!-- Sa-Token 插件：整合SSO -->
             <dependency>
                 <groupId>cn.dev33</groupId>
                 <artifactId>sa-token-sso</artifactId>
-                <version>1.37.0</version>
+                <version>1.44.0</version>
             </dependency>
 
             <!-- JustAuth 第三方登录 -->
diff --git a/snowy-plugin-api/snowy-plugin-auth-api/src/main/java/vip/xiaonuo/auth/core/util/StpClientUtil.java b/snowy-plugin-api/snowy-plugin-auth-api/src/main/java/vip/xiaonuo/auth/core/util/StpClientUtil.java
index 22dc2e89..4b1677d8 100644
--- a/snowy-plugin-api/snowy-plugin-auth-api/src/main/java/vip/xiaonuo/auth/core/util/StpClientUtil.java
+++ b/snowy-plugin-api/snowy-plugin-auth-api/src/main/java/vip/xiaonuo/auth/core/util/StpClientUtil.java
@@ -14,11 +14,15 @@ package vip.xiaonuo.auth.core.util;
 
 import cn.dev33.satoken.SaManager;
 import cn.dev33.satoken.fun.SaFunction;
+import cn.dev33.satoken.fun.SaTwoParamFunction;
+import cn.dev33.satoken.listener.SaTokenEventCenter;
 import cn.dev33.satoken.session.SaSession;
-import cn.dev33.satoken.stp.SaLoginModel;
+import cn.dev33.satoken.session.SaTerminalInfo;
 import cn.dev33.satoken.stp.SaTokenInfo;
 import cn.dev33.satoken.stp.StpLogic;
-import cn.dev33.satoken.stp.StpUtil;
+import cn.dev33.satoken.stp.parameter.SaLoginParameter;
+import cn.dev33.satoken.stp.parameter.SaLogoutParameter;
+import lombok.Getter;
 
 import java.util.List;
 
@@ -36,69 +40,88 @@ public class StpClientUtil {
     public static final String TYPE = "C";
 
     /**
-     * 底层的 StpLogic 对象，使用匿名子类 重写`stpLogic对象`的一些方法
+     * 底层使用的 StpLogic 对象
+     * -- GETTER --
+     *  获取 StpLogic 对象
+     *
      */
-    public static StpLogic stpLogic = new StpLogic(TYPE) {
-
-        /**
-         * 重写 StpLogic 类下的 `splicingKeyTokenName` 函数，返回一个与 `StpUtil` 相同的token名称
-         */
-        @Override
-        public String splicingKeyTokenName() {
-            return super.splicingKeyTokenName();
-        }
-
-        // 此处可以根据需求重写其他方法
-    };
+    @Getter
+    public static StpLogic stpLogic = new StpLogic(TYPE);
 
     /**
      * 获取当前 StpLogic 的账号类型
-     * @return See Note
+     *
+     * @return /
      */
-    public static String getLoginType() {
+    public static String getLoginType(){
         return stpLogic.getLoginType();
     }
 
     /**
-     * 重置 StpLogic 对象
-     * @param stpLogic /
+     * 安全的重置 StpLogic 对象
+     *
+     * <br> 1、更改此账户的 StpLogic 对象
+     * <br> 2、put 到全局 StpLogic 集合中
+     * <br> 3、发送日志
+     *
+     * @param newStpLogic /
      */
-    public static void setStpLogic(StpLogic stpLogic) {
-        StpUtil.stpLogic = stpLogic;
-        // 防止自定义 stpLogic 被覆盖
-        SaManager.putStpLogic(stpLogic);
+    public static void setStpLogic(StpLogic newStpLogic) {
+        // 1、重置此账户的 StpLogic 对象
+        stpLogic = newStpLogic;
+
+        // 2、添加到全局 StpLogic 集合中
+        //    以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic
+        SaManager.putStpLogic(newStpLogic);
+
+        // 3、$$ 发布事件：更新了 stpLogic 对象
+        SaTokenEventCenter.doSetStpLogic(stpLogic);
     }
 
 
-    // =================== 获取token 相关 ===================
+    // ------------------- 获取 token 相关 -------------------
 
     /**
-     * 返回token名称
-     * @return 此StpLogic的token名称
+     * 返回 token 名称，此名称在以下地方体现：Cookie 保存 token 时的名称、提交 token 时参数的名称、存储 token 时的 key 前缀
+     *
+     * @return /
      */
     public static String getTokenName() {
         return stpLogic.getTokenName();
     }
 
     /**
-     * 在当前会话写入当前TokenValue
-     * @param tokenValue token值
+     * 在当前会话写入指定 token 值
+     *
+     * @param tokenValue token 值
      */
-    public static void setTokenValue(String tokenValue) {
+    public static void setTokenValue(String tokenValue){
         stpLogic.setTokenValue(tokenValue);
     }
 
     /**
-     * 在当前会话写入当前TokenValue
-     * @param tokenValue token值
+     * 在当前会话写入指定 token 值
+     *
+     * @param tokenValue token 值
      * @param cookieTimeout Cookie存活时间(秒)
      */
-    public static void setTokenValue(String tokenValue, int cookieTimeout) {
+    public static void setTokenValue(String tokenValue, int cookieTimeout){
         stpLogic.setTokenValue(tokenValue, cookieTimeout);
     }
 
     /**
-     * 获取当前TokenValue
+     * 在当前会话写入指定 token 值
+     *
+     * @param tokenValue token 值
+     * @param loginParameter 登录参数
+     */
+    public static void setTokenValue(String tokenValue, SaLoginParameter loginParameter){
+        stpLogic.setTokenValue(tokenValue, loginParameter);
+    }
+
+    /**
+     * 获取当前请求的 token 值
+     *
      * @return 当前tokenValue
      */
     public static String getTokenValue() {
@@ -106,28 +129,31 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前TokenValue (不裁剪前缀)
+     * 获取当前请求的 token 值 （不裁剪前缀）
+     *
      * @return /
      */
-    public static String getTokenValueNotCut() {
+    public static String getTokenValueNotCut(){
         return stpLogic.getTokenValueNotCut();
     }
 
     /**
-     * 获取当前会话的Token信息
-     * @return token信息
+     * 获取当前会话的 token 参数信息
+     *
+     * @return token 参数信息
      */
     public static SaTokenInfo getTokenInfo() {
         return stpLogic.getTokenInfo();
     }
 
 
-    // =================== 登录相关操作 ===================
+    // ------------------- 登录相关操作 -------------------
 
     // --- 登录
 
     /**
      * 会话登录
+     *
      * @param id 账号id，建议的类型：（long | int | String）
      */
     public static void login(Object id) {
@@ -135,35 +161,49 @@ public class StpClientUtil {
     }
 
     /**
-     * 会话登录，并指定登录设备
+     * 会话登录，并指定登录设备类型
+     *
      * @param id 账号id，建议的类型：（long | int | String）
-     * @param device 设备标识
+     * @param deviceType 设备类型
      */
-    public static void login(Object id, String device) {
-        stpLogic.login(id, device);
+    public static void login(Object id, String deviceType) {
+        stpLogic.login(id, deviceType);
     }
 
     /**
      * 会话登录，并指定是否 [记住我]
+     *
      * @param id 账号id，建议的类型：（long | int | String）
-     * @param isLastingCookie 是否为持久Cookie
+     * @param isLastingCookie 是否为持久Cookie，值为 true 时记住我，值为 false 时关闭浏览器需要重新登录
      */
     public static void login(Object id, boolean isLastingCookie) {
         stpLogic.login(id, isLastingCookie);
     }
 
     /**
-     * 会话登录，并指定所有登录参数Model
-     * @param id 登录id，建议的类型：（long | int | String）
-     * @param loginModel 此次登录的参数Model
+     * 会话登录，并指定此次登录 token 的有效期, 单位:秒
+     *
+     * @param id      账号id，建议的类型：（long | int | String）
+     * @param timeout 此次登录 token 的有效期, 单位:秒
      */
-    public static void login(Object id, SaLoginModel loginModel) {
-        stpLogic.login(id, loginModel);
+    public static void login(Object id, long timeout) {
+        stpLogic.login(id, timeout);
     }
 
     /**
-     * 创建指定账号id的登录会话
-     * @param id 登录id，建议的类型：（long | int | String）
+     * 会话登录，并指定所有登录参数 Model
+     *
+     * @param id 账号id，建议的类型：（long | int | String）
+     * @param loginParameter 此次登录的参数Model
+     */
+    public static void login(Object id, SaLoginParameter loginParameter) {
+        stpLogic.login(id, loginParameter);
+    }
+
+    /**
+     * 创建指定账号 id 的登录会话数据
+     *
+     * @param id 账号id，建议的类型：（long | int | String）
      * @return 返回会话令牌
      */
     public static String createLoginSession(Object id) {
@@ -171,26 +211,108 @@ public class StpClientUtil {
     }
 
     /**
-     * 创建指定账号id的登录会话
-     * @param id 登录id，建议的类型：（long | int | String）
-     * @param loginModel 此次登录的参数Model
+     * 创建指定账号 id 的登录会话数据
+     *
+     * @param id 账号id，建议的类型：（long | int | String）
+     * @param loginParameter 此次登录的参数Model
      * @return 返回会话令牌
      */
-    public static String createLoginSession(Object id, SaLoginModel loginModel) {
-        return stpLogic.createLoginSession(id, loginModel);
+    public static String createLoginSession(Object id, SaLoginParameter loginParameter) {
+        return stpLogic.createLoginSession(id, loginParameter);
     }
 
-    // --- 注销
+    /**
+     * 获取指定账号 id 的登录会话数据，如果获取不到则创建并返回
+     *
+     * @param id 账号id，建议的类型：（long | int | String）
+     * @return 返回会话令牌
+     */
+    public static String getOrCreateLoginSession(Object id) {
+        return stpLogic.getOrCreateLoginSession(id);
+    }
+
+    // --- 注销 (根据 token)
 
     /**
-     * 会话注销
+     * 在当前客户端会话注销
      */
     public static void logout() {
         stpLogic.logout();
     }
 
+    /**
+     * 在当前客户端会话注销，根据注销参数
+     */
+    public static void logout(SaLogoutParameter logoutParameter) {
+        stpLogic.logout(logoutParameter);
+    }
+
+    /**
+     * 注销下线，根据指定 token
+     *
+     * @param tokenValue 指定 token
+     */
+    public static void logoutByTokenValue(String tokenValue) {
+        stpLogic.logoutByTokenValue(tokenValue);
+    }
+
+    /**
+     * 注销下线，根据指定 token、注销参数
+     *
+     * @param tokenValue 指定 token
+     * @param logoutParameter /
+     */
+    public static void logoutByTokenValue(String tokenValue, SaLogoutParameter logoutParameter) {
+        stpLogic.logoutByTokenValue(tokenValue, logoutParameter);
+    }
+
+    /**
+     * 踢人下线，根据指定 token
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
+     *
+     * @param tokenValue 指定 token
+     */
+    public static void kickoutByTokenValue(String tokenValue) {
+        stpLogic.kickoutByTokenValue(tokenValue);
+    }
+
+    /**
+     * 踢人下线，根据指定 token、注销参数
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
+     *
+     * @param tokenValue 指定 token
+     * @param logoutParameter 注销参数
+     */
+    public static void kickoutByTokenValue(String tokenValue, SaLogoutParameter logoutParameter) {
+        stpLogic.kickoutByTokenValue(tokenValue, logoutParameter);
+    }
+
+    /**
+     * 顶人下线，根据指定 token
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 </p>
+     *
+     * @param tokenValue 指定 token
+     */
+    public static void replacedByTokenValue(String tokenValue) {
+        stpLogic.replacedByTokenValue(tokenValue);
+    }
+
+    /**
+     * 顶人下线，根据指定 token、注销参数
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 </p>
+     *
+     * @param tokenValue 指定 token
+     * @param logoutParameter /
+     */
+    public static void replacedByTokenValue(String tokenValue, SaLogoutParameter logoutParameter) {
+        stpLogic.replacedByTokenValue(tokenValue, logoutParameter);
+    }
+
+    // --- 注销 (根据 loginId)
+
     /**
      * 会话注销，根据账号id
+     *
      * @param loginId 账号id
      */
     public static void logout(Object loginId) {
@@ -198,27 +320,28 @@ public class StpClientUtil {
     }
 
     /**
-     * 会话注销，根据账号id 和 设备标识
+     * 会话注销，根据账号id 和 设备类型
      *
      * @param loginId 账号id
-     * @param device 设备标识 (填null代表所有注销设备)
+     * @param deviceType 设备类型 (填 null 代表注销该账号的所有设备类型)
      */
-    public static void logout(Object loginId, String device) {
-        stpLogic.logout(loginId, device);
+    public static void logout(Object loginId, String deviceType) {
+        stpLogic.logout(loginId, deviceType);
     }
 
     /**
-     * 会话注销，根据指定 Token
+     * 会话注销，根据账号id 和 注销参数
      *
-     * @param tokenValue 指定token
+     * @param loginId 账号id
+     * @param logoutParameter 注销参数
      */
-    public static void logoutByTokenValue(String tokenValue) {
-        stpLogic.logoutByTokenValue(tokenValue);
+    public static void logout(Object loginId, SaLogoutParameter logoutParameter) {
+        stpLogic.logout(loginId, logoutParameter);
     }
 
     /**
      * 踢人下线，根据账号id
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
      *
      * @param loginId 账号id
      */
@@ -227,48 +350,109 @@ public class StpClientUtil {
     }
 
     /**
-     * 踢人下线，根据账号id 和 设备标识
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
+     * 踢人下线，根据账号id 和 设备类型
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
      *
      * @param loginId 账号id
-     * @param device 设备标识 (填null代表踢出所有设备)
+     * @param deviceType 设备类型 (填 null 代表踢出该账号的所有设备类型)
      */
-    public static void kickout(Object loginId, String device) {
-        stpLogic.kickout(loginId, device);
+    public static void kickout(Object loginId, String deviceType) {
+        stpLogic.kickout(loginId, deviceType);
     }
 
     /**
-     * 踢人下线，根据指定 Token
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
-     *
-     * @param tokenValue 指定token
-     */
-    public static void kickoutByTokenValue(String tokenValue) {
-        stpLogic.kickoutByTokenValue(tokenValue);
-    }
-
-    /**
-     * 顶人下线，根据账号id 和 设备标识
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
+     * 踢人下线，根据账号id 和 注销参数
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
      *
      * @param loginId 账号id
-     * @param device 设备标识 (填null代表顶替所有设备)
+     * @param logoutParameter 注销参数
      */
-    public static void replaced(Object loginId, String device) {
-        stpLogic.replaced(loginId, device);
+    public static void kickout(Object loginId, SaLogoutParameter logoutParameter) {
+        stpLogic.kickout(loginId, logoutParameter);
+    }
+
+    /**
+     * 顶人下线，根据账号id
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 </p>
+     *
+     * @param loginId 账号id
+     */
+    public static void replaced(Object loginId) {
+        stpLogic.replaced(loginId);
+    }
+
+    /**
+     * 顶人下线，根据账号id 和 设备类型
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 </p>
+     *
+     * @param loginId 账号id
+     * @param deviceType 设备类型 （填 null 代表顶替该账号的所有设备类型）
+     */
+    public static void replaced(Object loginId, String deviceType) {
+        stpLogic.replaced(loginId, deviceType);
+    }
+
+    /**
+     * 顶人下线，根据账号id 和 注销参数
+     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 </p>
+     *
+     * @param loginId 账号id
+     * @param logoutParameter 注销参数
+     */
+    public static void replaced(Object loginId, SaLogoutParameter logoutParameter) {
+        stpLogic.replaced(loginId, logoutParameter);
+    }
+
+    // --- 注销 (会话管理辅助方法)
+
+    /**
+     * 在 Account-Session 上移除 Terminal 信息 (注销下线方式)
+     * @param session /
+     * @param terminal /
+     */
+    public static void removeTerminalByLogout(SaSession session, SaTerminalInfo terminal) {
+        stpLogic.removeTerminalByLogout(session, terminal);
+    }
+
+    /**
+     * 在 Account-Session 上移除 Terminal 信息 (踢人下线方式)
+     * @param session /
+     * @param terminal /
+     */
+    public static void removeTerminalByKickout(SaSession session, SaTerminalInfo terminal) {
+        stpLogic.removeTerminalByKickout(session, terminal);
+    }
+
+    /**
+     * 在 Account-Session 上移除 Terminal 信息 (顶人下线方式)
+     * @param session /
+     * @param terminal /
+     */
+    public static void removeTerminalByReplaced(SaSession session, SaTerminalInfo terminal) {
+        stpLogic.removeTerminalByReplaced(session, terminal);
     }
 
 
-    // 查询相关
+    // 会话查询
 
     /**
-     * 当前会话是否已经登录
-     * @return 是否已登录
+     * 判断当前会话是否已经登录
+     *
+     * @return 已登录返回 true，未登录返回 false
      */
     public static boolean isLogin() {
         return stpLogic.isLogin();
     }
 
+    /**
+     * 判断指定账号是否已经登录
+     *
+     * @return 已登录返回 true，未登录返回 false
+     */
+    public static boolean isLogin(Object loginId) {
+        return stpLogic.isLogin(loginId);
+    }
+
     /**
      * 检验当前会话是否已经登录，如未登录，则抛出异常
      */
@@ -277,7 +461,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前会话账号id, 如果未登录，则抛出异常
+     * 获取当前会话账号id，如果未登录，则抛出异常
+     *
      * @return 账号id
      */
     public static Object getLoginId() {
@@ -286,6 +471,7 @@ public class StpClientUtil {
 
     /**
      * 获取当前会话账号id, 如果未登录，则返回默认值
+     *
      * @param <T> 返回类型
      * @param defaultValue 默认值
      * @return 登录id
@@ -296,6 +482,7 @@ public class StpClientUtil {
 
     /**
      * 获取当前会话账号id, 如果未登录，则返回null
+     *
      * @return 账号id
      */
     public static Object getLoginIdDefaultNull() {
@@ -303,7 +490,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前会话账号id, 并转换为String类型
+     * 获取当前会话账号id, 并转换为 String 类型
+     *
      * @return 账号id
      */
     public static String getLoginIdAsString() {
@@ -311,7 +499,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前会话账号id, 并转换为int类型
+     * 获取当前会话账号id, 并转换为 int 类型
+     *
      * @return 账号id
      */
     public static int getLoginIdAsInt() {
@@ -319,7 +508,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前会话账号id, 并转换为long类型
+     * 获取当前会话账号id, 并转换为 long 类型
+     *
      * @return 账号id
      */
     public static long getLoginIdAsLong() {
@@ -327,7 +517,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取指定Token对应的账号id，如果未登录，则返回 null
+     * 获取指定 token 对应的账号id，如果 token 无效或 token 处于被踢、被顶、被冻结等状态，则返回 null
+     *
      * @param tokenValue token
      * @return 账号id
      */
@@ -336,7 +527,18 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取Token扩展信息（只在jwt模式下有效）
+     * 获取指定 token 对应的账号id，如果 token 无效或 token 处于被踢、被顶等状态 (不考虑被冻结)，则返回 null
+     *
+     * @param tokenValue token
+     * @return 账号id
+     */
+    public Object getLoginIdByTokenNotThinkFreeze(String tokenValue) {
+        return stpLogic.getLoginIdByTokenNotThinkFreeze(tokenValue);
+    }
+
+    /**
+     * 获取当前 Token 的扩展信息（此函数只在jwt模式下生效）
+     *
      * @param key 键值
      * @return 对应的扩展数据
      */
@@ -344,21 +546,34 @@ public class StpClientUtil {
         return stpLogic.getExtra(key);
     }
 
+    /**
+     * 获取指定 Token 的扩展信息（此函数只在jwt模式下生效）
+     *
+     * @param tokenValue 指定的 Token 值
+     * @param key 键值
+     * @return 对应的扩展数据
+     */
+    public static Object getExtra(String tokenValue, String key) {
+        return stpLogic.getExtra(tokenValue, key);
+    }
 
-    // =================== User-Session 相关 ===================
+
+    // ------------------- Account-Session 相关 -------------------
 
     /**
-     * 获取指定账号id的Session, 如果Session尚未创建，isCreate=是否新建并返回
+     * 获取指定账号 id 的 Account-Session, 如果该 SaSession 尚未创建，isCreate=是否新建并返回
+     *
      * @param loginId 账号id
      * @param isCreate 是否新建
-     * @return Session对象
+     * @return SaSession 对象
      */
     public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
         return stpLogic.getSessionByLoginId(loginId, isCreate);
     }
 
     /**
-     * 获取指定key的Session, 如果Session尚未创建，则返回null
+     * 获取指定 key 的 SaSession, 如果该 SaSession 尚未创建，则返回 null
+     *
      * @param sessionId SessionId
      * @return Session对象
      */
@@ -367,16 +582,18 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取指定账号id的Session，如果Session尚未创建，则新建并返回
+     * 获取指定账号 id 的 Account-Session，如果该 SaSession 尚未创建，则新建并返回
+     *
      * @param loginId 账号id
-     * @return Session对象
+     * @return SaSession 对象
      */
     public static SaSession getSessionByLoginId(Object loginId) {
         return stpLogic.getSessionByLoginId(loginId);
     }
 
     /**
-     * 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回
+     * 获取当前已登录账号的 Account-Session, 如果该 SaSession 尚未创建，isCreate=是否新建并返回
+     *
      * @param isCreate 是否新建
      * @return Session对象
      */
@@ -385,7 +602,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前会话的Session，如果Session尚未创建，则新建并返回
+     * 获取当前已登录账号的 Account-Session，如果该 SaSession 尚未创建，则新建并返回
+     *
      * @return Session对象
      */
     public static SaSession getSession() {
@@ -393,10 +611,11 @@ public class StpClientUtil {
     }
 
 
-    // =================== Token-Session 相关 ===================
+    // ------------------- Token-Session 相关 -------------------
 
     /**
-     * 获取指定Token-Session，如果Session尚未创建，则新建并返回
+     * 获取指定 token 的 Token-Session，如果该 SaSession 尚未创建，则新建并返回
+     *
      * @param tokenValue Token值
      * @return Session对象
      */
@@ -405,37 +624,50 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前Token-Session，如果Session尚未创建，则新建并返回
+     * 获取当前 token 的 Token-Session，如果该 SaSession 尚未创建，则新建并返回
+     *
      * @return Session对象
      */
     public static SaSession getTokenSession() {
         return stpLogic.getTokenSession();
     }
 
-
-    // =================== [临时有效期] 验证相关 ===================
-
     /**
-     * 检查当前token 是否已经[临时过期]，如果已经过期则抛出异常
+     * 获取当前匿名 Token-Session （可在未登录情况下使用的Token-Session）
+     *
+     * @return Token-Session 对象
      */
-    public static void checkActiveTimeout() {
-        stpLogic.checkActiveTimeout();
+    public static SaSession getAnonTokenSession() {
+        return stpLogic.getAnonTokenSession();
     }
 
+
+    // ------------------- Active-Timeout token 最低活跃度 验证相关 -------------------
+
     /**
-     * 续签当前token：(将 [最后操作时间] 更新为当前时间戳)
-     * <h1>请注意: 即时token已经 [临时过期] 也可续签成功，
-     * 如果此场景下需要提示续签失败，可在此之前调用 checkActiveTimeout() 强制检查是否过期即可 </h1>
+     * 续签当前 token：(将 [最后操作时间] 更新为当前时间戳)
+     * <h2>
+     * 		请注意: 即使 token 已被冻结 也可续签成功，
+     * 		如果此场景下需要提示续签失败，可在此之前调用 checkActiveTimeout() 强制检查是否冻结即可
+     * </h2>
      */
     public static void updateLastActiveToNow() {
         stpLogic.updateLastActiveToNow();
     }
 
+    /**
+     * 检查当前 token 是否已被冻结，如果是则抛出异常
+     */
+    public static void checkActiveTimeout() {
+        stpLogic.checkActiveTimeout();
+    }
 
-    // =================== 过期时间相关 ===================
+
+    // ------------------- 过期时间相关 -------------------
 
     /**
-     * 获取当前登录者的 token 剩余有效时间 (单位: 秒)
+     * 获取当前会话 token 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+     *
      * @return token剩余有效时间
      */
     public static long getTokenTimeout() {
@@ -443,7 +675,18 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前登录者的 User-Session 剩余有效时间 (单位: 秒)
+     * 获取指定 token 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+     *
+     * @param token 指定token
+     * @return token剩余有效时间
+     */
+    public static long getTokenTimeout(String token) {
+        return stpLogic.getTokenTimeout(token);
+    }
+
+    /**
+     * 获取当前登录账号的 Account-Session 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+     *
      * @return token剩余有效时间
      */
     public static long getSessionTimeout() {
@@ -451,7 +694,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前 Token-Session 剩余有效时间 (单位: 秒)
+     * 获取当前 token 的 Token-Session 剩余有效时间（单位: 秒，返回 -1 代表永久有效，-2 代表没有这个值）
+     *
      * @return token剩余有效时间
      */
     public static long getTokenSessionTimeout() {
@@ -459,15 +703,17 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取当前 token [临时过期] 剩余有效时间 (单位: 秒)
-     * @return token [临时过期] 剩余有效时间
+     * 获取当前 token 剩余活跃有效期：当前 token 距离被冻结还剩多少时间（单位: 秒，返回 -1 代表永不冻结，-2 代表没有这个值或 token 已被冻结了）
+     *
+     * @return /
      */
     public static long getTokenActiveTimeout() {
         return stpLogic.getTokenActiveTimeout();
     }
 
     /**
-     * 对当前 Token 的 timeout 值进行续期
+     * 对当前 token 的 timeout 值进行续期
+     *
      * @param timeout 要修改成为的有效时间 (单位: 秒)
      */
     public static void renewTimeout(long timeout) {
@@ -475,18 +721,21 @@ public class StpClientUtil {
     }
 
     /**
-     * 对指定 Token 的 timeout 值进行续期
-     * @param tokenValue 指定token
-     * @param timeout 要修改成为的有效时间 (单位: 秒)
+     * 对指定 token 的 timeout 值进行续期
+     *
+     * @param tokenValue 指定 token
+     * @param timeout 要修改成为的有效时间 (单位: 秒，填 -1 代表要续为永久有效)
      */
     public static void renewTimeout(String tokenValue, long timeout) {
         stpLogic.renewTimeout(tokenValue, timeout);
     }
 
-    // =================== 角色验证操作 ===================
+
+    // ------------------- 角色认证操作 -------------------
 
     /**
      * 获取：当前账号的角色集合
+     *
      * @return /
      */
     public static List<String> getRoleList() {
@@ -495,6 +744,7 @@ public class StpClientUtil {
 
     /**
      * 获取：指定账号的角色集合
+     *
      * @param loginId 指定账号id
      * @return /
      */
@@ -503,16 +753,18 @@ public class StpClientUtil {
     }
 
     /**
-     * 判断：当前账号是否拥有指定角色, 返回true或false
-     * @param role 角色标识
-     * @return 是否含有指定角色标识
+     * 判断：当前账号是否拥有指定角色, 返回 true 或 false
+     *
+     * @param role 角色
+     * @return /
      */
     public static boolean hasRole(String role) {
         return stpLogic.hasRole(role);
     }
 
     /**
-     * 判断：指定账号是否含有指定角色标识, 返回true或false
+     * 判断：指定账号是否含有指定角色标识, 返回 true 或 false
+     *
      * @param loginId 账号id
      * @param role 角色标识
      * @return 是否含有指定角色标识
@@ -522,25 +774,28 @@ public class StpClientUtil {
     }
 
     /**
-     * 判断：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
+     * 判断：当前账号是否含有指定角色标识 [ 指定多个，必须全部验证通过 ]
+     *
      * @param roleArray 角色标识数组
      * @return true或false
      */
-    public static boolean hasRoleAnd(String... roleArray) {
+    public static boolean hasRoleAnd(String... roleArray){
         return stpLogic.hasRoleAnd(roleArray);
     }
 
     /**
-     * 判断：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
+     * 判断：当前账号是否含有指定角色标识 [ 指定多个，只要其一验证通过即可 ]
+     *
      * @param roleArray 角色标识数组
      * @return true或false
      */
-    public static boolean hasRoleOr(String... roleArray) {
+    public static boolean hasRoleOr(String... roleArray){
         return stpLogic.hasRoleOr(roleArray);
     }
 
     /**
      * 校验：当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
+     *
      * @param role 角色标识
      */
     public static void checkRole(String role) {
@@ -548,26 +803,29 @@ public class StpClientUtil {
     }
 
     /**
-     * 校验：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
+     * 校验：当前账号是否含有指定角色标识 [ 指定多个，必须全部验证通过 ]
+     *
      * @param roleArray 角色标识数组
      */
-    public static void checkRoleAnd(String... roleArray) {
+    public static void checkRoleAnd(String... roleArray){
         stpLogic.checkRoleAnd(roleArray);
     }
 
     /**
-     * 校验：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
+     * 校验：当前账号是否含有指定角色标识 [ 指定多个，只要其一验证通过即可 ]
+     *
      * @param roleArray 角色标识数组
      */
-    public static void checkRoleOr(String... roleArray) {
+    public static void checkRoleOr(String... roleArray){
         stpLogic.checkRoleOr(roleArray);
     }
 
 
-    // =================== 权限验证操作 ===================
+    // ------------------- 权限认证操作 -------------------
 
     /**
      * 获取：当前账号的权限码集合
+     *
      * @return /
      */
     public static List<String> getPermissionList() {
@@ -576,6 +834,7 @@ public class StpClientUtil {
 
     /**
      * 获取：指定账号的权限码集合
+     *
      * @param loginId 指定账号id
      * @return /
      */
@@ -584,7 +843,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 判断：当前账号是否含有指定权限, 返回true或false
+     * 判断：当前账号是否含有指定权限, 返回 true 或 false
+     *
      * @param permission 权限码
      * @return 是否含有指定权限
      */
@@ -593,8 +853,9 @@ public class StpClientUtil {
     }
 
     /**
-     * 判断：指定账号id是否含有指定权限, 返回true或false
-     * @param loginId 账号id
+     * 判断：指定账号 id 是否含有指定权限, 返回 true 或 false
+     *
+     * @param loginId 账号 id
      * @param permission 权限码
      * @return 是否含有指定权限
      */
@@ -603,25 +864,28 @@ public class StpClientUtil {
     }
 
     /**
-     * 判断：当前账号是否含有指定权限, [指定多个，必须全部具有]
+     * 判断：当前账号是否含有指定权限 [ 指定多个，必须全部具有 ]
+     *
      * @param permissionArray 权限码数组
      * @return true 或 false
      */
-    public static boolean hasPermissionAnd(String... permissionArray) {
+    public static boolean hasPermissionAnd(String... permissionArray){
         return stpLogic.hasPermissionAnd(permissionArray);
     }
 
     /**
-     * 判断：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
+     * 判断：当前账号是否含有指定权限 [ 指定多个，只要其一验证通过即可 ]
+     *
      * @param permissionArray 权限码数组
      * @return true 或 false
      */
-    public static boolean hasPermissionOr(String... permissionArray) {
+    public static boolean hasPermissionOr(String... permissionArray){
         return stpLogic.hasPermissionOr(permissionArray);
     }
 
     /**
      * 校验：当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException
+     *
      * @param permission 权限码
      */
     public static void checkPermission(String permission) {
@@ -629,7 +893,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 校验：当前账号是否含有指定权限 [指定多个，必须全部验证通过]
+     * 校验：当前账号是否含有指定权限 [ 指定多个，必须全部验证通过 ]
+     *
      * @param permissionArray 权限码数组
      */
     public static void checkPermissionAnd(String... permissionArray) {
@@ -637,7 +902,8 @@ public class StpClientUtil {
     }
 
     /**
-     * 校验：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
+     * 校验：当前账号是否含有指定权限 [ 指定多个，只要其一验证通过即可 ]
+     *
      * @param permissionArray 权限码数组
      */
     public static void checkPermissionOr(String... permissionArray) {
@@ -645,12 +911,15 @@ public class StpClientUtil {
     }
 
 
-    // =================== id 反查token 相关操作 ===================
+    // ------------------- id 反查 token 相关操作 -------------------
 
     /**
-     * 获取指定账号id的tokenValue
-     * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
-     * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
+     * 获取指定账号 id 的 token
+     * <p>
+     * 		在配置为允许并发登录时，此方法只会返回队列的最后一个 token，
+     * 		如果你需要返回此账号 id 的所有 token，请调用 getTokenValueListByLoginId
+     * </p>
+     *
      * @param loginId 账号id
      * @return token值
      */
@@ -659,52 +928,121 @@ public class StpClientUtil {
     }
 
     /**
-     * 获取指定账号id指定设备端的tokenValue
-     * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
-     * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
+     * 获取指定账号 id 指定设备类型端的 token
+     * <p>
+     * 		在配置为允许并发登录时，此方法只会返回队列的最后一个 token，
+     * 		如果你需要返回此账号 id 的所有 token，请调用 getTokenValueListByLoginId
+     * </p>
+     *
      * @param loginId 账号id
-     * @param device 设备标识
+     * @param deviceType 设备类型，填 null 代表不限设备类型
      * @return token值
      */
-    public static String getTokenValueByLoginId(Object loginId, String device) {
-        return stpLogic.getTokenValueByLoginId(loginId, device);
+    public static String getTokenValueByLoginId(Object loginId, String deviceType) {
+        return stpLogic.getTokenValueByLoginId(loginId, deviceType);
     }
 
     /**
-     * 获取指定账号id的tokenValue集合
+     * 获取指定账号 id 的 token 集合
+     *
      * @param loginId 账号id
-     * @return 此loginId的所有相关token
+     * @return 此 loginId 的所有相关 token
      */
     public static List<String> getTokenValueListByLoginId(Object loginId) {
         return stpLogic.getTokenValueListByLoginId(loginId);
     }
 
     /**
-     * 获取指定账号id指定设备端的tokenValue 集合
+     * 获取指定账号 id 指定设备类型端的 token 集合
+     *
      * @param loginId 账号id
-     * @param device 设备标识
-     * @return 此loginId的所有相关token
+     * @param deviceType 设备类型，填 null 代表不限设备类型
+     * @return 此 loginId 的所有登录 token
      */
-    public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
-        return stpLogic.getTokenValueListByLoginId(loginId, device);
+    public static List<String> getTokenValueListByLoginId(Object loginId, String deviceType) {
+        return stpLogic.getTokenValueListByLoginId(loginId, deviceType);
     }
 
     /**
-     * 返回当前会话的登录设备
-     * @return 当前令牌的登录设备
+     * 获取指定账号 id 已登录设备信息集合
+     *
+     * @param loginId 账号id
+     * @return 此 loginId 的所有登录 token
      */
-    public static String getLoginDevice() {
-        return stpLogic.getLoginDevice();
+    public static List<SaTerminalInfo> getTerminalListByLoginId(Object loginId) {
+        return stpLogic.getTerminalListByLoginId(loginId);
+    }
+
+    /**
+     * 获取指定账号 id 指定设备类型端的已登录设备信息集合
+     *
+     * @param loginId 账号id
+     * @param deviceType 设备类型，填 null 代表不限设备类型
+     * @return /
+     */
+    public static List<SaTerminalInfo> getTerminalListByLoginId(Object loginId, String deviceType) {
+        return stpLogic.getTerminalListByLoginId(loginId, deviceType);
+    }
+
+    /**
+     * 获取指定账号 id 已登录设备信息集合，执行特定函数
+     *
+     * @param loginId 账号id
+     * @param function 需要执行的函数
+     */
+    public static void forEachTerminalList(Object loginId, SaTwoParamFunction<SaSession, SaTerminalInfo> function) {
+        stpLogic.forEachTerminalList(loginId, function);
+    }
+
+    /**
+     * 返回当前会话的登录设备类型
+     *
+     * @return 当前令牌的登录设备类型
+     */
+    public static String getLoginDeviceType() {
+        return stpLogic.getLoginDeviceType();
+    }
+
+    /**
+     * 返回指定 token 会话的登录设备类型
+     *
+     * @param tokenValue 指定token
+     * @return 当前令牌的登录设备类型
+     */
+    public static String getLoginDeviceTypeByToken(String tokenValue) {
+        return stpLogic.getLoginDeviceTypeByToken(tokenValue);
+    }
+
+    /**
+     * 获取当前 token 的最后活跃时间（13位时间戳），如果不存在则返回 -2
+     *
+     * @return /
+     */
+    public static long getTokenLastActiveTime() {
+        return stpLogic.getTokenLastActiveTime();
+    }
+
+    /**
+     * 判断对于指定 loginId 来讲，指定设备 id 是否为可信任设备
+     * @param deviceId /
+     * @return /
+     */
+    public static boolean isTrustDeviceId(Object userId, String deviceId) {
+        return stpLogic.isTrustDeviceId(userId, deviceId);
     }
 
 
-    // =================== 会话管理 ===================
+
+    // ------------------- 会话管理 -------------------
 
     /**
-     * 根据条件查询Token
+     * 根据条件查询缓存中所有的 token
+     *
      * @param keyword 关键字
-     * @param start 开始处索引 (-1代表查询所有)
-     * @param size 获取数量
+     * @param start 开始处索引
+     * @param size 获取数量 (-1代表一直获取到末尾)
+     * @param sortType 排序类型（true=正序，false=反序）
+     *
      * @return token集合
      */
     public static List<String> searchTokenValue(String keyword, int start, int size, boolean sortType) {
@@ -712,10 +1050,13 @@ public class StpClientUtil {
     }
 
     /**
-     * 根据条件查询SessionId
+     * 根据条件查询缓存中所有的 SessionId
+     *
      * @param keyword 关键字
-     * @param start 开始处索引 (-1代表查询所有)
-     * @param size 获取数量
+     * @param start 开始处索引
+     * @param size 获取数量  (-1代表一直获取到末尾)
+     * @param sortType 排序类型（true=正序，false=反序）
+     *
      * @return sessionId集合
      */
     public static List<String> searchSessionId(String keyword, int start, int size, boolean sortType) {
@@ -723,10 +1064,13 @@ public class StpClientUtil {
     }
 
     /**
-     * 根据条件查询Token专属Session的Id
+     * 根据条件查询缓存中所有的 Token-Session-Id
+     *
      * @param keyword 关键字
-     * @param start 开始处索引 (-1代表查询所有)
-     * @param size 获取数量
+     * @param start 开始处索引
+     * @param size 获取数量 (-1代表一直获取到末尾)
+     * @param sortType 排序类型（true=正序，false=反序）
+     *
      * @return sessionId集合
      */
     public static List<String> searchTokenSessionId(String keyword, int start, int size, boolean sortType) {
@@ -737,35 +1081,48 @@ public class StpClientUtil {
     // ------------------- 账号封禁 -------------------
 
     /**
-     * 封禁指定账号
-     * <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常
+     * 封禁：指定账号
+     * <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
+     *
      * @param loginId 指定账号id
-     * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
+     * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
      */
-    public static void disable(Object loginId, long disableTime) {
-        stpLogic.disable(loginId, disableTime);
+    public static void disable(Object loginId, long time) {
+        stpLogic.disable(loginId, time);
     }
 
     /**
-     * 指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
+     * 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
+     *
      * @param loginId 账号id
-     * @return see note
+     * @return /
      */
     public static boolean isDisable(Object loginId) {
         return stpLogic.isDisable(loginId);
     }
 
     /**
-     * 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+     * 校验：指定账号是否已被封禁，如果被封禁则抛出异常
+     *
      * @param loginId 账号id
-     * @return see note
+     */
+    public static void checkDisable(Object loginId) {
+        stpLogic.checkDisable(loginId);
+    }
+
+    /**
+     * 获取：指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+     *
+     * @param loginId 账号id
+     * @return /
      */
     public static long getDisableTime(Object loginId) {
         return stpLogic.getDisableTime(loginId);
     }
 
     /**
-     * 解封指定账号
+     * 解封：指定账号
+     *
      * @param loginId 账号id
      */
     public static void untieDisable(Object loginId) {
@@ -773,10 +1130,159 @@ public class StpClientUtil {
     }
 
 
-    // =================== 身份切换 ===================
+    // ------------------- 分类封禁 -------------------
+
+    /**
+     * 封禁：指定账号的指定服务
+     * <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
+     *
+     * @param loginId 指定账号id
+     * @param service 指定服务
+     * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
+     */
+    public static void disable(Object loginId, String service, long time) {
+        stpLogic.disable(loginId, service, time);
+    }
+
+    /**
+     * 判断：指定账号的指定服务 是否已被封禁（true=已被封禁, false=未被封禁）
+     *
+     * @param loginId 账号id
+     * @param service 指定服务
+     * @return /
+     */
+    public static boolean isDisable(Object loginId, String service) {
+        return stpLogic.isDisable(loginId, service);
+    }
+
+    /**
+     * 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
+     *
+     * @param loginId 账号id
+     * @param services 指定服务，可以指定多个
+     */
+    public static void checkDisable(Object loginId, String... services) {
+        stpLogic.checkDisable(loginId, services);
+    }
+
+    /**
+     * 获取：指定账号 指定服务 剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+     *
+     * @param loginId 账号id
+     * @param service 指定服务
+     * @return see note
+     */
+    public static long getDisableTime(Object loginId, String service) {
+        return stpLogic.getDisableTime(loginId, service);
+    }
+
+    /**
+     * 解封：指定账号、指定服务
+     *
+     * @param loginId 账号id
+     * @param services 指定服务，可以指定多个
+     */
+    public static void untieDisable(Object loginId, String... services) {
+        stpLogic.untieDisable(loginId, services);
+    }
+
+
+    // ------------------- 阶梯封禁 -------------------
+
+    /**
+     * 封禁：指定账号，并指定封禁等级
+     *
+     * @param loginId 指定账号id
+     * @param level 指定封禁等级
+     * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
+     */
+    public static void disableLevel(Object loginId, int level, long time) {
+        stpLogic.disableLevel(loginId, level, time);
+    }
+
+    /**
+     * 封禁：指定账号的指定服务，并指定封禁等级
+     *
+     * @param loginId 指定账号id
+     * @param service 指定封禁服务
+     * @param level 指定封禁等级
+     * @param time 封禁时间, 单位: 秒 （-1=永久封禁）
+     */
+    public static void disableLevel(Object loginId, String service, int level, long time) {
+        stpLogic.disableLevel(loginId, service, level, time);
+    }
+
+    /**
+     * 判断：指定账号是否已被封禁到指定等级
+     *
+     * @param loginId 指定账号id
+     * @param level 指定封禁等级
+     * @return /
+     */
+    public static boolean isDisableLevel(Object loginId, int level) {
+        return stpLogic.isDisableLevel(loginId, level);
+    }
+
+    /**
+     * 判断：指定账号的指定服务，是否已被封禁到指定等级
+     *
+     * @param loginId 指定账号id
+     * @param service 指定封禁服务
+     * @param level 指定封禁等级
+     * @return /
+     */
+    public static boolean isDisableLevel(Object loginId, String service, int level) {
+        return stpLogic.isDisableLevel(loginId, service, level);
+    }
+
+    /**
+     * 校验：指定账号是否已被封禁到指定等级（如果已经达到，则抛出异常）
+     *
+     * @param loginId 指定账号id
+     * @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
+     */
+    public static void checkDisableLevel(Object loginId, int level) {
+        stpLogic.checkDisableLevel(loginId, level);
+    }
+
+    /**
+     * 校验：指定账号的指定服务，是否已被封禁到指定等级（如果已经达到，则抛出异常）
+     *
+     * @param loginId 指定账号id
+     * @param service 指定封禁服务
+     * @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
+     */
+    public static void checkDisableLevel(Object loginId, String service, int level) {
+        stpLogic.checkDisableLevel(loginId, service, level);
+    }
+
+    /**
+     * 获取：指定账号被封禁的等级，如果未被封禁则返回-2
+     *
+     * @param loginId 指定账号id
+     * @return /
+     */
+    public static int getDisableLevel(Object loginId) {
+        return stpLogic.getDisableLevel(loginId);
+    }
+
+    /**
+     * 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
+     *
+     * @param loginId 指定账号id
+     * @param service 指定封禁服务
+     * @return /
+     */
+    public static int getDisableLevel(Object loginId, String service) {
+        return stpLogic.getDisableLevel(loginId, service);
+    }
+
+
+    // ------------------- 临时身份切换 -------------------
 
     /**
      * 临时切换身份为指定账号id
+     *
      * @param loginId 指定loginId
      */
     public static void switchTo(Object loginId) {
@@ -791,15 +1297,17 @@ public class StpClientUtil {
     }
 
     /**
-     * 当前是否正处于[身份临时切换]中
-     * @return 是否正处于[身份临时切换]中
+     * 判断当前请求是否正处于 [ 身份临时切换 ] 中
+     *
+     * @return /
      */
     public static boolean isSwitch() {
         return stpLogic.isSwitch();
     }
 
     /**
-     * 在一个代码段里方法内，临时切换身份为指定账号id
+     * 在一个 lambda 代码段里，临时切换身份为指定账号id，lambda 结束后自动恢复
+     *
      * @param loginId 指定账号id
      * @param function 要执行的方法
      */
@@ -812,6 +1320,7 @@ public class StpClientUtil {
 
     /**
      * 在当前会话 开启二级认证
+     *
      * @param safeTime 维持时间 (单位: 秒)
      */
     public static void openSafe(long safeTime) {
@@ -819,7 +1328,18 @@ public class StpClientUtil {
     }
 
     /**
-     * 当前会话 是否处于二级认证时间内
+     * 在当前会话 开启二级认证
+     *
+     * @param service 业务标识
+     * @param safeTime 维持时间 (单位: 秒)
+     */
+    public static void openSafe(String service, long safeTime) {
+        stpLogic.openSafe(service, safeTime);
+    }
+
+    /**
+     * 判断：当前会话是否处于二级认证时间内
+     *
      * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
      */
     public static boolean isSafe() {
@@ -827,20 +1347,61 @@ public class StpClientUtil {
     }
 
     /**
-     * 检查当前会话是否已通过二级认证，如未通过则抛出异常
+     * 判断：当前会话 是否处于指定业务的二级认证时间内
+     *
+     * @param service 业务标识
+     * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+     */
+    public static boolean isSafe(String service) {
+        return stpLogic.isSafe(service);
+    }
+
+    /**
+     * 判断：指定 token 是否处于二级认证时间内
+     *
+     * @param tokenValue Token 值
+     * @param service 业务标识
+     * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
+     */
+    public static boolean isSafe(String tokenValue, String service) {
+        return stpLogic.isSafe(tokenValue, service);
+    }
+
+    /**
+     * 校验：当前会话是否已通过二级认证，如未通过则抛出异常
      */
     public static void checkSafe() {
         stpLogic.checkSafe();
     }
 
     /**
-     * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
+     * 校验：检查当前会话是否已通过指定业务的二级认证，如未通过则抛出异常
+     *
+     * @param service 业务标识
+     */
+    public static void checkSafe(String service) {
+        stpLogic.checkSafe(service);
+    }
+
+    /**
+     * 获取：当前会话的二级认证剩余有效时间（单位: 秒, 返回-2代表尚未通过二级认证）
+     *
      * @return 剩余有效时间
      */
     public static long getSafeTime() {
         return stpLogic.getSafeTime();
     }
 
+    /**
+     * 获取：当前会话的二级认证剩余有效时间（单位: 秒, 返回-2代表尚未通过二级认证）
+     *
+     * @param service 业务标识
+     * @return 剩余有效时间
+     */
+    public static long getSafeTime(String service) {
+        return stpLogic.getSafeTime(service);
+    }
+
     /**
      * 在当前会话 结束二级认证
      */
@@ -848,89 +1409,50 @@ public class StpClientUtil {
         stpLogic.closeSafe();
     }
 
+    /**
+     * 在当前会话 结束指定业务标识的二级认证
+     *
+     * @param service 业务标识
+     */
+    public static void closeSafe(String service) {
+        stpLogic.closeSafe(service);
+    }
 
-    // =================== 历史API，兼容旧版本 ===================
+
+    // ------------------- Bean 对象、字段代理 -------------------
 
     /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.getLoginType() ，使用方式保持不变 </h1>
+     * 根据当前配置对象创建一个 SaLoginParameter 对象
      *
-     * 获取当前StpLogin的loginKey
-     * @return 当前StpLogin的loginKey
+     * @return /
+     */
+    public static SaLoginParameter createSaLoginParameter() {
+        return stpLogic.createSaLoginParameter();
+    }
+
+
+    // ------------------- 过期方法 -------------------
+
+    /**
+     * <h2>请更换为 getLoginDeviceType </h2>
+     * 返回当前会话的登录设备类型
+     *
+     * @return 当前令牌的登录设备类型
      */
     @Deprecated
-    public static String getLoginKey() {
-        return stpLogic.getLoginType();
+    public static String getLoginDevice() {
+        return stpLogic.getLoginDevice();
     }
 
     /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
+     * <h2>请更换为 getLoginDeviceTypeByToken </h2>
+     * 返回指定 token 会话的登录设备类型
      *
-     * 在当前会话上登录id
-     * @param loginId 登录id，建议的类型：（long | int | String）
+     * @param tokenValue 指定token
+     * @return 当前令牌的登录设备类型
      */
     @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);
-    }
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1>
-     *
-     * 会话注销，根据账号id （踢人下线）
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
-     * @param loginId 账号id
-     */
-    @Deprecated
-    public static void logoutByLoginId(Object loginId) {
-        stpLogic.kickout(loginId);
-    }
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.kickout() ，使用方式保持不变 </h1>
-     *
-     * 会话注销，根据账号id and 设备标识 （踢人下线）
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
-     * @param loginId 账号id
-     * @param device 设备标识 (填null代表所有注销设备)
-     */
-    @Deprecated
-    public static void logoutByLoginId(Object loginId, String device) {
-        stpLogic.kickout(loginId, device);
+    public static String getLoginDeviceByToken(String tokenValue) {
+        return stpLogic.getLoginDeviceByToken(tokenValue);
     }
 }
diff --git a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/core/config/AuthConfigure.java b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/core/config/AuthConfigure.java
index 957b4362..e88c828b 100644
--- a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/core/config/AuthConfigure.java
+++ b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/core/config/AuthConfigure.java
@@ -16,7 +16,7 @@ import cn.dev33.satoken.config.SaTokenConfig;
 import cn.dev33.satoken.interceptor.SaInterceptor;
 import cn.dev33.satoken.stp.StpInterface;
 import cn.dev33.satoken.stp.StpLogic;
-import cn.dev33.satoken.strategy.SaStrategy;
+import cn.dev33.satoken.strategy.SaAnnotationStrategy;
 import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.util.StrUtil;
 import jakarta.annotation.Resource;
@@ -81,7 +81,7 @@ public class AuthConfigure implements WebMvcConfigurer {
     @Autowired
     public void rewriteSaStrategy() {
         // 重写Sa-Token的注解处理器，增加注解合并功能
-        SaStrategy.instance.getAnnotation = AnnotatedElementUtils::getMergedAnnotation;
+        SaAnnotationStrategy.instance.getAnnotation = AnnotatedElementUtils::getMergedAnnotation;
     }
 
     /**
diff --git a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/auth/AuthApiProvider.java b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/auth/AuthApiProvider.java
index 3836f2f5..443abd2d 100644
--- a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/auth/AuthApiProvider.java
+++ b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/auth/AuthApiProvider.java
@@ -47,7 +47,7 @@ public class AuthApiProvider implements AuthApi {
             JSONObject jsonObject = JSONUtil.createObj();
             String userId = StrUtil.split(sessionId, StrUtil.COLON).get(3);
             SaSession saSession = StpUtil.getSessionByLoginId(userId, false);
-            int tokenCount = saSession.getTokenSignList().size();
+            int tokenCount = saSession.getTerminalList().size();
             long createTime = saSession.getCreateTime();
             jsonObject.set("userId", userId);
             jsonObject.set("tokenCount", tokenCount);
@@ -59,7 +59,7 @@ public class AuthApiProvider implements AuthApi {
             JSONObject jsonObject = JSONUtil.createObj();
             String userId = StrUtil.split(sessionId, StrUtil.COLON).get(3);
             SaSession saSession = StpClientUtil.getSessionByLoginId(userId, false);
-            int tokenCount = saSession.getTokenSignList().size();
+            int tokenCount = saSession.getTerminalList().size();
             long createTime = saSession.getCreateTime();
             jsonObject.set("userId", userId);
             jsonObject.set("tokenCount", tokenCount);
diff --git a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/listener/AuthListener.java b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/listener/AuthListener.java
index c5a15827..d38bdd15 100644
--- a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/listener/AuthListener.java
+++ b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/listener/AuthListener.java
@@ -13,7 +13,7 @@
 package vip.xiaonuo.auth.modular.login.listener;
 
 import cn.dev33.satoken.listener.SaTokenListener;
-import cn.dev33.satoken.stp.SaLoginModel;
+import cn.dev33.satoken.stp.parameter.SaLoginParameter;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.util.ObjectUtil;
 import jakarta.annotation.Resource;
@@ -43,10 +43,10 @@ public class AuthListener implements SaTokenListener {
 
     /** 每次登录时触发 */
     @Override
-    public void doLogin(String loginType, Object loginId, String tokenValue, SaLoginModel loginModel)  {
+    public void doLogin(String loginType, Object loginId, String tokenValue, SaLoginParameter loginModel)  {
         // 更新用户的登录时间和登录ip等信息
         if(SaClientTypeEnum.B.getValue().equals(loginType)) {
-            loginUserApi.updateUserLoginInfo(Convert.toStr(loginId), loginModel.getDevice());
+            loginUserApi.updateUserLoginInfo(Convert.toStr(loginId), loginModel.getDeviceType());
             // 记录B端登录日志
             Object name = loginModel.getExtra("name");
             if(ObjectUtil.isNotEmpty(name)) {
@@ -55,7 +55,7 @@ public class AuthListener implements SaTokenListener {
                 devLogApi.executeLoginLog(null);
             }
         } else {
-            clientLoginUserApi.updateUserLoginInfo(Convert.toStr(loginId), loginModel.getDevice());
+            clientLoginUserApi.updateUserLoginInfo(Convert.toStr(loginId), loginModel.getDeviceType());
         }
     }
 
@@ -123,7 +123,7 @@ public class AuthListener implements SaTokenListener {
 
     /** 每次Token续期时触发 */
     @Override
-    public void doRenewTimeout(String tokenValue, Object loginId, long timeout) {
+    public void doRenewTimeout(String loginType, Object loginId, String tokenValue, long timeout) {
         // ...
     }
 }
diff --git a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/service/impl/AuthServiceImpl.java b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/service/impl/AuthServiceImpl.java
index e2bd2b07..19eed328 100644
--- a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/service/impl/AuthServiceImpl.java
+++ b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/login/service/impl/AuthServiceImpl.java
@@ -12,8 +12,8 @@
  */
 package vip.xiaonuo.auth.modular.login.service.impl;
 
-import cn.dev33.satoken.stp.SaLoginModel;
 import cn.dev33.satoken.stp.StpUtil;
+import cn.dev33.satoken.stp.parameter.SaLoginParameter;
 import cn.hutool.captcha.CaptchaUtil;
 import cn.hutool.captcha.CircleCaptcha;
 import cn.hutool.core.collection.CollectionUtil;
@@ -751,7 +751,7 @@ public class AuthServiceImpl implements AuthService {
             throw new CommonException(AuthExceptionEnum.ACCOUNT_DISABLED.getValue());
         }
         // 执行登录
-        StpUtil.login(saBaseLoginUser.getId(), new SaLoginModel().setDevice(device).setExtra("name", saBaseLoginUser.getName()));
+        StpUtil.login(saBaseLoginUser.getId(), new SaLoginParameter().setDeviceType(device).setExtra("name", saBaseLoginUser.getName()));
         // 填充B端用户信息并更新缓存
         fillSaBaseLoginUserAndUpdateCache(saBaseLoginUser);
         // 返回token
@@ -805,7 +805,7 @@ public class AuthServiceImpl implements AuthService {
             throw new CommonException(AuthExceptionEnum.ACCOUNT_DISABLED.getValue());
         }
         // 执行登录
-        StpClientUtil.login(saBaseClientLoginUser.getId(), new SaLoginModel().setDevice(device).setExtra("name", saBaseClientLoginUser.getName()));
+        StpClientUtil.login(saBaseClientLoginUser.getId(), new SaLoginParameter().setDevice(device).setExtra("name", saBaseClientLoginUser.getName()));
         // 填充C端用户信息并更新缓存
         fillSaBaseClientLoginUserAndUpdateCache(saBaseClientLoginUser);
         // 返回token
diff --git a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/monitor/service/impl/AuthSessionServiceImpl.java b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/monitor/service/impl/AuthSessionServiceImpl.java
index 4a96b3f6..637c8ba4 100644
--- a/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/monitor/service/impl/AuthSessionServiceImpl.java
+++ b/snowy-plugin/snowy-plugin-auth/src/main/java/vip/xiaonuo/auth/modular/monitor/service/impl/AuthSessionServiceImpl.java
@@ -66,36 +66,36 @@ public class AuthSessionServiceImpl implements AuthSessionService {
             JSONObject jsonObject = JSONUtil.createObj();
             String userId = StrUtil.split(sessionId, StrUtil.COLON).get(3);
             SaSession saSession = StpUtil.getSessionByLoginId(userId, false);
-            int tokenCount = saSession.getTokenSignList().size();
+            int tokenCount = saSession.getTerminalList().size();
             long createTime = saSession.getCreateTime();
             jsonObject.set("userId", userId);
             jsonObject.set("tokenCount", tokenCount);
             jsonObject.set("createTime", DateTime.of(createTime));
             return jsonObject;
-        }).collect(Collectors.toList());
+        }).toList();
 
         List<JSONObject> sessionListC = StpClientUtil.searchSessionId("", -1, -1, true).stream().map(sessionId -> {
             JSONObject jsonObject = JSONUtil.createObj();
             String userId = StrUtil.split(sessionId, StrUtil.COLON).get(3);
             SaSession saSession = StpClientUtil.getSessionByLoginId(userId, false);
-            int tokenCount = saSession.getTokenSignList().size();
+            int tokenCount = saSession.getTerminalList().size();
             long createTime = saSession.getCreateTime();
             jsonObject.set("userId", userId);
             jsonObject.set("tokenCount", tokenCount);
             jsonObject.set("createTime", DateTime.of(createTime));
             return jsonObject;
-        }).collect(Collectors.toList());
+        }).toList();
 
         List<Integer> tokenCountList = CollectionUtil.newArrayList();
-        tokenCountList.addAll(sessionListB.stream().map(jsonObject -> jsonObject.getInt("tokenCount")).collect(Collectors.toList()));
-        tokenCountList.addAll(sessionListC.stream().map(jsonObject -> jsonObject.getInt("tokenCount")).collect(Collectors.toList()));
+        tokenCountList.addAll(sessionListB.stream().map(jsonObject -> jsonObject.getInt("tokenCount")).toList());
+        tokenCountList.addAll(sessionListC.stream().map(jsonObject -> jsonObject.getInt("tokenCount")).toList());
         CollectionUtil.sort(tokenCountList, Comparator.comparingInt(Integer::intValue));
         int currentSessionTotalCount = sessionListB.size() + sessionListC.size();
         authSessionAnalysisResult.setCurrentSessionTotalCount(Convert.toStr(currentSessionTotalCount));
         authSessionAnalysisResult.setMaxTokenCount(Convert.toStr(tokenCountList.get(tokenCountList.size() - 1)));
         List<Date> sessionCreateTimeList = CollectionUtil.newArrayList();
-        sessionCreateTimeList.addAll(sessionListB.stream().map(jsonObject -> jsonObject.getDate("createTime")).collect(Collectors.toList()));
-        sessionCreateTimeList.addAll(sessionListC.stream().map(jsonObject -> jsonObject.getDate("createTime")).collect(Collectors.toList()));
+        sessionCreateTimeList.addAll(sessionListB.stream().map(jsonObject -> jsonObject.getDate("createTime")).toList());
+        sessionCreateTimeList.addAll(sessionListC.stream().map(jsonObject -> jsonObject.getDate("createTime")).toList());
         DateTime oneHourAgo = DateUtil.offset(DateTime.now(), DateField.HOUR, -1);
         authSessionAnalysisResult.setOneHourNewlyAdded(Convert.toStr(sessionCreateTimeList.stream().filter(date -> DateUtil.compare(oneHourAgo, date) <= 0).count()));
         authSessionAnalysisResult.setProportionOfBAndC(sessionListB.size() + StrUtil.SLASH + sessionListC.size());
@@ -123,36 +123,36 @@ public class AuthSessionServiceImpl implements AuthSessionService {
                     AuthSessionPageResult authSessionPageResult = JSONUtil.toBean(userJsonObject, AuthSessionPageResult.class);
                     authSessionPageResult.setSessionId(saSession.getId());
                     authSessionPageResult.setSessionCreateTime(DateTime.of(saSession.getCreateTime()));
-                    long sessionTimeOut = saSession.getTimeout();
+                    long sessionTimeOut = saSession.timeout();
                     if (sessionTimeOut == -1) {
                         authSessionPageResult.setSessionTimeout("永久");
                     } else {
-                        authSessionPageResult.setSessionTimeout(CommonTimeFormatUtil.formatSeconds(saSession.getTimeout()));
+                        authSessionPageResult.setSessionTimeout(CommonTimeFormatUtil.formatSeconds(sessionTimeOut));
                     }
-                    List<AuthSessionPageResult.TokenSignInfo> tokenInfoList = saSession.getTokenSignList().stream()
-                            .filter(tokenSign -> {
-                                long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpUtil.stpLogic.splicingKeyTokenValue(tokenSign.getValue()));
+                    List<AuthSessionPageResult.TokenSignInfo> tokenInfoList = saSession.getTerminalList().stream()
+                            .filter(terminalInfo -> {
+                                long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpUtil.stpLogic.splicingKeyTokenValue(terminalInfo.getTokenValue()));
                                 return tokenTimeout != -2;  // 过滤掉tokenTimeout为-2的元素
                             })
-                            .map(tokenSign -> {
-                                AuthSessionPageResult.TokenSignInfo tokenSignInfo = new AuthSessionPageResult.TokenSignInfo();
-                                tokenSignInfo.setTokenValue(tokenSign.getValue());
-                                tokenSignInfo.setTokenDevice(tokenSign.getDevice());
-                                long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpUtil.stpLogic.splicingKeyTokenValue(tokenSign.getValue()));
+                            .map(terminalInfo -> {
+                                AuthSessionPageResult.TokenSignInfo terminalInfoInfo = new AuthSessionPageResult.TokenSignInfo();
+                                terminalInfoInfo.setTokenValue(terminalInfo.getTokenValue());
+                                terminalInfoInfo.setTokenDevice(terminalInfo.getDeviceType());
+                                long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpUtil.stpLogic.splicingKeyTokenValue(terminalInfo.getTokenValue()));
                                 long tokenTimeoutConfig = StpUtil.stpLogic.getConfigOrGlobal().getTimeout();
                                 if (tokenTimeout == -1) {
-                                    tokenSignInfo.setTokenTimeout("永久");
-                                    tokenSignInfo.setTokenTimeoutPercent(100d);
+                                    terminalInfoInfo.setTokenTimeout("永久");
+                                    terminalInfoInfo.setTokenTimeoutPercent(100d);
                                 } else {
-                                    tokenSignInfo.setTokenTimeout(CommonTimeFormatUtil.formatSeconds(SaManager.getSaTokenDao()
-                                            .getTimeout(StpUtil.stpLogic.splicingKeyTokenValue(tokenSign.getValue()))));
+                                    terminalInfoInfo.setTokenTimeout(CommonTimeFormatUtil.formatSeconds(SaManager.getSaTokenDao()
+                                            .getTimeout(StpUtil.stpLogic.splicingKeyTokenValue(terminalInfo.getTokenValue()))));
                                     if (tokenTimeoutConfig == -1) {
-                                        tokenSignInfo.setTokenTimeoutPercent(0d);
+                                        terminalInfoInfo.setTokenTimeoutPercent(0d);
                                     } else {
-                                        tokenSignInfo.setTokenTimeoutPercent(NumberUtil.div(tokenTimeout, tokenTimeoutConfig));
+                                        terminalInfoInfo.setTokenTimeoutPercent(NumberUtil.div(tokenTimeout, tokenTimeoutConfig));
                                     }
                                 }
-                                return tokenSignInfo;
+                                return terminalInfoInfo;
                             })
                             .collect(Collectors.toList());
                     authSessionPageResult.setTokenCount(tokenInfoList.size());
@@ -186,34 +186,34 @@ public class AuthSessionServiceImpl implements AuthSessionService {
                     AuthSessionPageResult authSessionPageResult = JSONUtil.toBean(userJsonObject, AuthSessionPageResult.class);
                     authSessionPageResult.setSessionId(saSession.getId());
                     authSessionPageResult.setSessionCreateTime(DateTime.of(saSession.getCreateTime()));
-                    long sessionTimeOut = saSession.getTimeout();
+                    long sessionTimeOut = saSession.timeout();
                     if (sessionTimeOut == -1) {
                         authSessionPageResult.setSessionTimeout("永久");
                     } else {
-                        authSessionPageResult.setSessionTimeout(CommonTimeFormatUtil.formatSeconds(saSession.getTimeout()));
+                        authSessionPageResult.setSessionTimeout(CommonTimeFormatUtil.formatSeconds(sessionTimeOut));
                     }
-                    List<AuthSessionPageResult.TokenSignInfo> tokenInfoList = saSession.getTokenSignList().stream().filter(tokenSign -> {
-                        long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpClientUtil.stpLogic.splicingKeyTokenValue(tokenSign.getValue()));
+                    List<AuthSessionPageResult.TokenSignInfo> tokenInfoList = saSession.getTerminalList().stream().filter(terminalInfo -> {
+                        long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpClientUtil.stpLogic.splicingKeyTokenValue(terminalInfo.getTokenValue()));
                         return tokenTimeout != -2;  // 过滤掉tokenTimeout为-2的元素
-                    }).map(tokenSign -> {
-                        AuthSessionPageResult.TokenSignInfo tokenSignInfo = new AuthSessionPageResult.TokenSignInfo();
-                        tokenSignInfo.setTokenValue(tokenSign.getValue());
-                        tokenSignInfo.setTokenDevice(tokenSign.getDevice());
-                        long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpClientUtil.stpLogic.splicingKeyTokenValue(tokenSign.getValue()));
+                    }).map(terminalInfo -> {
+                        AuthSessionPageResult.TokenSignInfo terminalInfoInfo = new AuthSessionPageResult.TokenSignInfo();
+                        terminalInfoInfo.setTokenValue(terminalInfo.getTokenValue());
+                        terminalInfoInfo.setTokenDevice(terminalInfo.getDeviceType());
+                        long tokenTimeout = SaManager.getSaTokenDao().getTimeout(StpClientUtil.stpLogic.splicingKeyTokenValue(terminalInfo.getTokenValue()));
                         long tokenTimeoutConfig = StpClientUtil.stpLogic.getConfigOrGlobal().getTimeout();
                         if (tokenTimeout == -1) {
-                            tokenSignInfo.setTokenTimeout("永久");
-                            tokenSignInfo.setTokenTimeoutPercent(100d);
+                            terminalInfoInfo.setTokenTimeout("永久");
+                            terminalInfoInfo.setTokenTimeoutPercent(100d);
                         } else {
-                            tokenSignInfo.setTokenTimeout(CommonTimeFormatUtil.formatSeconds(SaManager.getSaTokenDao()
-                                    .getTimeout(StpClientUtil.stpLogic.splicingKeyTokenValue(tokenSign.getValue()))));
+                            terminalInfoInfo.setTokenTimeout(CommonTimeFormatUtil.formatSeconds(SaManager.getSaTokenDao()
+                                    .getTimeout(StpClientUtil.stpLogic.splicingKeyTokenValue(terminalInfo.getTokenValue()))));
                             if (tokenTimeoutConfig == -1) {
-                                tokenSignInfo.setTokenTimeoutPercent(0d);
+                                terminalInfoInfo.setTokenTimeoutPercent(0d);
                             } else {
-                                tokenSignInfo.setTokenTimeoutPercent(NumberUtil.div(tokenTimeout, tokenTimeoutConfig));
+                                terminalInfoInfo.setTokenTimeoutPercent(NumberUtil.div(tokenTimeout, tokenTimeoutConfig));
                             }
                         }
-                        return tokenSignInfo;
+                        return terminalInfoInfo;
                     }).collect(Collectors.toList());
                     authSessionPageResult.setTokenCount(tokenInfoList.size());
                     authSessionPageResult.setTokenSignList(tokenInfoList);