配置类重构

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

@@ -35,7 +35,7 @@ public class SaManager {
 	private static SaTokenConfig config;	
 	public static void setConfig(SaTokenConfig config) {
 		SaManager.config = config;
-		if(config.getIsV()) {
+		if(config.getIsPrint()) {
 			SaFoxUtil.printSaToken();
 		}
 		// 调用一次StpUtil中的方法，保证其可以尽早的初始化 StpLogic 

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

@@ -23,7 +23,7 @@ public class SaTokenConfig {
 	private long activityTimeout = -1;
 
 	/** 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) */
-	private Boolean allowConcurrentLogin = true;
+	private Boolean isConcurrent = true;
 
 	/** 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) */
 	private Boolean isShare = true;
@@ -56,7 +56,7 @@ public class SaTokenConfig {
 	private String tokenPrefix;
 
 	/** 是否在初始化配置时打印版本字符画 */
-	private Boolean isV = true;
+	private Boolean isPrint = true;
 
 	/** 是否打印操作日志 */
 	private Boolean isLog = false;
@@ -118,18 +118,18 @@ public class SaTokenConfig {
 	}
 
 	/**
-	 * @return 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
+	 * @return 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
 	 */
-	public Boolean getAllowConcurrentLogin() {
-		return allowConcurrentLogin;
+	public Boolean getIsConcurrent() {
+		return isConcurrent;
 	}
 
 	/**
-	 * @param allowConcurrentLogin 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
+	 * @param isConcurrent 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
 	 * @return 对象自身
 	 */
-	public SaTokenConfig setAllowConcurrentLogin(Boolean allowConcurrentLogin) {
-		this.allowConcurrentLogin = allowConcurrentLogin;
+	public SaTokenConfig setIsConcurrent(Boolean isConcurrent) {
+		this.isConcurrent = isConcurrent;
 		return this;
 	}
 
@@ -298,16 +298,16 @@ public class SaTokenConfig {
 	/**
 	 * @return 是否在初始化配置时打印版本字符画
 	 */
-	public Boolean getIsV() {
-		return isV;
+	public Boolean getIsPrint() {
+		return isPrint;
 	}
 
 	/**
-	 * @param isV 是否在初始化配置时打印版本字符画
+	 * @param isPrint 是否在初始化配置时打印版本字符画
 	 * @return 对象自身
 	 */
-	public SaTokenConfig setIsV(Boolean isV) {
-		this.isV = isV;
+	public SaTokenConfig setIsPrint(Boolean isPrint) {
+		this.isPrint = isPrint;
 		return this;
 	}
 
@@ -349,16 +349,36 @@ public class SaTokenConfig {
 	@Override
 	public String toString() {
 		return "SaTokenConfig [tokenName=" + tokenName + ", timeout=" + timeout + ", activityTimeout=" + activityTimeout
-				+ ", allowConcurrentLogin=" + allowConcurrentLogin + ", isShare=" + isShare + ", isReadBody="
+				+ ", isConcurrent=" + isConcurrent + ", isShare=" + isShare + ", isReadBody="
 				+ isReadBody + ", isReadHead=" + isReadHead + ", isReadCookie=" + isReadCookie + ", tokenStyle="
 				+ tokenStyle + ", dataRefreshPeriod=" + dataRefreshPeriod + ", tokenSessionCheckLogin="
 				+ tokenSessionCheckLogin + ", autoRenew=" + autoRenew + ", cookieDomain=" + cookieDomain
-				+ ", tokenPrefix=" + tokenPrefix + ", isV=" + isV + ", isLog=" + isLog + ", jwtSecretKey="
+				+ ", tokenPrefix=" + tokenPrefix + ", isPrint=" + isPrint + ", isLog=" + isLog + ", jwtSecretKey="
 				+ jwtSecretKey + "]";
 	}
 	
-	
 
-	
+	/**
+	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 setIsConcurrent() ，使用方式保持不变 </h1>
+	 * @param allowConcurrentLogin see note
+	 * @return  see note
+	 */
+	@Deprecated
+	public SaTokenConfig setAllowConcurrentLogin(Boolean allowConcurrentLogin) {
+		this.isConcurrent = allowConcurrentLogin;
+		return this;
+	}
+
+
+	/**
+	 * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 setIsConcurrent() ，使用方式保持不变 </h1>
+	 * @param isV see note
+	 * @return see note
+	 */
+	public SaTokenConfig setIsV(Boolean isV) {
+		this.isPrint = isV;
+		return this;
+	}
+
 
 }

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

@@ -6,7 +6,7 @@ import cn.dev33.satoken.dao.SaTokenDao;
 import cn.dev33.satoken.util.SaTokenConsts;
 
 /**
- * 调用 `StpUtil.setLogin()` 时的 [配置参数 Model ]
+ * 调用 `StpUtil.login()` 时的 [配置参数 Model ]
  * @author kong
  *
  */

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

@@ -179,41 +179,41 @@ public class StpLogic {
 	// 登录与注销 
 	
 	/**
-	 * 在当前会话上登录id 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 */
-	public void login(Object loginId) {
-		login(loginId, new SaLoginModel());
+	public void login(Object id) {
+		login(id, new SaLoginModel());
 	}
 
 	/**
-	 * 在当前会话上登录id, 并指定登录设备 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录，并指定登录设备 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 * @param device 设备标识 
 	 */
-	public void login(Object loginId, String device) {
-		login(loginId, new SaLoginModel().setDevice(device));
+	public void login(Object id, String device) {
+		login(id, new SaLoginModel().setDevice(device));
 	}
 
 	/**
-	 * 在当前会话上登录id, 并指定登录设备 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录，并指定是否 [记住我] 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 * @param isLastingCookie 是否为持久Cookie 
 	 */
-	public void login(Object loginId, boolean isLastingCookie) {
-		login(loginId, new SaLoginModel().setIsLastingCookie(isLastingCookie));
+	public void login(Object id, boolean isLastingCookie) {
+		login(id, new SaLoginModel().setIsLastingCookie(isLastingCookie));
 	}
 	
 	/**
-	 * 在当前会话上登录id, 并指定所有登录参数Model 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录，并指定所有登录参数Model 
+	 * @param id 登录id，建议的类型：（long | int | String）
 	 * @param loginModel 此次登录的参数Model 
 	 */
-	public void login(Object loginId, SaLoginModel loginModel) {
+	public void login(Object id, SaLoginModel loginModel) {
 		
 		// ------ 0、检查此账号是否已被封禁 
-		if(isDisable(loginId)) {
-			throw new DisableLoginException(loginType, loginId, getDisableTime(loginId));
+		if(isDisable(id)) {
+			throw new DisableLoginException(loginType, id, getDisableTime(id));
 		}
 		
 		// ------ 1、获取相应对象  
@@ -224,15 +224,15 @@ public class StpLogic {
 		// ------ 2、生成一个token 
 		String tokenValue = null;
 		// --- 如果允许并发登录 
-		if(config.getAllowConcurrentLogin()) {
+		if(config.getIsConcurrent()) {
 			// 如果配置为共享token, 则尝试从Session签名记录里取出token 
 			if(config.getIsShare()) {
-				tokenValue = getTokenValueByLoginId(loginId, loginModel.getDevice());
+				tokenValue = getTokenValueByLoginId(id, loginModel.getDevice());
 			}
 		} else {
 			// --- 如果不允许并发登录 
 			// 如果此时[user-session]不为null，说明此账号在其他地正在登录，现在需要先把其它地的同设备token标记为被顶下线 
-			SaSession session = getSessionByLoginId(loginId, false);
+			SaSession session = getSessionByLoginId(id, false);
 			if(session != null) {
 				List<TokenSign> tokenSignList = session.getTokenSignList();
 				for (TokenSign tokenSign : tokenSignList) {
@@ -244,20 +244,20 @@ public class StpLogic {
 						// 3. 清理user-session上的token签名记录 
 						session.removeTokenSign(tokenSign.getValue()); 		
 				 		// $$ 通知监听器 
-				 		SaManager.getSaTokenListener().doReplaced(loginType, loginId, tokenSign.getValue(), tokenSign.getDevice());
+				 		SaManager.getSaTokenListener().doReplaced(loginType, id, tokenSign.getValue(), tokenSign.getDevice());
 					}
 				}
 			}
 		}
 		// 如果至此，仍未成功创建tokenValue, 则开始生成一个 
 		if(tokenValue == null) {
-			tokenValue = createTokenValue(loginId);
+			tokenValue = createTokenValue(id);
 		}
 		
 		// ------ 3. 获取[User-Session] (如果还没有创建session, 则新建, 如果已经创建，则续期) 
-		SaSession session = getSessionByLoginId(loginId, false);
+		SaSession session = getSessionByLoginId(id, false);
 		if(session == null) {
-			session = getSessionByLoginId(loginId);
+			session = getSessionByLoginId(id);
 		} else {
 			session.updateMinTimeout(loginModel.getTimeout());
 		}
@@ -266,7 +266,7 @@ public class StpLogic {
 		
 		// ------ 4. 持久化其它数据 
 		// token -> uid 
-		dao.set(splicingKeyTokenValue(tokenValue), String.valueOf(loginId), loginModel.getTimeout());
+		dao.set(splicingKeyTokenValue(tokenValue), String.valueOf(id), loginModel.getTimeout());
 		
 		// 写入 [最后操作时间]
 		setLastActivityToNow(tokenValue); 
@@ -275,7 +275,7 @@ public class StpLogic {
 		setTokenValue(tokenValue, loginModel.getCookieTimeout());
 		
 		// $$ 通知监听器
-		SaManager.getSaTokenListener().doLogin(loginType, loginId, loginModel);
+		SaManager.getSaTokenListener().doLogin(loginType, id, loginModel);
 	}
 
 	/** 
@@ -327,7 +327,7 @@ public class StpLogic {
 	}
 	
 	/**
-	 * 指定loginId的会话注销登录（踢人下线）
+	 * 指定账号id的会话注销登录（踢人下线）
 	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
 	 * @param loginId 账号id 
 	 */
@@ -336,7 +336,7 @@ public class StpLogic {
 	}
 	
 	/**
-	 * 指定loginId指定设备的会话注销登录（踢人下线）
+	 * 指定账号id指定设备的会话注销登录（踢人下线）
 	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
 	 * @param loginId 账号id 
 	 * @param device 设备标识 (填null代表所有注销设备) 

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

@@ -6,7 +6,7 @@ import cn.dev33.satoken.fun.SaFunction;
 import cn.dev33.satoken.session.SaSession;
 
 /**
- * Sa-Token 权限验证, 工具类 
+ * Sa-Token 权限验证工具类 
  * @author kong 
  */
 public class StpUtil {
@@ -69,38 +69,38 @@ public class StpUtil {
 	// =================== 登录相关操作 ===================
 
 	/**
-	 * 在当前会话上登录id 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 */
-	public static void login(Object loginId) {
-		stpLogic.login(loginId);
+	public static void login(Object id) {
+		stpLogic.login(id);
 	}
 
 	/**
-	 * 在当前会话上登录id, 并指定登录设备 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录，并指定登录设备 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 * @param device 设备标识 
 	 */
-	public static void login(Object loginId, String device) {
-		stpLogic.login(loginId, device);
+	public static void login(Object id, String device) {
+		stpLogic.login(id, device);
 	}
 
 	/**
-	 * 在当前会话上登录id, 并指定登录设备 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录，并指定是否 [记住我] 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 * @param isLastingCookie 是否为持久Cookie 
 	 */
-	public static void login(Object loginId, boolean isLastingCookie) {
-		stpLogic.login(loginId, isLastingCookie);
+	public static void login(Object id, boolean isLastingCookie) {
+		stpLogic.login(id, isLastingCookie);
 	}
-	
+
 	/**
-	 * 在当前会话上登录id, 并指定所有登录参数Model 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录，并指定所有登录参数Model 
+	 * @param id 登录id，建议的类型：（long | int | String）
 	 * @param loginModel 此次登录的参数Model 
 	 */
-	public static void login(Object loginId, SaLoginModel loginModel) {
-		stpLogic.login(loginId, loginModel);
+	public static void login(Object id, SaLoginModel loginModel) {
+		stpLogic.login(id, loginModel);
 	}
 	
 	/** 
@@ -119,7 +119,7 @@ public class StpUtil {
 	}
 	
 	/**
-	 * 指定loginId的会话注销登录（踢人下线）
+	 * 指定账号id的会话注销登录（踢人下线）
 	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
 	 * @param loginId 账号id 
 	 */
@@ -128,7 +128,7 @@ public class StpUtil {
 	}
 
 	/**
-	 * 指定loginId指定设备的会话注销登录（踢人下线）
+	 * 指定账号id指定设备的会话注销登录（踢人下线）
 	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
 	 * @param loginId 账号id 
 	 * @param device 设备标识 

sa-token-demo/sa-token-demo-springboot/src/main/java/com/pj/SaTokenDemoApplication.java

@@ -16,6 +16,7 @@ public class SaTokenDemoApplication {
 	public static void main(String[] args) {
 		SpringApplication.run(SaTokenDemoApplication.class, args);
 		System.out.println("\n启动成功：sa-token配置如下：" + SaManager.getConfig());
+		System.out.println("\n启动成功：sa-token配置如下：" + SaManager.getConfig().getIsConcurrent());
 	}
 	
 }

sa-token-demo/sa-token-demo-springboot/src/main/resources/application.yml

@@ -12,7 +12,7 @@ spring:
         # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
         activity-timeout: -1
         # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
-        allow-concurrent-login: true
+        is-concurrent: false
         # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) 
         is-share: true
         # token风格
@@ -20,6 +20,8 @@ spring:
         # 是否输出操作日志 
         is-log: false
         
+        is-print: false
+        
     # redis配置 
     redis:
         # Redis数据库索引（默认为0）

sa-token-doc/doc/more/common-questions.md

@@ -13,7 +13,7 @@
 
 
 ### 登录方法需要我自己实现吗？
-是的，不同于`shiro`等框架，`sa-token`不会在登录流程中强插一脚，开发者比对完用户的账号和密码之后，只需要调用`StpUtil.setLogin(id)`通知一下框架即可
+是的，不同于`shiro`等框架，`sa-token`不会在登录流程中强插一脚，开发者比对完用户的账号和密码之后，只需要调用`StpUtil.login(id)`通知一下框架即可
 
 
 ### 一个User对象存进Session后，再取出来时报错：无法从User类型转换成User类型？