完善账号封禁模块的单元测试

sa-token-core/src/main/java/cn/dev33/satoken/annotation/SaCheckDisable.java

@@ -8,7 +8,7 @@ import java.lang.annotation.Target;
 import cn.dev33.satoken.util.SaTokenConsts;
 
 /**
- * 服务禁用校验：在没有被禁用服务的情况下才可以进入方法 
+ * 服务禁用校验：在没有被禁用指定服务的情况下才可以进入方法 
  *
  * <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上）
  *

sa-token-demo/sa-token-demo-springboot-redis/src/main/java/com/pj/satoken/at/StpUserUtil.java

@@ -15,6 +15,8 @@ import cn.dev33.satoken.stp.StpLogic;
  */
 public class StpUserUtil {
 	
+	private StpUserUtil() {}
+	
 	/**
 	 * 账号类型标识 
 	 */
@@ -132,18 +134,30 @@ public class StpUserUtil {
 	}
 
 	/**
-	 * 会话登录，并指定是否 [记住我] 
-	 * @param id 账号id，建议的类型：（long | int | String）
-	 * @param isLastingCookie 是否为持久Cookie 
+	 * 会话登录，并指定是否 [记住我]
+	 *
+	 * @param id              账号id，建议的类型：（long | int | String）
+	 * @param isLastingCookie 是否为持久Cookie
 	 */
 	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的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
+	 */
+	public static void login(Object id, long timeout) {
+		stpLogic.login(id, timeout);
+	}
+
+	/**
+	 * 会话登录，并指定所有登录参数Model
+	 *
+	 * @param id         登录id，建议的类型：（long | int | String）
+	 * @param loginModel 此次登录的参数Model
 	 */
 	public static void login(Object id, SaLoginModel loginModel) {
 		stpLogic.login(id, loginModel);
@@ -410,6 +424,14 @@ public class StpUserUtil {
 		return stpLogic.getTokenSession();
 	}
 
+	/** 
+	 * 获取当前匿名 Token-Session （可在未登录情况下使用的Token-Session）
+	 * @return Token-Session 对象 
+	 */
+	public static SaSession getAnonTokenSession() {
+		return stpLogic.getAnonTokenSession();
+	}
+	
 
 	// =================== [临时有效期] 验证相关 ===================  
 
@@ -742,13 +764,24 @@ public class StpUserUtil {
 
 	/**
 	 * 封禁指定账号
-	 * <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常 
+	 * <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
 	 * @param loginId 指定账号id 
 	 * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
 	 */
 	public static void disable(Object loginId, long disableTime) {
 		stpLogic.disable(loginId, disableTime);
 	}
+
+	/**
+	 * 封禁 指定账号 指定服务 
+	 * <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
+	 * @param loginId 指定账号id 
+	 * @param service 指定服务 
+	 * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
+	 */
+	public static void disable(Object loginId, String service, long disableTime) {
+		stpLogic.disable(loginId, service, disableTime);
+	}
 	
 	/**
 	 * 指定账号是否已被封禁 (true=已被封禁, false=未被封禁) 
@@ -758,6 +791,33 @@ public class StpUserUtil {
 	public static boolean isDisable(Object loginId) {
 		return stpLogic.isDisable(loginId);
 	}
+
+	/**
+	 * 指定账号 指定服务 是否已被封禁 (true=已被封禁, false=未被封禁) 
+	 * @param loginId 账号id
+	 * @param service 指定服务 
+	 * @return see note
+	 */
+	public static boolean isDisable(Object loginId, String service) {
+		return stpLogic.isDisable(loginId, service);
+	}
+
+	/**
+	 * 校验指定账号是否已被封禁，如果被封禁则抛出异常 
+	 * @param loginId 账号id
+	 */
+	public static void checkDisable(Object loginId) {
+		stpLogic.checkDisable(loginId);
+	}
+
+	/**
+	 * 校验 指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常 
+	 * @param loginId 账号id
+	 * @param services 指定服务，可以指定多个 
+	 */
+	public static void checkDisable(Object loginId, String... services) {
+		stpLogic.checkDisable(loginId, services);
+	}
 	
 	/**
 	 * 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
@@ -768,6 +828,16 @@ public class StpUserUtil {
 		return stpLogic.getDisableTime(loginId);
 	}
 
+	/**
+	 * 获取 指定账号 指定服务 剩余封禁时间，单位：秒（-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 
@@ -775,6 +845,15 @@ public class StpUserUtil {
 	public static void untieDisable(Object loginId) {
 		stpLogic.untieDisable(loginId);
 	}
+
+	/**
+	 * 解封指定账号、指定服务
+	 * @param loginId 账号id
+	 * @param services 指定服务，可以指定多个 
+	 */
+	public static void untieDisable(Object loginId, String... services) {
+		stpLogic.untieDisable(loginId, services);
+	}
 	
 	
 	// =================== 身份切换 ===================  
@@ -852,135 +931,4 @@ public class StpUserUtil {
 		stpLogic.closeSafe();
 	}
 
-
-	// =================== 历史API，兼容旧版本 ===================  
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.getLoginType() ，使用方式保持不变 </h1>
-	 * 
-	 * 获取当前StpLogin的loginKey 
-	 * @return 当前StpLogin的loginKey
-	 */
-	@Deprecated
-	public static String getLoginKey(){
-		return stpLogic.getLoginType();
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId) {
-		stpLogic.login(loginId);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id, 并指定登录设备类型
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 * @param device 设备类型 
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId, String device) {
-		stpLogic.login(loginId, device);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id, 并指定登录设备类型
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 * @param isLastingCookie 是否为持久Cookie 
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId, boolean isLastingCookie) {
-		stpLogic.login(loginId, isLastingCookie);
-	}
-	
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id, 并指定所有登录参数Model 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 * @param loginModel 此次登录的参数Model 
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId, SaLoginModel loginModel) {
-		stpLogic.login(loginId, loginModel);
-	}
-	
-	/**
-	 * <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);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.searchTokenValue(keyword, start, size, sortType) ，使用方式保持不变 </h1>
-	 * 
-	 * 根据条件查询Token 
-	 * @param keyword 关键字 
-	 * @param start 开始处索引 (-1代表查询所有) 
-	 * @param size 获取数量 
-	 * 
-	 * @return token集合 
-	 */
-	@Deprecated
-	public static List<String> searchTokenValue(String keyword, int start, int size) {
-		return stpLogic.searchTokenValue(keyword, start, size, true);
-	}
-	
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.searchSessionId(keyword, start, size, sortType) ，使用方式保持不变 </h1>
-	 * 
-	 * 根据条件查询SessionId 
-	 * @param keyword 关键字 
-	 * @param start 开始处索引 (-1代表查询所有) 
-	 * @param size 获取数量 
-	 * 
-	 * @return sessionId集合 
-	 */
-	@Deprecated
-	public static List<String> searchSessionId(String keyword, int start, int size) {
-		return stpLogic.searchSessionId(keyword, start, size, true);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.searchTokenSessionId(keyword, start, size, sortType) ，使用方式保持不变 </h1>
-	 * 
-	 * 根据条件查询Token专属Session的Id 
-	 * @param keyword 关键字 
-	 * @param start 开始处索引 (-1代表查询所有) 
-	 * @param size 获取数量 
-	 * 
-	 * @return sessionId集合 
-	 */
-	@Deprecated
-	public static List<String> searchTokenSessionId(String keyword, int start, int size) {
-		return stpLogic.searchTokenSessionId(keyword, start, size, true);
-	}
-
 }

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

@@ -15,6 +15,8 @@ import cn.dev33.satoken.stp.StpLogic;
  */
 public class StpUserUtil {
 	
+	private StpUserUtil() {}
+	
 	/**
 	 * 账号类型标识 
 	 */
@@ -132,18 +134,30 @@ public class StpUserUtil {
 	}
 
 	/**
-	 * 会话登录，并指定是否 [记住我] 
-	 * @param id 账号id，建议的类型：（long | int | String）
-	 * @param isLastingCookie 是否为持久Cookie 
+	 * 会话登录，并指定是否 [记住我]
+	 *
+	 * @param id              账号id，建议的类型：（long | int | String）
+	 * @param isLastingCookie 是否为持久Cookie
 	 */
 	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的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
+	 */
+	public static void login(Object id, long timeout) {
+		stpLogic.login(id, timeout);
+	}
+
+	/**
+	 * 会话登录，并指定所有登录参数Model
+	 *
+	 * @param id         登录id，建议的类型：（long | int | String）
+	 * @param loginModel 此次登录的参数Model
 	 */
 	public static void login(Object id, SaLoginModel loginModel) {
 		stpLogic.login(id, loginModel);
@@ -410,6 +424,14 @@ public class StpUserUtil {
 		return stpLogic.getTokenSession();
 	}
 
+	/** 
+	 * 获取当前匿名 Token-Session （可在未登录情况下使用的Token-Session）
+	 * @return Token-Session 对象 
+	 */
+	public static SaSession getAnonTokenSession() {
+		return stpLogic.getAnonTokenSession();
+	}
+	
 
 	// =================== [临时有效期] 验证相关 ===================  
 
@@ -742,13 +764,24 @@ public class StpUserUtil {
 
 	/**
 	 * 封禁指定账号
-	 * <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常 
+	 * <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
 	 * @param loginId 指定账号id 
 	 * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
 	 */
 	public static void disable(Object loginId, long disableTime) {
 		stpLogic.disable(loginId, disableTime);
 	}
+
+	/**
+	 * 封禁 指定账号 指定服务 
+	 * <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
+	 * @param loginId 指定账号id 
+	 * @param service 指定服务 
+	 * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
+	 */
+	public static void disable(Object loginId, String service, long disableTime) {
+		stpLogic.disable(loginId, service, disableTime);
+	}
 	
 	/**
 	 * 指定账号是否已被封禁 (true=已被封禁, false=未被封禁) 
@@ -758,6 +791,33 @@ public class StpUserUtil {
 	public static boolean isDisable(Object loginId) {
 		return stpLogic.isDisable(loginId);
 	}
+
+	/**
+	 * 指定账号 指定服务 是否已被封禁 (true=已被封禁, false=未被封禁) 
+	 * @param loginId 账号id
+	 * @param service 指定服务 
+	 * @return see note
+	 */
+	public static boolean isDisable(Object loginId, String service) {
+		return stpLogic.isDisable(loginId, service);
+	}
+
+	/**
+	 * 校验指定账号是否已被封禁，如果被封禁则抛出异常 
+	 * @param loginId 账号id
+	 */
+	public static void checkDisable(Object loginId) {
+		stpLogic.checkDisable(loginId);
+	}
+
+	/**
+	 * 校验 指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常 
+	 * @param loginId 账号id
+	 * @param services 指定服务，可以指定多个 
+	 */
+	public static void checkDisable(Object loginId, String... services) {
+		stpLogic.checkDisable(loginId, services);
+	}
 	
 	/**
 	 * 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
@@ -768,6 +828,16 @@ public class StpUserUtil {
 		return stpLogic.getDisableTime(loginId);
 	}
 
+	/**
+	 * 获取 指定账号 指定服务 剩余封禁时间，单位：秒（-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 
@@ -775,6 +845,15 @@ public class StpUserUtil {
 	public static void untieDisable(Object loginId) {
 		stpLogic.untieDisable(loginId);
 	}
+
+	/**
+	 * 解封指定账号、指定服务
+	 * @param loginId 账号id
+	 * @param services 指定服务，可以指定多个 
+	 */
+	public static void untieDisable(Object loginId, String... services) {
+		stpLogic.untieDisable(loginId, services);
+	}
 	
 	
 	// =================== 身份切换 ===================  
@@ -852,135 +931,4 @@ public class StpUserUtil {
 		stpLogic.closeSafe();
 	}
 
-
-	// =================== 历史API，兼容旧版本 ===================  
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.getLoginType() ，使用方式保持不变 </h1>
-	 * 
-	 * 获取当前StpLogin的loginKey 
-	 * @return 当前StpLogin的loginKey
-	 */
-	@Deprecated
-	public static String getLoginKey(){
-		return stpLogic.getLoginType();
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId) {
-		stpLogic.login(loginId);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id, 并指定登录设备类型
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 * @param device 设备类型 
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId, String device) {
-		stpLogic.login(loginId, device);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id, 并指定登录设备类型
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 * @param isLastingCookie 是否为持久Cookie 
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId, boolean isLastingCookie) {
-		stpLogic.login(loginId, isLastingCookie);
-	}
-	
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-	 * 
-	 * 在当前会话上登录id, 并指定所有登录参数Model 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
-	 * @param loginModel 此次登录的参数Model 
-	 */
-	@Deprecated
-	public static void setLoginId(Object loginId, SaLoginModel loginModel) {
-		stpLogic.login(loginId, loginModel);
-	}
-	
-	/**
-	 * <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);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.searchTokenValue(keyword, start, size, sortType) ，使用方式保持不变 </h1>
-	 * 
-	 * 根据条件查询Token 
-	 * @param keyword 关键字 
-	 * @param start 开始处索引 (-1代表查询所有) 
-	 * @param size 获取数量 
-	 * 
-	 * @return token集合 
-	 */
-	@Deprecated
-	public static List<String> searchTokenValue(String keyword, int start, int size) {
-		return stpLogic.searchTokenValue(keyword, start, size, true);
-	}
-	
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.searchSessionId(keyword, start, size, sortType) ，使用方式保持不变 </h1>
-	 * 
-	 * 根据条件查询SessionId 
-	 * @param keyword 关键字 
-	 * @param start 开始处索引 (-1代表查询所有) 
-	 * @param size 获取数量 
-	 * 
-	 * @return sessionId集合 
-	 */
-	@Deprecated
-	public static List<String> searchSessionId(String keyword, int start, int size) {
-		return stpLogic.searchSessionId(keyword, start, size, true);
-	}
-
-	/**
-	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.searchTokenSessionId(keyword, start, size, sortType) ，使用方式保持不变 </h1>
-	 * 
-	 * 根据条件查询Token专属Session的Id 
-	 * @param keyword 关键字 
-	 * @param start 开始处索引 (-1代表查询所有) 
-	 * @param size 获取数量 
-	 * 
-	 * @return sessionId集合 
-	 */
-	@Deprecated
-	public static List<String> searchTokenSessionId(String keyword, int start, int size) {
-		return stpLogic.searchTokenSessionId(keyword, start, size, true);
-	}
-
 }

sa-token-test/sa-token-jwt-test/src/test/java/com/pj/test/JwtForMixinTest.java

@@ -207,15 +207,16 @@ public class JwtForMixinTest {
         	// 封号 
         	StpUtil.disable(10007, 200);
         	Assertions.assertTrue(StpUtil.isDisable(10007));
-        	Assertions.assertEquals(dao.get("satoken:login:disable:" + 10007), DisableServiceException.BE_VALUE); 
+        	Assertions.assertEquals(dao.get("satoken:login:disable:login:" + 10007), DisableServiceException.BE_VALUE); 
         	
         	// 解封  
         	StpUtil.untieDisable(10007);
         	Assertions.assertFalse(StpUtil.isDisable(10007));
-        	Assertions.assertEquals(dao.get("satoken:login:disable:" + 10007), null); 
+        	Assertions.assertEquals(dao.get("satoken:login:disable:login:" + 10007), null); 
         	
-        	// 封号后登陆 (会抛出 DisableLoginException 异常)
+        	// 封号后校验 (会抛出 DisableLoginException 异常)
         	StpUtil.disable(10007, 200); 
+        	StpUtil.checkDisable(10007);
         	StpUtil.login(10007);  
     	});
     }

sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/annotation/SaAnnotationController.java

@@ -3,6 +3,7 @@ package cn.dev33.satoken.integrate.annotation;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import cn.dev33.satoken.annotation.SaCheckDisable;
 import cn.dev33.satoken.annotation.SaCheckLogin;
 import cn.dev33.satoken.annotation.SaCheckPermission;
 import cn.dev33.satoken.annotation.SaCheckRole;
@@ -68,5 +69,26 @@ public class SaAnnotationController {
 	public SaResult checkSafe() {
 		return SaResult.ok();
 	}
-	
+
+	// 封禁账号 
+	@RequestMapping("disable")
+	public SaResult disable(long id) {
+		StpUtil.disable(id, "comment", 200);
+		return SaResult.ok();
+	}
+
+	// 服务封禁校验 
+	@SaCheckDisable("comment")
+	@RequestMapping("checkDisable")
+	public SaResult checkDisable() {
+		return SaResult.ok();
+	}
+
+	// 解封账号 
+	@RequestMapping("untieDisable")
+	public SaResult untieDisable(long id) {
+		StpUtil.untieDisable(id, "comment");
+		return SaResult.ok();
+	}
+
 }

sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/annotation/SaAnnotationControllerTest.java

@@ -70,6 +70,10 @@ public class SaAnnotationControllerTest {
     	// 校验二级认证，通过
     	SaResult res7 = request("/at/checkSafe?satoken=" + satoken);
     	Assertions.assertEquals(res7.getCode(), 200);
+    	
+    	// 访问校验封禁的接口 ，通过
+    	SaResult res9 = request("/at/checkDisable?satoken=" + satoken);
+    	Assertions.assertEquals(res9.getCode(), 200);
     }
 
 	// 校验不通过的情况 
@@ -99,6 +103,23 @@ public class SaAnnotationControllerTest {
     	// 校验二级认证，不通过
     	SaResult res7 = request("/at/checkSafe?satoken=" + satoken);
     	Assertions.assertEquals(res7.getCode(), 901);
+
+    	// -------- 登录拿到Token 
+    	String satoken10042 = request("/at/login?id=10042").get("token", String.class);
+    	Assertions.assertNotNull(satoken10042);
+    	
+    	// 校验账号封禁 ，通过
+    	SaResult res8 = request("/at/disable?id=10042");
+    	Assertions.assertEquals(res8.getCode(), 200);
+    	
+    	// 访问校验封禁的接口 ，不通过
+    	SaResult res9 = request("/at/checkDisable?satoken=" + satoken10042);
+    	Assertions.assertEquals(res9.getCode(), 904);
+    	
+    	// 解封后就能访问了 
+    	request("/at/untieDisable?id=10042");
+    	SaResult res10 = request("/at/checkDisable?satoken=" + satoken10042);
+    	Assertions.assertEquals(res10.getCode(), 200);
     }
 
 	// 测试忽略认证 

sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/integrate/configure/HandlerException.java

@@ -3,6 +3,7 @@ package cn.dev33.satoken.integrate.configure;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 
+import cn.dev33.satoken.exception.DisableServiceException;
 import cn.dev33.satoken.exception.IdTokenInvalidException;
 import cn.dev33.satoken.exception.NotBasicAuthException;
 import cn.dev33.satoken.exception.NotLoginException;
@@ -54,5 +55,11 @@ public class HandlerException {
 	public SaResult handlerNotBasicAuthException(NotBasicAuthException e) {
 		return SaResult.error().setCode(903);
 	}
+
+	// 服务被封禁 ，code=904
+	@ExceptionHandler(DisableServiceException.class)
+	public SaResult handlerDisableServiceException(DisableServiceException e) {
+		return SaResult.error().setCode(904);
+	}
 	
 }

sa-token-test/sa-token-springboot-test/src/test/java/cn/dev33/satoken/springboot/BasicsTest.java

@@ -359,7 +359,10 @@ public class BasicsTest {
     	// 封号 
     	StpUtil.disable(10007, 200);
     	Assertions.assertTrue(StpUtil.isDisable(10007));
-    	Assertions.assertEquals(dao.get("satoken:login:disable:" + 10007), DisableServiceException.BE_VALUE); 
+    	Assertions.assertEquals(dao.get("satoken:login:disable:login:" + 10007), DisableServiceException.BE_VALUE); 
+
+    	// 封号后检测一下 (会抛出 DisableLoginException 异常) 
+		Assertions.assertThrows(DisableServiceException.class, () -> StpUtil.checkDisable(10007));
     	
     	// 封号时间 
     	long disableTime = StpUtil.getDisableTime(10007);
@@ -368,11 +371,38 @@ public class BasicsTest {
     	// 解封  
     	StpUtil.untieDisable(10007);
     	Assertions.assertFalse(StpUtil.isDisable(10007));
-    	Assertions.assertEquals(dao.get("satoken:login:disable:" + 10007), null); 
+    	Assertions.assertEquals(dao.get("satoken:login:disable:login:" + 10007), null); 
+		Assertions.assertDoesNotThrow(() -> StpUtil.checkDisable(10007));
+    }
 
-    	// 封号后检测一下 (会抛出 DisableLoginException 异常) 
-    	StpUtil.disable(10007, 200); 
-		Assertions.assertThrows(DisableServiceException.class, () -> StpUtil.checkDisable(10007));
+    // 测试：账号封禁，根据服务 
+    @Test
+    public void testDisableService() {
+    	// 封掉评论功能 
+    	StpUtil.disable(10008, "comment", 200);
+    	Assertions.assertTrue(StpUtil.isDisable(10008, "comment"));
+    	Assertions.assertEquals(dao.get("satoken:login:disable:comment:" + 10008), DisableServiceException.BE_VALUE); 
+    	Assertions.assertNull(dao.get("satoken:login:disable:login:" + 10008)); 
+
+    	// 封号后检测一下 
+		Assertions.assertThrows(DisableServiceException.class, () -> StpUtil.checkDisable(10008, "comment"));
+		// 检查多个，有一个不通过就报异常 
+		Assertions.assertThrows(DisableServiceException.class, () -> StpUtil.checkDisable(10008, "comment", "login"));
+		
+    	// 封号时间 
+    	long disableTime = StpUtil.getDisableTime(10008, "comment");
+    	Assertions.assertTrue(disableTime <= 200 && disableTime >= 199);
+    	
+    	// 解封 (不加服务名不会成功)
+    	StpUtil.untieDisable(10008);
+    	Assertions.assertTrue(StpUtil.isDisable(10008, "comment"));
+    	Assertions.assertNotNull(dao.get("satoken:login:disable:comment:" + 10008)); 
+    	
+    	// 解封 (加服务名才会成功)
+    	StpUtil.untieDisable(10008, "comment");
+    	Assertions.assertFalse(StpUtil.isDisable(10008, "comment"));
+    	Assertions.assertEquals(dao.get("satoken:login:disable:comment:" + 10008), null); 
+		Assertions.assertDoesNotThrow(() -> StpUtil.checkDisable(10007, "comment"));
     }
 
     // 测试：身份切换