⚡ v1.22.0 更新

Update pom.xml

.gitignore

@@ -11,4 +11,5 @@ unpackage/
 .factorypath
 /.factorypath
 
-.idea/
+.idea/
+

LICENSE

@@ -199,3 +199,4 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+

README.md

@@ -1,9 +1,9 @@
 <p align="center">
 	<img alt="logo" src="https://gitee.com/dromara/sa-token/raw/master/sa-token-doc/doc/logo.png" width="150" height="150">
 </p>
-<h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">sa-token v1.17.0</h1>
+<h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">Sa-Token v1.22.0</h1>
 <h4 align="center">这可能是史上功能最全的 Java 权限认证框架！</h4>
-<h4 align="center">
+<p align="center">
 	<a href="https://gitee.com/dromara/sa-token/stargazers"><img src="https://gitee.com/dromara/sa-token/badge/star.svg"></a>
 	<a href="https://gitee.com/dromara/sa-token/members"><img src="https://gitee.com/dromara/sa-token/badge/fork.svg"></a>
 	<a href="https://github.com/dromara/sa-token/stargazers"><img src="https://img.shields.io/github/stars/dromara/sa-token?style=flat-square&logo=GitHub"></a>
@@ -11,57 +11,48 @@
 	<a href="https://github.com/dromara/sa-token/watchers"><img src="https://img.shields.io/github/watchers/dromara/sa-token?style=flat-square&logo=GitHub"></a>
 	<a href="https://github.com/dromara/sa-token/issues"><img src="https://img.shields.io/github/issues/dromara/sa-token.svg?style=flat-square&logo=GitHub"></a>
 	<a href="https://github.com/dromara/sa-token/blob/master/LICENSE"><img src="https://img.shields.io/github/license/dromara/sa-token.svg?style=flat-square"></a>
-</h4>
+</p>
 
 ---
 
 
 ## 在线资料
 
-- [官网首页：http://sa-token.dev33.cn/](http://sa-token.dev33.cn/)
-
-- [在线文档：http://sa-token.dev33.cn/doc/index.html](http://sa-token.dev33.cn/doc/index.html)
+- [在线文档：http://sa-token.dev33.cn/](http://sa-token.dev33.cn/)
 
 - [需求提交：我们深知一个优秀的项目需要海纳百川，点我在线提交需求](http://sa-app.dev33.cn/wall.html?name=sa-token)
 
 - [开源不易，求鼓励，点个star吧 ！](###)
 
 
-## Sa-Token是什么？
+## Sa-Token 是什么？
 Sa-Token是一个轻量级Java权限认证框架，主要解决：登录认证、权限认证、Session会话、单点登录、OAuth2.0 等一系列权限相关问题
 
-框架针对踢人下线、自动续签、前后台分离、分布式会话……等常见业务进行N多适配，通过sa-token，你可以以一种极简的方式实现系统的权限认证部分
-
-与其它权限认证框架相比，`sa-token` 具有以下优势：
-1. **简单** ：可零配置启动框架，真正的开箱即用，低成本上手
-2. **强大** ：目前已集成几十项权限相关特性，涵盖了大部分业务场景的解决方案
-3. **易用** ：如丝般顺滑的API调用，大量高级特性统统只需一行代码即可实现
-4. **高扩展** ：几乎所有组件都提供了扩展接口，90%以上的逻辑都可以按需重写
-
-有了sa-token，你所有的权限认证问题，都不再是问题！
+框架集成简单、开箱即用、API设计清爽，通过Sa-Token，你将以一种极其简单的方式实现系统的权限认证部分
 
 ## Sa-Token 能做什么？
 
-![sa-token-js](https://oss.dev33.cn/sa-token/doc/sa-token-js.png 's-w')
-
-- **登录验证** —— 轻松登录鉴权，并提供五种细分场景值
-- **权限验证** —— 适配RBAC权限模型，不同角色不同授权
-- **Session会话** —— 专业的数据缓存中心
-- **踢人下线** —— 将违规用户立刻清退下线
-- **账号封禁** —— 封禁指定账号，使其无法登陆，还可指定解封时间
+- **登录验证** —— 单端登录、多端登录、同端互斥登录、七天内免登录
+- **权限验证** —— 权限认证、角色认证、会话二级认证
+- **Session会话** —— 全端共享Session、单端独享Session、自定义Session 
+- **踢人下线** —— 根据账号id踢人下线、根据Token值踢人下线
+- **账号封禁** —— 指定天数封禁、永久封禁、设定解封时间 
 - **持久层扩展** —— 可集成Redis、Memcached等专业缓存中间件，重启数据不丢失
-- **分布式会话** —— 提供jwt集成和共享数据中心两种分布式会话方案
-- **微服务网关鉴权** —— 适配Gateway、Soul、Zuul等常见网关组件的请求拦截认证
-- **单点登录** —— 一处登录，处处通行
+- **分布式会话** —— 提供jwt集成、共享数据中心两种分布式会话方案
+- **微服务网关鉴权** —— 适配Gateway、Soul、Zuul等常见网关的路由拦截认证
+- **单点登录** —— 内置三种单点登录模式：无论是否跨域、是否共享Redis，都可以搞定
+- **二级认证** —— 在已登录的基础上再次认证，保证安全性 
+- **独立Redis** —— 将权限缓存与业务缓存分离 
+- **临时Token验证** —— 解决短时间的Token授权问题
 - **模拟他人账号** —— 实时操作任意用户状态数据
 - **临时身份切换** —— 将会话身份临时切换为其它账号
-- **无Cookie模式** —— APP、小程序等前后台分离场景
+- **前后台分离** —— APP、小程序等不支持Cookie的终端
 - **同端互斥登录** —— 像QQ一样手机电脑同时在线，但是两个手机上互斥登录
 - **多账号认证体系** —— 比如一个商城项目的user表和admin表分开鉴权
-- **花式token生成** —— 内置六种token风格，还可自定义token生成策略
+- **花式token生成** —— 内置六种Token风格，还可：自定义Token生成策略、自定义Token前缀
 - **注解式鉴权** —— 优雅的将鉴权与业务代码分离
 - **路由拦截式鉴权** —— 根据路由拦截鉴权，可适配restful模式
-- **自动续签** —— 提供两种token过期策略，灵活搭配使用，还可自动续签
+- **自动续签** —— 提供两种Token过期策略，灵活搭配使用，还可自动续签
 - **会话治理** —— 提供方便灵活的会话查询接口
 - **记住我模式** —— 适配[记住我]模式，重启浏览器免验证
 - **密码加密** —— 提供密码加密模块，可快速MD5、SHA1、SHA256、AES、RSA加密 
@@ -69,26 +60,58 @@ Sa-Token是一个轻量级Java权限认证框架，主要解决：登录认证
 - **开箱即用** —— 提供SpringMVC、WebFlux等常见web框架starter集成包，真正的开箱即用
 - **更多功能正在集成中...** —— 如有您有好想法或者建议，欢迎加群交流
 
+##### Sa-Token 功能结构图
+![sa-token-js](https://color-test.oss-cn-qingdao.aliyuncs.com/sa-token/x/sa-token-js2.png 's-w')
+
+##### Sa-Token 认证流程图
+![sa-token-rz](https://color-test.oss-cn-qingdao.aliyuncs.com/sa-token/x/sa-token-rz2.png 's-w')
+
+
+## Sa-Token-SSO 单点登录
+对于单点登录，网上教程大多以CAS模式为主，其实对于不同的系统架构，实现单点登录的步骤也大为不同，Sa-Token由简入难将其划分为三种模式：
+
+| 系统架构						| 采用模式	| 简介						|  文档链接	|
+| :--------						| :--------	| :--------					| :--------	|
+| 前端同域 + 后端同 Redis		| 模式一		| 共享Cookie同步会话			| [文档](http://sa-token.dev33.cn/doc/index.html#/sso/sso-type1)、[示例](https://gitee.com/dromara/sa-token/blob/dev/sa-token-demo/sa-token-demo-sso1)	|
+| 前端不同域 + 后端同 Redis		| 模式二		| URL重定向传播会话 			| [文档](http://sa-token.dev33.cn/doc/index.html#/sso/sso-type2)、[示例](https://gitee.com/dromara/sa-token/blob/dev/sa-token-demo/sa-token-demo-sso2-server)	|
+| 前端不同域 + 后端 不同Redis	| 模式三		| Http请求获取会话			| [文档](http://sa-token.dev33.cn/doc/index.html#/sso/sso-type3)、[示例](https://gitee.com/dromara/sa-token/blob/dev/sa-token-demo/sa-token-demo-sso3-server)	|
+
+
+1. 前端同域：就是指多个系统可以部署在同一个主域名之下，比如：`c1.domain.com`、`c2.domain.com`、`c3.domain.com`
+2. 后端同Redis：就是指多个系统可以连接同一个Redis，其它的缓存数据中心亦可。PS：这里并不需要把所有项目的数据都放在同一个Redis中，Sa-Token提供了 **`[权限缓存与业务缓存分离]`** 的解决方案，详情戳：[Alone独立Redis插件](http://sa-token.dev33.cn/doc/index.html#/plugin/alone-redis)
+3. 如果既无法做到前端同域，也无法做到后端同Redis，那么只能走模式三，Http请求获取会话（Sa-Token对SSO提供了完整的封装，你只需要按照示例从文档上复制几段代码便可以轻松集成）
+4. 技术选型一定要根据系统架构对症下药，切不可胡乱选择 
+
+
+## Sa-Token-SSO 特性
+1. API简单易用，文档介绍详细，且提供直接可用的集成示例
+2. 支持三种模式，不论是否跨域、是否共享Redis，都可以完美解决
+3. 安全性高：内置域名校验、Ticket校验、秘钥校验等，杜绝`Ticket劫持`、`Token窃取`等常见攻击手段（文档讲述攻击原理和防御手段）
+4. 不丢参数：笔者曾试验多个单点登录框架，均有参数丢失的情况，比如重定向之前是：`http://a.com?id=1&name=2`，登录成功之后就变成了：`http://a.com?id=1`，Sa-Token-SSO内有专门的算法保证了参数不丢失，登录成功之后原路返回页面
+5. 无缝集成：由于Sa-Token本身就是一个权限认证框架，因此你可以只用一个框架同时解决`权限认证` + `单点登录`问题，让你不再到处搜索：xxx单点登录与xxx权限认证如何整合……
+6. 高可定制：Sa-Token-SSO模块对代码架构侵入性极低，结合Sa-Token本身的路由拦截特性，你可以非常轻松的定制化开发 
+
+
 
 ## 代码示例
 
-sa-token的API调用非常简单，有多简单呢？以登录验证为例，你只需要：
+Sa-Token的API调用非常简单，有多简单呢？以登录验证为例，你只需要：
 
 ``` java
 // 在登录时写入当前会话的账号id
-StpUtil.setLoginId(10001);
+StpUtil.login(10001);
 
 // 然后在任意需要校验登录处调用以下API
 // 如果当前会话未登录，这句代码会抛出 `NotLoginException`异常
 StpUtil.checkLogin();
 ```
-至此，我们已经借助sa-token框架完成登录授权！
+至此，我们已经借助Sa-Token框架完成登录授权！
 
 此时的你小脑袋可能飘满了问号，就这么简单？自定义Realm呢？全局过滤器呢？我不用写各种配置文件吗？
 
-事实上在此我可以负责的告诉你，在sa-token中，登录授权就是如此的简单，不需要什么全局过滤器，不需要各种乱七八糟的配置！只需要这一行简单的API调用，即可完成会话的登录授权！
+事实上在此我可以负责的告诉你，在Sa-Token中，登录授权就是如此的简单，不需要什么全局过滤器，不需要各种乱七八糟的配置！只需要这一行简单的API调用，即可完成会话的登录授权！
 
-当你受够Shiro、Security等框架的三拜九叩之后，你就会明白，相对于这些传统老牌框架，sa-token的API设计是多么的清爽！
+当你受够Shiro、Spring Security等框架的三拜九叩之后，你就会明白，相对于这些传统老牌框架，Sa-Token的API设计是多么的清爽！
 
 权限认证示例 (只有具有`user:add`权限的会话才可以进入请求)
 ``` java
@@ -106,9 +129,9 @@ public String insert(SysUser user) {
 StpUtil.logoutByLoginId(10001);
 ```
 
-除了以上的示例，sa-token还可以一行代码完成以下功能：
+除了以上的示例，Sa-Token还可以一行代码完成以下功能：
 ``` java
-StpUtil.setLoginId(10001);                // 标记当前会话登录的账号id
+StpUtil.login(10001);                     // 标记当前会话登录的账号id
 StpUtil.getLoginId();                     // 获取当前会话登录的账号id
 StpUtil.isLogin();                        // 获取当前会话是否已经登录, 返回true或false
 StpUtil.logout();                         // 当前会话注销登录
@@ -118,11 +141,11 @@ StpUtil.hasPermission("user:add");        // 查询当前账号是否含有指
 StpUtil.getSession();                     // 获取当前账号id的Session
 StpUtil.getSessionByLoginId(10001);       // 获取账号id为10001的Session
 StpUtil.getTokenValueByLoginId(10001);    // 获取账号id为10001的token令牌值
-StpUtil.setLoginId(10001, "PC");          // 指定设备标识登录
+StpUtil.login(10001, "PC");               // 指定设备标识登录
 StpUtil.logoutByLoginId(10001, "PC");     // 指定设备标识进行强制注销 (不同端不受影响)
 StpUtil.switchTo(10044);                  // 将当前会话身份临时切换为其它账号
 ```
-sa-token API 众多，请恕此处无法为您逐一展示，更多示例请戳官方在线文档
+Sa-Token API 众多，请恕此处无法为您逐一展示，更多示例请戳官方在线文档
 
 
 ## Star 趋势
@@ -133,7 +156,7 @@ sa-token API 众多，请恕此处无法为您逐一展示，更多示例请戳
 
 ## 参与贡献
 众人拾柴火焰高，万丈高楼众人起！
-sa-token秉承着开放的思想，欢迎大家为框架添砖加瓦：
+Sa-Token秉承着开放的思想，欢迎大家为框架添砖加瓦：
 
 1. 核心代码：该部分需要开发者了解整个框架的架构，遵循已有代码规范进行bug修复或提交新功能
 2. 文档部分：需要以清晰明了的语句书写文档，力求简单易读，授人以鱼同时更授人以渔
@@ -142,16 +165,17 @@ sa-token秉承着开放的思想，欢迎大家为框架添砖加瓦：
 5. 其它部分：您可以参考项目issues与需求墙进行贡献
 
 作者寄语：参与贡献不光只有提交代码，点一个star、提一个issues都是对开源项目的促进，
-如果sa-token帮助到了你，欢迎你把框架推荐给朋友、同事使用，为sa-token的推广做一份贡献
+如果Sa-Token帮助到了你，欢迎你把框架推荐给朋友、同事使用，为Sa-Token的推广做一份贡献
 
 
-## 使用sa-token的开源项目
-[**[ sa-plus]** 一个基于springboot架构的快速开发框架，内置代码生成器](https://gitee.com/click33/sa-plus)
+## 使用Sa-Token的开源项目
+[**[ sa-plus ]** 一个基于springboot架构的快速开发框架，内置代码生成器](https://gitee.com/click33/sa-plus)
 
-[**[ jthink]** 一个基于springboot+sa-token+thymeleaf的博客系统](https://gitee.com/wtsoftware/jthink)
+[**[ jthink ]** 一个基于springboot+sa-token+thymeleaf的博客系统](https://gitee.com/wtsoftware/jthink)
 
+[**[ dcy-fast ]** 一个基于springboot+sa-token+mybatis-plus的后台管理系统，前端vue-element-admin，并且内置代码生成器](https://gitee.com/dcy421/dcy-fast)
 
-如果您的项目使用了sa-token，欢迎提交pr
+如果您的项目使用了Sa-Token，欢迎提交pr
 
 
 ## 友情链接

mvn clean.bat

@@ -1,6 +1,10 @@
 
+:: 整体clean
 call mvn clean
 
+:: demo模块clean
+cd sa-token-demo
+
 cd sa-token-demo-jwt
 call mvn clean
 cd ..
@@ -13,14 +17,55 @@ cd sa-token-demo-webflux
 call mvn clean
 cd ..
 
-cd sa-token-demo-oauth2\sa-token-demo-oauth2-client
+cd sa-token-demo-solon
 call mvn clean
-cd ../..
+cd ..
 
-cd sa-token-demo-oauth2\sa-token-demo-oauth2-server
+cd sa-token-demo-oauth2-client
 call mvn clean
-cd ../..
+cd ..
 
+cd sa-token-demo-oauth2-server
+call mvn clean
+cd ..
+
+cd sa-token-demo-quick-login
+call mvn clean
+cd ..
+
+cd sa-token-demo-alone-redis
+call mvn clean
+cd ..
+
+cd sa-token-demo-sso1
+call mvn clean
+cd ..
+
+cd sa-token-demo-sso2-server
+call mvn clean
+cd ..
+
+cd sa-token-demo-sso2-client
+call mvn clean
+cd ..
+
+cd sa-token-demo-sso3-server
+call mvn clean
+cd ..
+
+cd sa-token-demo-sso3-client
+call mvn clean
+cd ..
+
+
+
+
+
+
+
+cd ..
+
+:: 最后打印
 echo;
 echo;
 echo ----------- clean end ----------- 

pom.xml

@@ -8,7 +8,7 @@
     <groupId>cn.dev33</groupId>
     <artifactId>sa-token-parent</artifactId>
 	<packaging>pom</packaging>
-	<version>1.17.0</version>
+	<version>1.22.0</version>
 	
 	<!-- 项目介绍 -->
 	<name>sa-token</name>
@@ -19,13 +19,9 @@
 	<!-- 所有模块 -->
 	<modules>
 		<module>sa-token-core</module>
-		<module>sa-token-servlet</module>
-		<module>sa-token-spring-boot-starter</module>
-		<module>sa-token-reactor-spring-boot-starter</module>
-		<module>sa-token-dao-redis</module>
-		<module>sa-token-dao-redis-jackson</module>
-		<module>sa-token-spring-aop</module>
-		<!-- <module>sa-token-oauth2</module> -->
+		<module>sa-token-starter</module>
+		<module>sa-token-plugin</module>
+		<!-- <module>sa-token-demo/sa-token-demo-solon</module> -->
 	</modules>
 	
 	<!-- 开源协议 apache 2.0 -->
@@ -40,7 +36,7 @@
 	
 	<!-- 一些属性 -->
 	<properties>
-		<sa-token-version>1.17.0</sa-token-version>
+		<sa-token-version>1.22.0</sa-token-version>
         <jdk.version>1.8</jdk.version>
 		<project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
 		<project.reporting.outputEncoding>utf-8</project.reporting.outputEncoding>

sa-token-core/pom.xml

@@ -7,7 +7,7 @@
 	<parent>
         <groupId>cn.dev33</groupId>
         <artifactId>sa-token-parent</artifactId>
-        <version>1.17.0</version>
+        <version>1.22.0</version>
     </parent>
     <packaging>jar</packaging>
 
@@ -16,7 +16,7 @@
 	<description>A Java Web lightweight authority authentication framework, comprehensive function, easy to use</description>
 
 	<dependencies>
-		<!-- Zero dependence！ -->
+		<!-- Zero dependence -->
 	</dependencies>
 
 

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

@@ -11,33 +11,39 @@ import cn.dev33.satoken.context.SaTokenContext;
 import cn.dev33.satoken.context.SaTokenContextDefaultImpl;
 import cn.dev33.satoken.dao.SaTokenDao;
 import cn.dev33.satoken.dao.SaTokenDaoDefaultImpl;
+import cn.dev33.satoken.exception.SaTokenException;
 import cn.dev33.satoken.listener.SaTokenListener;
 import cn.dev33.satoken.listener.SaTokenListenerDefaultImpl;
 import cn.dev33.satoken.stp.StpInterface;
 import cn.dev33.satoken.stp.StpInterfaceDefaultImpl;
 import cn.dev33.satoken.stp.StpLogic;
-import cn.dev33.satoken.util.SaTokenInsideUtil;
+import cn.dev33.satoken.stp.StpUtil;
+import cn.dev33.satoken.temp.SaTempInterface;
+import cn.dev33.satoken.temp.SaTempDefaultImpl;
+import cn.dev33.satoken.util.SaFoxUtil;
 
 /**
- * 管理sa-token所有接口对象 
+ * 管理 Sa-Token 所有接口对象 
  * @author kong
  *
  */
-public class SaTokenManager {
+public class SaManager {
 
 	/**
 	 * 配置文件 Bean 
 	 */
-	private static SaTokenConfig config;	
+	public static SaTokenConfig config;	
 	public static void setConfig(SaTokenConfig config) {
-		SaTokenManager.config = config;
-		if(config.getIsV()) {
-			SaTokenInsideUtil.printSaToken();
+		SaManager.config = config;
+		if(config.getIsPrint()) {
+			SaFoxUtil.printSaToken();
 		}
+		// 调用一次StpUtil中的方法，保证其可以尽早的初始化 StpLogic 
+		StpUtil.getLoginType();
 	}
 	public static SaTokenConfig getConfig() {
 		if (config == null) {
-			synchronized (SaTokenManager.class) {
+			synchronized (SaManager.class) {
 				if (config == null) {
 					setConfig(SaTokenConfigFactory.createConfig());
 				}
@@ -51,14 +57,14 @@ public class SaTokenManager {
 	 */
 	private static SaTokenDao saTokenDao;
 	public static void setSaTokenDao(SaTokenDao saTokenDao) {
-		if(SaTokenManager.saTokenDao != null && (SaTokenManager.saTokenDao instanceof SaTokenDaoDefaultImpl)) {
-			((SaTokenDaoDefaultImpl)SaTokenManager.saTokenDao).endRefreshThread();
+		if((SaManager.saTokenDao instanceof SaTokenDaoDefaultImpl)) {
+			((SaTokenDaoDefaultImpl)SaManager.saTokenDao).endRefreshThread();
 		}
-		SaTokenManager.saTokenDao = saTokenDao;
+		SaManager.saTokenDao = saTokenDao;
 	}
 	public static SaTokenDao getSaTokenDao() {
 		if (saTokenDao == null) {
-			synchronized (SaTokenManager.class) {
+			synchronized (SaManager.class) {
 				if (saTokenDao == null) {
 					setSaTokenDao(new SaTokenDaoDefaultImpl());
 				}
@@ -72,11 +78,11 @@ public class SaTokenManager {
 	 */
 	private static StpInterface stpInterface;
 	public static void setStpInterface(StpInterface stpInterface) {
-		SaTokenManager.stpInterface = stpInterface;
+		SaManager.stpInterface = stpInterface;
 	}
 	public static StpInterface getStpInterface() {
 		if (stpInterface == null) {
-			synchronized (SaTokenManager.class) {
+			synchronized (SaManager.class) {
 				if (stpInterface == null) {
 					setStpInterface(new StpInterfaceDefaultImpl());
 				}
@@ -90,11 +96,11 @@ public class SaTokenManager {
 	 */
 	private static SaTokenAction saTokenAction;
 	public static void setSaTokenAction(SaTokenAction saTokenAction) {
-		SaTokenManager.saTokenAction = saTokenAction;
+		SaManager.saTokenAction = saTokenAction;
 	}
 	public static SaTokenAction getSaTokenAction() {
 		if (saTokenAction == null) {
-			synchronized (SaTokenManager.class) {
+			synchronized (SaManager.class) {
 				if (saTokenAction == null) {
 					setSaTokenAction(new SaTokenActionDefaultImpl());
 				}
@@ -108,11 +114,11 @@ public class SaTokenManager {
 	 */
 	private static SaTokenContext saTokenContext;
 	public static void setSaTokenContext(SaTokenContext saTokenContext) {
-		SaTokenManager.saTokenContext = saTokenContext;
+		SaManager.saTokenContext = saTokenContext;
 	}
 	public static SaTokenContext getSaTokenContext() {
 		if (saTokenContext == null) {
-			synchronized (SaTokenManager.class) {
+			synchronized (SaManager.class) {
 				if (saTokenContext == null) {
 					setSaTokenContext(new SaTokenContextDefaultImpl());
 				}
@@ -126,11 +132,11 @@ public class SaTokenManager {
 	 */
 	private static SaTokenListener saTokenListener;
 	public static void setSaTokenListener(SaTokenListener saTokenListener) {
-		SaTokenManager.saTokenListener = saTokenListener;
+		SaManager.saTokenListener = saTokenListener;
 	}
 	public static SaTokenListener getSaTokenListener() {
 		if (saTokenListener == null) {
-			synchronized (SaTokenManager.class) {
+			synchronized (SaManager.class) {
 				if (saTokenListener == null) {
 					setSaTokenListener(new SaTokenListenerDefaultImpl());
 				}
@@ -139,6 +145,24 @@ public class SaTokenManager {
 		return saTokenListener;
 	}
 
+	/**
+	 * 临时令牌验证模块 Bean  
+	 */
+	private static SaTempInterface saTemp;
+	public static void setSaTemp(SaTempInterface saTemp) {
+		SaManager.saTemp = saTemp;
+	}
+	public static SaTempInterface getSaTemp() {
+		if (saTemp == null) {
+			synchronized (SaManager.class) {
+				if (saTemp == null) {
+					setSaTemp(new SaTempDefaultImpl());
+				}
+			}
+		}
+		return saTemp;
+	}
+	
 	/**
 	 * StpLogic集合, 记录框架所有成功初始化的StpLogic 
 	 */
@@ -149,16 +173,35 @@ public class SaTokenManager {
 	 * @param stpLogic StpLogic
 	 */
 	public static void putStpLogic(StpLogic stpLogic) {
-		stpLogicMap.put(stpLogic.getLoginKey(), stpLogic);
+		stpLogicMap.put(stpLogic.getLoginType(), stpLogic);
 	}
 
 	/**
-	 * 根据 LoginKey 获取对应的StpLogic，如果不存在则返回null 
-	 * @param loginKey 对应的LoginKey 
+	 * 根据 LoginType 获取对应的StpLogic，如果不存在则抛出异常 
+	 * @param loginType 对应的账号类型 
 	 * @return 对应的StpLogic
 	 */
-	public static StpLogic getStpLogic(String loginKey) {
-		return stpLogicMap.get(loginKey);
+	public static StpLogic getStpLogic(String loginType) {
+		// 如果type为空则返回框架内置的 
+		if(loginType == null || loginType.isEmpty()) {
+			return StpUtil.stpLogic;
+		}
+		
+		// 从SaManager中获取 
+		StpLogic stpLogic = stpLogicMap.get(loginType);
+		if(stpLogic == null) {
+			/*
+			 * 此时有两种情况会造成 StpLogic == null 
+			 * 1. loginType拼写错误，请改正 （建议使用常量） 
+			 * 2. 自定义StpUtil尚未初始化（静态类中的属性至少一次调用后才会初始化），解决方法两种
+			 * 		(1) 从main方法里调用一次
+			 * 		(2) 在自定义StpUtil类加上类似 @Component 的注解让容器启动时扫描到自动初始化 
+			 */
+			throw new SaTokenException("未能获取对应StpLogic，type="+ loginType);
+		}
+		
+		// 返回 
+		return stpLogic;
 	}
 	
 	

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

@@ -1,9 +1,12 @@
 package cn.dev33.satoken.action;
 
+import java.lang.reflect.Method;
+import java.util.List;
+
 import cn.dev33.satoken.session.SaSession;
 
 /**
- * sa-token逻辑代理接口 
+ * Sa-Token 逻辑代理接口 
  * <p>此接口将会代理框架内部的一些关键性逻辑，方便开发者进行按需重写</p> 
  * @author kong
  *
@@ -11,18 +14,32 @@ import cn.dev33.satoken.session.SaSession;
 public interface SaTokenAction {
 
 	/**
-	 * 根据一定的算法生成一个token 
+	 * 创建一个Token 
 	 * @param loginId 账号id 
-	 * @param loginKey 账号体系key 
-	 * @return 一个token
+	 * @param loginType 账号类型 
+	 * @return token
 	 */
-	public String createToken(Object loginId, String loginKey); 
+	public String createToken(Object loginId, String loginType); 
 	
 	/**
-	 * 根据 SessionId 创建一个 Session
+	 * 创建一个Session 
 	 * @param sessionId Session的Id
 	 * @return 创建后的Session 
 	 */
 	public SaSession createSession(String sessionId); 
 	
+	/**
+	 * 判断：集合中是否包含指定元素（模糊匹配） 
+	 * @param list 集合
+	 * @param element 元素
+	 * @return 是否包含
+	 */
+	public boolean hasElement(List<String> list, String element);
+
+	/**
+	 * 对一个Method对象进行注解检查（注解鉴权内部实现） 
+	 * @param method Method对象
+	 */
+	public void checkMethodAnnotation(Method method);
+	
 }

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

@@ -1,27 +1,33 @@
 package cn.dev33.satoken.action;
 
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Method;
+import java.util.List;
 import java.util.UUID;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import cn.dev33.satoken.annotation.SaCheckRole;
+import cn.dev33.satoken.annotation.SaCheckSafe;
 import cn.dev33.satoken.session.SaSession;
+import cn.dev33.satoken.util.SaFoxUtil;
 import cn.dev33.satoken.util.SaTokenConsts;
-import cn.dev33.satoken.util.SaTokenInsideUtil;
 
 /**
- * 对 SaTokenAction 接口的默认实现 
+ * Sa-Token 逻辑代理接口 [默认实现类] 
  * @author kong
  *
  */
 public class SaTokenActionDefaultImpl implements SaTokenAction {
 
-	
 	/**
-	 * 根据一定的算法生成一个token 
+	 * 创建一个Token 
 	 */
 	@Override
-	public String createToken(Object loginId, String loginKey) {
+	public String createToken(Object loginId, String loginType) {
 		// 根据配置的tokenStyle生成不同风格的token 
-		String tokenStyle = SaTokenManager.getConfig().getTokenStyle();
+		String tokenStyle = SaManager.getConfig().getTokenStyle();
 		// uuid 
 		if(SaTokenConsts.TOKEN_STYLE_UUID.equals(tokenStyle)) {
 			return UUID.randomUUID().toString();
@@ -32,31 +38,101 @@ public class SaTokenActionDefaultImpl implements SaTokenAction {
 		}
 		// 32位随机字符串
 		if(SaTokenConsts.TOKEN_STYLE_RANDOM_32.equals(tokenStyle)) {
-			return SaTokenInsideUtil.getRandomString(32);
+			return SaFoxUtil.getRandomString(32);
 		}
 		// 64位随机字符串
 		if(SaTokenConsts.TOKEN_STYLE_RANDOM_64.equals(tokenStyle)) {
-			return SaTokenInsideUtil.getRandomString(64);
+			return SaFoxUtil.getRandomString(64);
 		}
 		// 128位随机字符串
 		if(SaTokenConsts.TOKEN_STYLE_RANDOM_128.equals(tokenStyle)) {
-			return SaTokenInsideUtil.getRandomString(128);
+			return SaFoxUtil.getRandomString(128);
 		}
 		// tik风格 (2_14_16)
 		if(SaTokenConsts.TOKEN_STYLE_TIK.equals(tokenStyle)) {
-			return SaTokenInsideUtil.getRandomString(2) + "_" + SaTokenInsideUtil.getRandomString(14) + "_" + SaTokenInsideUtil.getRandomString(16) + "__";
+			return SaFoxUtil.getRandomString(2) + "_" + SaFoxUtil.getRandomString(14) + "_" + SaFoxUtil.getRandomString(16) + "__";
 		}
 		// 默认，还是uuid 
 		return UUID.randomUUID().toString();
 	}
 
-	
 	/**
-	 * 根据 SessionId 创建一个 Session 
+	 * 创建一个Session 
 	 */
 	@Override
 	public SaSession createSession(String sessionId) {
 		return new SaSession(sessionId);
 	}
+
+	/**
+	 * 判断：集合中是否包含指定元素（模糊匹配） 
+	 */
+	@Override
+	public boolean hasElement(List<String> list, String element) {
+		
+		// 空集合直接返回false
+		if(list == null || list.size() == 0) {
+			return false;
+		}
+
+		// 先尝试一下简单匹配，如果可以匹配成功则无需继续模糊匹配 
+		if (list.contains(element)) {
+			return true;
+		}
+		
+		// 开始模糊匹配 
+		for (String patt : list) {
+			if(SaFoxUtil.vagueMatch(patt, element)) {
+				return true;
+			}
+		}
+		
+		// 走出for循环说明没有一个元素可以匹配成功 
+		return false;
+	}
+
+	/**
+	 * 对一个Method对象进行注解检查（注解鉴权内部实现） 
+	 */
+	@Override
+	public void checkMethodAnnotation(Method method) {
+
+		// 先校验 Method 所属 Class 上的注解 
+		validateAnnotation(method.getDeclaringClass());
+		
+		// 再校验 Method 上的注解  
+		validateAnnotation(method);
+	}
+
+	/**
+	 * 从指定元素校验注解 
+	 * @param target see note 
+	 */
+	protected void validateAnnotation(AnnotatedElement target) {
+		
+		// 校验 @SaCheckLogin 注解 
+		if(target.isAnnotationPresent(SaCheckLogin.class)) {
+			SaCheckLogin at = target.getAnnotation(SaCheckLogin.class);
+			SaManager.getStpLogic(at.type()).checkByAnnotation(at);
+		}
+
+		// 校验 @SaCheckRole 注解 
+		if(target.isAnnotationPresent(SaCheckRole.class)) {
+			SaCheckRole at = target.getAnnotation(SaCheckRole.class);
+			SaManager.getStpLogic(at.type()).checkByAnnotation(at);
+		}
+
+		// 校验 @SaCheckPermission 注解
+		if(target.isAnnotationPresent(SaCheckPermission.class)) {
+			SaCheckPermission at = target.getAnnotation(SaCheckPermission.class);
+			SaManager.getStpLogic(at.type()).checkByAnnotation(at);
+		}
+
+		// 校验 @SaCheckSafe 注解
+		if(target.isAnnotationPresent(SaCheckSafe.class)) {
+			SaCheckSafe at = target.getAnnotation(SaCheckSafe.class);
+			SaManager.getStpLogic(null).checkByAnnotation(at);
+		}
+	}
 	
 }

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

@@ -6,8 +6,8 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * 登录校验：标注在一个方法上，当前会话必须已经登录才能进入该方法 
- * <p> 可标注在类上，其效果等同于标注在此类的所有方法上 
+ * 登录认证：只有登录之后才能进入该方法 
+ * <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上） 
  * @author kong
  *
  */
@@ -15,4 +15,10 @@ import java.lang.annotation.Target;
 @Target({ ElementType.METHOD, ElementType.TYPE })
 public @interface SaCheckLogin {
 
+    /**
+     * 多账号体系下所属的账号体系标识 
+     * @return see note 
+     */
+    String type() default "";
+
 }

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

@@ -6,8 +6,8 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * 权限校验：标注在一个方法上，当前会话必须具有指定权限才能进入该方法 
- * <p> 可标注在类上，其效果等同于标注在此类的所有方法上 
+ * 权限认证：必须具有指定权限才能进入该方法 
+ * <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上） 
  * @author kong
  *
  */
@@ -26,5 +26,11 @@ public @interface SaCheckPermission {
 	 * @return 验证模式
 	 */
 	SaMode mode() default SaMode.AND;
-	
+
+    /**
+     * 多账号体系下所属的账号体系标识 
+     * @return see note 
+     */
+	String type() default "";
+
 }

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

@@ -6,8 +6,8 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * 角色校验：标注在一个方法上，当前会话必须具有指定角色标识才能进入该方法 
- * <p> 可标注在类上，其效果等同于标注在此类的所有方法上 
+ * 角色认证：必须具有指定角色标识才能进入该方法 
+ * <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上） 
  * @author kong
  *
  */
@@ -26,5 +26,12 @@ public @interface SaCheckRole {
 	 * @return 验证模式
 	 */
 	SaMode mode() default SaMode.AND;
+
+    /**
+     * 账号类型 
+     * <p> 建议使用常量，避免因错误拼写带来的bug 
+     * @return see note 
+     */
+	String type() default "";
 	
 }

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

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

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

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

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

@@ -0,0 +1,293 @@
+package cn.dev33.satoken.config;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import cn.dev33.satoken.exception.SaTokenException;
+import cn.dev33.satoken.util.SaFoxUtil;
+import cn.dev33.satoken.util.SaResult;
+
+/**
+ * Sa-Token-SSO 单点登录模块 配置Model
+ * @author kong
+ *
+ */
+public class SaSsoConfig {
+
+	/**
+	 * Ticket有效期 (单位: 秒)
+	 */
+	public long ticketTimeout = 60 * 5;
+	
+	/**
+	 * 所有允许的授权回调地址，多个用逗号隔开 (不在此列表中的URL将禁止下放ticket) 
+	 */
+	public String allowUrl = "*";
+	
+	/**
+	 * 接口调用秘钥 (用于SSO模式三单点注销的接口通信身份校验)
+	 */
+	public String secretkey;
+	
+	/**
+	 * SSO-Server端 单点登录地址
+	 */
+	public String authUrl;
+
+	/**
+	 * SSO-Server端 Ticket校验地址
+	 */
+	public String checkTicketUrl;
+
+	/**
+	 * SSO-Server端 单点注销地址 
+	 */
+	public String sloUrl;
+
+	/**
+	 * SSO-Client端 当前Client端的单点注销回调URL （为空时自动获取） 
+	 */
+	public String ssoLogoutCall;
+
+
+	/**
+	 * @return Ticket有效期 (单位: 秒) 
+	 */
+	public long getTicketTimeout() {
+		return ticketTimeout;
+	}
+
+	/**
+	 * @param ticketTimeout Ticket有效期 (单位: 秒) 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setTicketTimeout(long ticketTimeout) {
+		this.ticketTimeout = ticketTimeout;
+		return this;
+	}
+
+	/**
+	 * @return 所有允许的授权回调地址，多个用逗号隔开 (不在此列表中的URL将禁止下放ticket) 
+	 */
+	public String getAllowUrl() {
+		return allowUrl;
+	}
+
+	/**
+	 * @param allowUrl 所有允许的授权回调地址，多个用逗号隔开 (不在此列表中的URL将禁止下放ticket) 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setAllowUrl(String allowUrl) {
+		this.allowUrl = allowUrl;
+		return this;
+	}
+
+	/**
+	 * @return 调用秘钥 (用于SSO模式三单点注销的接口通信身份校验)
+	 */
+	public String getSecretkey() {
+		return secretkey;
+	}
+
+	/**
+	 * @param secretkey 调用秘钥 (用于SSO模式三单点注销的接口通信身份校验) 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setSecretkey(String secretkey) {
+		this.secretkey = secretkey;
+		return this;
+	}
+
+	/**
+	 * @return SSO-Server端 单点登录地址
+	 */
+	public String getAuthUrl() {
+		return authUrl;
+	}
+
+	/**
+	 * @param authUrl SSO-Server端 单点登录地址
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setAuthUrl(String authUrl) {
+		this.authUrl = authUrl;
+		return this;
+	}
+
+	/**
+	 * @return SSO-Server端Ticket校验地址 
+	 */
+	public String getCheckTicketUrl() {
+		return checkTicketUrl;
+	}
+
+	/**
+	 * @param checkTicketUrl SSO-Server端Ticket校验地址
+	 */
+	public SaSsoConfig setCheckTicketUrl(String checkTicketUrl) {
+		this.checkTicketUrl = checkTicketUrl;
+		return this;
+	}
+
+	/**
+	 * @return SSO-Server端单点注销地址
+	 */
+	public String getSloUrl() {
+		return sloUrl;
+	}
+
+	/**
+	 * @param sloUrl SSO-Server端单点注销地址
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setSloUrl(String sloUrl) {
+		this.sloUrl = sloUrl;
+		return this;
+	}
+
+	/**
+	 * @return SSO-Client端 当前Client端的单点注销回调URL （为空时自动获取） 
+	 */
+	public String getSsoLogoutCall() {
+		return ssoLogoutCall;
+	}
+
+	/**
+	 * @param ssoLogoutCall SSO-Client端 当前Client端的单点注销回调URL （为空时自动获取） 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setSsoLogoutCall(String ssoLogoutCall) {
+		this.ssoLogoutCall = ssoLogoutCall;
+		return this;
+	}
+
+	@Override
+	public String toString() {
+		return "SaSsoConfig [ticketTimeout=" + ticketTimeout + ", allowUrl=" + allowUrl + ", secretkey=" + secretkey
+				+ ", authUrl=" + authUrl + ", checkTicketUrl=" + checkTicketUrl + ", sloUrl=" + sloUrl
+				+ ", ssoLogoutCall=" + ssoLogoutCall + ", isHttp=" + isHttp + ", isSlo=" + isSlo + "]";
+	}
+	
+
+	/**
+	 * 以数组形式写入允许的授权回调地址 
+	 * @param url 所有集合 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setAllow(String ...url) {
+		this.allowUrl = SaFoxUtil.arrayJoin(url);
+		return this;
+	}
+
+	// -------------------- SaSsoHandle 相关配置 -------------------- 
+	
+	/**
+	 * 是否使用http请求校验ticket值 
+	 */
+	public Boolean isHttp = false; 
+
+	/**
+	 * 是否打开单点注销 
+	 */
+	public Boolean isSlo = false; 
+	
+
+	/**
+	 * @return isHttp 是否使用http请求校验ticket值 
+	 */
+	public Boolean getIsHttp() {
+		return isHttp;
+	}
+
+	/**
+	 * @param isHttp 是否使用http请求校验ticket值 
+	 * @return 对象自身 
+	 */
+	public SaSsoConfig setIsHttp(Boolean isHttp) {
+		this.isHttp = isHttp;
+		return this;
+	}
+
+	/**
+	 * @return 是否打开单点注销 
+	 */
+	public Boolean getIsSlo() {
+		return isSlo;
+	}
+
+	/**
+	 * @param isSlo 是否打开单点注销 
+	 * @return 对象自身 
+	 */
+	public SaSsoConfig setIsSlo(Boolean isSlo) {
+		this.isSlo = isSlo;
+		return this;
+	}
+	
+	
+	// -------------------- SaSsoHandle 所有回调函数 -------------------- 
+	
+
+
+	/**
+	 * SSO-Server端：未登录时返回的View 
+	 */
+	public Supplier<Object> notLoginView = () -> "当前会话在SSO-Server认证中心尚未登录";
+
+	/**
+	 * SSO-Server端：登录函数 
+	 */
+	public BiFunction<String, String, Object> doLoginHandle = (name, pwd) -> SaResult.error();
+
+	/**
+	 * SSO-Client端：Ticket无效时返回的View 
+	 */
+	public Function<String, Object> ticketInvalidView = (ticket) -> {
+		// 此处向客户端提示ticket无效即可，不要重定向到SSO认证中心，否则容易引起无限重定向 
+		return "ticket无效: " + ticket;
+	};
+
+	/**
+	 * SSO-Client端：发送Http请求的处理函数 
+	 */
+	public Function<String, Object> sendHttp = url -> {throw new SaTokenException("请配置Http处理器");};
+
+
+	/**
+	 * @param notLoginView SSO-Server端：未登录时返回的View 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setNotLoginView(Supplier<Object> notLoginView) {
+		this.notLoginView = notLoginView;
+		return this;
+	}
+	
+	/**
+	 * @param doLoginHandle SSO-Server端：登录函数 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setDoLoginHandle(BiFunction<String, String, Object> doLoginHandle) {
+		this.doLoginHandle = doLoginHandle;
+		return this;
+	}
+
+	/**
+	 * @param ticketInvalidView SSO-Client端：Ticket无效时返回的View 
+	 * @return 对象自身
+	 */
+	public SaSsoConfig setTicketInvalidView(Function<String, Object> ticketInvalidView) {
+		this.ticketInvalidView = ticketInvalidView;
+		return this;
+	}
+	
+	/**
+	 * @param sendHttp SSO-Client端：发送Http请求的处理函数 
+	 * @return 对象自身 
+	 */
+	public SaSsoConfig setSendHttp(Function<String, Object> sendHttp) {
+		this.sendHttp = sendHttp;
+		return this;
+	}
+
+}

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

@@ -1,7 +1,7 @@
 package cn.dev33.satoken.config;
 
 /**
- * sa-token 配置类 Model
+ * Sa-Token 配置类 Model
  * <p>
  * 你可以通过yml、properties、java代码等形式配置本类参数，具体请查阅官方文档: http://sa-token.dev33.cn/
  * 
@@ -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,11 +56,21 @@ public class SaTokenConfig {
 	private String tokenPrefix;
 
 	/** 是否在初始化配置时打印版本字符画 */
-	private Boolean isV = true;
+	private Boolean isPrint = true;
 
 	/** 是否打印操作日志 */
 	private Boolean isLog = false;
 
+	/**
+	 * jwt秘钥 (只有集成 sa-token-temp-jwt 模块时此参数才会生效) 
+	 */
+	private String jwtSecretKey;
+	
+	/**
+	 * SSO单点登录配置对象 
+	 */
+	public SaSsoConfig sso = new SaSsoConfig();
+	
 
 	/**
 	 * @return token名称 (同时也是cookie名称)
@@ -113,18 +123,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;
 	}
 
@@ -293,16 +303,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;
 	}
 
@@ -315,6 +325,7 @@ public class SaTokenConfig {
 
 	/**
 	 * @param isLog 是否打印操作日志
+	 * @return 对象自身
 	 */
 	public SaTokenConfig setIsLog(Boolean isLog) {
 		this.isLog = isLog;
@@ -322,21 +333,74 @@ public class SaTokenConfig {
 	}
 
 	/**
-	 * toString()
+	 * @return jwt秘钥 (只有集成 sa-token-temp-jwt 模块时此参数才会生效)  
+	 */
+	public String getJwtSecretKey() {
+		return jwtSecretKey;
+	}
+
+	/**
+	 * @param jwtSecretKey jwt秘钥 (只有集成 sa-token-temp-jwt 模块时此参数才会生效)  
+	 * @return 对象自身
+	 */
+	public SaTokenConfig setJwtSecretKey(String jwtSecretKey) {
+		this.jwtSecretKey = jwtSecretKey;
+		return this;
+	}
+
+	/**
+	 * @return SSO单点登录配置对象 
+	 */
+	public SaSsoConfig getSso() {
+		return sso;
+	}
+	
+
+	/**
+	 * @param sso SSO单点登录配置对象 
+	 */
+	public void setSso(SaSsoConfig sso) {
+		this.sso = sso;
+	}
+	
+
+	/**
+	 * toString() 
 	 */
 	@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 + "]";
+				+ ", tokenPrefix=" + tokenPrefix + ", isPrint=" + isPrint + ", isLog=" + isLog + ", jwtSecretKey="
+				+ jwtSecretKey + ", sso=" + sso + "]";
+	}
+	
+
+	
+	
+	/**
+	 * <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/config/SaTokenConfigFactory.java

@@ -8,7 +8,7 @@ import java.util.Map;
 import java.util.Properties;
 
 /**
- * sa-token配置文件的构建工厂类
+ * Sa-Token配置文件的构建工厂类
  * <p>
  * 只有在非IOC环境下才会用到此类
  * 
@@ -94,9 +94,7 @@ public class SaTokenConfigFactory {
 				Object valueConvert = getObjectByClass(value, field.getType());
 				field.setAccessible(true);
 				field.set(obj, valueConvert);
-			} catch (IllegalArgumentException e) {
-				throw new RuntimeException("属性赋值出错：" + field.getName(), e);
-			} catch (IllegalAccessException e) {
+			} catch (IllegalArgumentException | IllegalAccessException e) {
 				throw new RuntimeException("属性赋值出错：" + field.getName(), e);
 			}
 		}
@@ -112,23 +110,23 @@ public class SaTokenConfigFactory {
 	 */
 	@SuppressWarnings("unchecked")
 	private static <T> T getObjectByClass(String str, Class<T> cs) {
-		Object value = null;
+		Object value;
 		if (str == null) {
 			value = null;
 		} else if (cs.equals(String.class)) {
 			value = str;
 		} else if (cs.equals(int.class) || cs.equals(Integer.class)) {
-			value = new Integer(str);
+			value = Integer.valueOf(str);
 		} else if (cs.equals(long.class) || cs.equals(Long.class)) {
-			value = new Long(str);
+			value = Long.valueOf(str);
 		} else if (cs.equals(short.class) || cs.equals(Short.class)) {
-			value = new Short(str);
+			value = Short.valueOf(str);
 		} else if (cs.equals(float.class) || cs.equals(Float.class)) {
-			value = new Float(str);
+			value = Float.valueOf(str);
 		} else if (cs.equals(double.class) || cs.equals(Double.class)) {
-			value = new Double(str);
+			value = Double.valueOf(str);
 		} else if (cs.equals(boolean.class) || cs.equals(Boolean.class)) {
-			value = new Boolean(str);
+			value = Boolean.valueOf(str);
 		} else {
 			throw new RuntimeException("未能将值：" + str + "，转换类型为：" + cs, null);
 		}

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

@@ -0,0 +1,42 @@
+package cn.dev33.satoken.context;
+
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.context.model.SaRequest;
+import cn.dev33.satoken.context.model.SaResponse;
+import cn.dev33.satoken.context.model.SaStorage;
+
+/**
+ * Sa-Token 上下文持有类 
+ * @author kong
+ *
+ */
+public class SaHolder {
+
+	/**
+	 * 获取当前请求的 [Request] 对象
+	 * 
+	 * @return see note 
+	 */
+	public static SaRequest getRequest() {
+		return SaManager.getSaTokenContext().getRequest();
+	}
+
+	/**
+	 * 获取当前请求的 [Response] 对象
+	 * 
+	 * @return see note 
+	 */
+	public static SaResponse getResponse() {
+		return SaManager.getSaTokenContext().getResponse();
+	}
+
+	/**
+	 * 获取当前请求的 [存储器] 对象 
+	 * 
+	 * @return see note 
+	 */
+	public static SaStorage getStorage() {
+		return SaManager.getSaTokenContext().getStorage();
+	}
+
+}

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

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

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

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

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

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

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

@@ -1,7 +1,9 @@
 package cn.dev33.satoken.context.model;
 
+import cn.dev33.satoken.util.SaFoxUtil;
+
 /**
- * Request包装类
+ * Request 包装类
  * @author kong
  *
  */
@@ -20,6 +22,20 @@ public interface SaRequest {
 	 */
 	public String getParameter(String name);
 
+	/**
+	 * 在 [请求体] 里获取一个值，值为空时返回默认值  
+	 * @param name 键 
+	 * @param defaultValue 值为空时的默认值  
+	 * @return 值 
+	 */
+	public default String getParameter(String name, String defaultValue) {
+		String value = getParameter(name);
+		if(SaFoxUtil.isEmpty(value)) {
+			return defaultValue;
+		}
+		return value;
+	}
+
 	/**
 	 * 在 [请求头] 里获取一个值 
 	 * @param name 键 
@@ -35,9 +51,29 @@ public interface SaRequest {
 	public String getCookieValue(String name);
 
 	/**
-	 * 返回当前请求的URL 
+	 * 返回当前请求path (不包括上下文名称) 
 	 * @return see note
 	 */
-	public String getRequestURI();
+	public String getRequestPath();
+
+	/**
+	 * 返回当前请求的url，例：http://xxx.com/?id=127
+	 * @return see note
+	 */
+	public String getUrl();
+	
+	/**
+	 * 返回当前请求的类型 
+	 * @return see note
+	 */
+	public String getMethod();
+	
+	/**
+	 * 此请求是否为Ajax请求 
+	 * @return see note 
+	 */
+	public default boolean isAjax() {
+		return getHeader("X-Requested-With") != null;
+	}
 	
 }

sa-token-core/src/main/java/cn/dev33/satoken/context/model/SaResponse.java

@@ -29,4 +29,28 @@ public interface SaResponse {
 	 */
 	public void addCookie(String name, String value, String path, String domain, int timeout);
 	
+	/**
+	 * 在响应头里写入一个值 
+	 * @param name 名字
+	 * @param value 值 
+	 * @return 对象自身 
+	 */
+	public SaResponse setHeader(String name, String value);
+	
+	/**
+	 * 在响应头写入 [Server] 服务器名称 
+	 * @param value 服务器名称  
+	 * @return 对象自身 
+	 */
+	public default SaResponse setServer(String value) {
+		return this.setHeader("Server", value);
+	}
+
+	/**
+	 * 重定向 
+	 * @param url 重定向地址 
+	 * @return 任意值 
+	 */
+	public Object redirect(String url);
+	
 }

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

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

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

@@ -6,11 +6,11 @@ import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-import cn.dev33.satoken.SaTokenManager;
-import cn.dev33.satoken.util.SaTokenInsideUtil;
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.util.SaFoxUtil;
 
 /**
- * sa-token持久层默认的实现类 , 基于内存Map 
+ * Sa-Token持久层接口 [默认实现类, 基于内存Map] 
  * @author kong
  *
  */
@@ -189,7 +189,7 @@ public class SaTokenDaoDefaultImpl implements SaTokenDao {
 	public void initRefreshThread() {
 
 		// 如果配置了<=0的值，则不启动定时清理
-		if(SaTokenManager.getConfig().getDataRefreshPeriod() <= 0) {
+		if(SaManager.getConfig().getDataRefreshPeriod() <= 0) {
 			return;
 		}
 		// 启动定时刷新
@@ -208,7 +208,7 @@ public class SaTokenDaoDefaultImpl implements SaTokenDao {
 						e.printStackTrace();
 					}
 					// 休眠N秒 
-					int dataRefreshPeriod = SaTokenManager.getConfig().getDataRefreshPeriod();
+					int dataRefreshPeriod = SaManager.getConfig().getDataRefreshPeriod();
 					if(dataRefreshPeriod <= 0) {
 						dataRefreshPeriod = 1;
 					}
@@ -235,7 +235,7 @@ public class SaTokenDaoDefaultImpl implements SaTokenDao {
 	
 	@Override
 	public List<String> searchData(String prefix, String keyword, int start, int size) {
-		return SaTokenInsideUtil.searchList(expireMap.keySet(), prefix, keyword, start, size);
+		return SaFoxUtil.searchList(expireMap.keySet(), prefix, keyword, start, size);
 	}
 
 

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

@@ -0,0 +1,29 @@
+package cn.dev33.satoken.exception;
+
+/**
+ * 一个异常：代表停止匹配，直接退出，向前端输出结果 
+ * 
+ * @author kong
+ */
+public class BackResultException extends SaTokenException {
+
+	/**
+	 * 序列化版本号
+	 */
+	private static final long serialVersionUID = 6806129545290130143L;
+
+	/**
+	 * 要输出的结果 
+	 */
+	public Object result;
+	
+	/**
+	 * 构造 
+	 * @param result 要输出的结果 
+	 */
+	public BackResultException(Object result) {
+		super(String.valueOf(result));
+		this.result = result;
+	}
+
+}

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

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

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

@@ -4,7 +4,7 @@ import java.util.Arrays;
 import java.util.List;
 
 /**
- * 一个异常：代表用户没有登录 
+ * 一个异常：代表会话未能通过登录认证 
  * @author kong 
  */
 public class NotLoginException extends SaTokenException {
@@ -67,38 +67,38 @@ public class NotLoginException extends SaTokenException {
 	
 	
 	/**
-	 * loginKey 
+	 * 账号类型 
 	 */
-	private String loginKey;
+	private String loginType;
 	
 	/** 
-	 * 获得loginKey
-	 * @return loginKey
+	 * 获得账号类型 
+	 * @return 账号类型
 	 */
-	public String getLoginKey() {
-		return loginKey;
+	public String getLoginType() {
+		return loginType;
 	}
 	
 	
 	/**
 	 * 构造方法创建一个 
 	 * @param message 异常消息 
-	 * @param loginKey loginKey
+	 * @param loginType 账号类型
 	 * @param type 类型 
 	 */
-	public NotLoginException(String message, String loginKey, String type) {
+	public NotLoginException(String message, String loginType, String type) {
 		super(message);	
-        this.loginKey = loginKey;
+        this.loginType = loginType;
         this.type = type;
     }
 	
 	/**
 	 * 静态方法构建一个NotLoginException 
-	 * @param loginKey loginKey 
-	 * @param type 场景类型 
+	 * @param loginType 账号类型
+	 * @param type 账号类型 
 	 * @return 构建完毕的异常对象 
 	 */
-	public static NotLoginException newInstance(String loginKey, String type) {
+	public static NotLoginException newInstance(String loginType, String type) {
 		String message = null;
 		if(NOT_TOKEN.equals(type)) {
 			message = NOT_TOKEN_MESSAGE;
@@ -118,7 +118,7 @@ public class NotLoginException extends SaTokenException {
 		else {
 			message = DEFAULT_MESSAGE;
 		}
-		return new NotLoginException(message, loginKey, type);
+		return new NotLoginException(message, loginType, type);
     }
 
 }

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

@@ -3,7 +3,7 @@ package cn.dev33.satoken.exception;
 import cn.dev33.satoken.stp.StpUtil;
 
 /**
- * 没有指定权限码，抛出的异常 
+ * 一个异常：代表会话未能通过权限认证 
  * 
  * @author kong
  *
@@ -13,7 +13,7 @@ public class NotPermissionException extends SaTokenException {
 	/**
 	 * 序列化版本号 
 	 */
-	private static final long serialVersionUID = 6806129545290130142L;
+	private static final long serialVersionUID = 6806129545290130141L;
 
 	/** 权限码 */
 	private String code;
@@ -26,27 +26,27 @@ public class NotPermissionException extends SaTokenException {
 	}
 
 	/**
-	 * loginKey
+	 * 账号类型
 	 */
-	private String loginKey;
+	private String loginType;
 
 	/**
-	 * 获得loginKey
+	 * 获得账号类型
 	 * 
-	 * @return loginKey
+	 * @return 账号类型
 	 */
-	public String getLoginKey() {
-		return loginKey;
+	public String getLoginType() {
+		return loginType;
 	}
 
 	public NotPermissionException(String code) {
-		this(code, StpUtil.stpLogic.loginKey);
+		this(code, StpUtil.stpLogic.loginType);
 	}
 
-	public NotPermissionException(String code, String loginKey) {
+	public NotPermissionException(String code, String loginType) {
 		super("无此权限：" + code);
 		this.code = code;
-		this.loginKey = loginKey;
+		this.loginType = loginType;
 	}
 
 }

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

@@ -3,7 +3,7 @@ package cn.dev33.satoken.exception;
 import cn.dev33.satoken.stp.StpUtil;
 
 /**
- * 没有指定角色标识，抛出的异常 
+ * 一个异常：代表会话未能通过角色认证 
  * 
  * @author kong
  *
@@ -26,28 +26,27 @@ public class NotRoleException extends SaTokenException {
 	}
 
 	/**
-	 * loginKey
+	 * 账号类型
 	 */
-	private String loginKey;
+	private String loginType;
 
 	/**
-	 * 获得loginKey
+	 * 获得账号类型
 	 * 
-	 * @return loginKey
+	 * @return 账号类型
 	 */
-	public String getLoginKey() {
-		return loginKey;
+	public String getLoginType() {
+		return loginType;
 	}
 
 	public NotRoleException(String role) {
-		this(role, StpUtil.stpLogic.loginKey);
+		this(role, StpUtil.stpLogic.loginType);
 	}
 
-	public NotRoleException(String role, String loginKey) {
-		// 这里到底要不要拼接上loginKey呢？纠结
+	public NotRoleException(String role, String loginType) {
 		super("无此角色：" + role);
 		this.role = role;
-		this.loginKey = loginKey;
+		this.loginType = loginType;
 	}
 
 }

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

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

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

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

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

@@ -0,0 +1,22 @@
+package cn.dev33.satoken.exception;
+
+/**
+ * 一个异常：代表停止路由匹配 
+ * 
+ * @author kong
+ */
+public class StopMatchException extends SaTokenException {
+
+	/**
+	 * 序列化版本号
+	 */
+	private static final long serialVersionUID = 6806129545290130143L;
+
+	/**
+	 * 构造 
+	 */
+	public StopMatchException() {
+		super("stop match");
+	}
+
+}

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

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

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

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

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

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

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

@@ -6,6 +6,7 @@ package cn.dev33.satoken.fun;
  * @author kong
  *
  */
+@FunctionalInterface
 public interface SaFunction {
 
 	/**

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

@@ -0,0 +1,17 @@
+package cn.dev33.satoken.fun;
+
+/**
+ * 设定一个函数，并返回一个值，方便在Lambda表达式下的函数式编程
+ * @author kong
+ *
+ */
+@FunctionalInterface
+public interface SaRetFunction {
+	
+	/**
+	 * 执行的方法 
+	 * @return 返回值 
+	 */
+	public Object run();
+	
+}

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

@@ -3,7 +3,7 @@ package cn.dev33.satoken.listener;
 import cn.dev33.satoken.stp.SaLoginModel;
 
 /**
- * Sa-Token的侦听器
+ * Sa-Token 侦听器
  * <p> 你可以通过实现此接口在用户登陆、退出等关键性操作时进行一些AOP操作 
  * @author kong
  *
@@ -12,52 +12,52 @@ public interface SaTokenListener {
 
 	/**
 	 * 每次登录时触发 
-	 * @param loginKey 账号类别
+	 * @param loginType 账号类别
 	 * @param loginId 账号id
 	 * @param loginModel 登录参数
 	 */
-	public void doLogin(String loginKey, Object loginId, SaLoginModel loginModel);
+	public void doLogin(String loginType, Object loginId, SaLoginModel loginModel);
 			
 	/**
 	 * 每次注销时触发 
-	 * @param loginKey 账号类别
+	 * @param loginType 账号类别
 	 * @param loginId 账号id
 	 * @param tokenValue token值
 	 */
-	public void doLogout(String loginKey, Object loginId, String tokenValue);
+	public void doLogout(String loginType, Object loginId, String tokenValue);
 	
 	/**
 	 * 每次被踢下线时触发
-	 * @param loginKey 账号类别
+	 * @param loginType 账号类别
 	 * @param loginId 账号id
 	 * @param tokenValue token值
 	 * @param device 设备标识 
 	 */
-	public void doLogoutByLoginId(String loginKey, Object loginId, String tokenValue, String device);
+	public void doLogoutByLoginId(String loginType, Object loginId, String tokenValue, String device);
 
 	/**
 	 * 每次被顶下线时触发
-	 * @param loginKey 账号类别
+	 * @param loginType 账号类别
 	 * @param loginId 账号id
 	 * @param tokenValue token值
 	 * @param device 设备标识 
 	 */
-	public void doReplaced(String loginKey, Object loginId, String tokenValue, String device);
+	public void doReplaced(String loginType, Object loginId, String tokenValue, String device);
 
 	/**
 	 * 每次被封禁时触发
-	 * @param loginKey 账号类别
+	 * @param loginType 账号类别
 	 * @param loginId 账号id
 	 * @param disableTime 封禁时长，单位: 秒
 	 */
-	public void doDisable(String loginKey, Object loginId, long disableTime);
+	public void doDisable(String loginType, Object loginId, long disableTime);
 	
 	/**
 	 * 每次被解封时触发
-	 * @param loginKey 账号类别
+	 * @param loginType 账号类别
 	 * @param loginId 账号id
 	 */
-	public void doUntieDisable(String loginKey, Object loginId);
+	public void doUntieDisable(String loginType, Object loginId);
 	
 	/**
 	 * 每次创建Session时触发

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

@@ -2,9 +2,9 @@ package cn.dev33.satoken.listener;
 
 import java.util.Date;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
 import cn.dev33.satoken.stp.SaLoginModel;
-import cn.dev33.satoken.util.SaTokenInsideUtil;
+import cn.dev33.satoken.util.SaFoxUtil;
 
 /**
  * Sa-Token 侦听器的默认实现：log打印 
@@ -17,7 +17,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
 	 * 每次登录时触发 
 	 */
 	@Override
-	public void doLogin(String loginKey, Object loginId, SaLoginModel loginModel) {
+	public void doLogin(String loginType, Object loginId, SaLoginModel loginModel) {
 		println("账号[" + loginId + "]登录成功");
 	}
 
@@ -25,7 +25,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
 	 * 每次注销时触发 
 	 */
 	@Override
-	public void doLogout(String loginKey, Object loginId, String tokenValue) {
+	public void doLogout(String loginType, Object loginId, String tokenValue) {
 		println("账号[" + loginId + "]注销成功");
 	}
 
@@ -33,7 +33,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
 	 * 每次被踢下线时触发
 	 */
 	@Override
-	public void doLogoutByLoginId(String loginKey, Object loginId, String tokenValue, String device) {
+	public void doLogoutByLoginId(String loginType, Object loginId, String tokenValue, String device) {
 		println("账号[" + loginId + "]被踢下线 (终端: " + device + ")");
 	}
 
@@ -41,7 +41,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
 	 * 每次被顶下线时触发
 	 */
 	@Override
-	public void doReplaced(String loginKey, Object loginId, String tokenValue, String device) {
+	public void doReplaced(String loginType, Object loginId, String tokenValue, String device) {
 		println("账号[" + loginId + "]被顶下线 (终端: " + device + ")");
 	}
 
@@ -49,16 +49,16 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
 	 * 每次被封禁时触发
 	 */
 	@Override
-	public void doDisable(String loginKey, Object loginId, long disableTime) {
+	public void doDisable(String loginType, Object loginId, long disableTime) {
 		Date date = new Date(System.currentTimeMillis() + disableTime * 1000);
-		println("账号[" + loginId + "]被封禁 (解封时间: " + SaTokenInsideUtil.formatDate(date) + ")");
+		println("账号[" + loginId + "]被封禁 (解封时间: " + SaFoxUtil.formatDate(date) + ")");
 	}
 
 	/**
 	 * 每次被解封时触发
 	 */
 	@Override
-	public void doUntieDisable(String loginKey, Object loginId) {
+	public void doUntieDisable(String loginType, Object loginId) {
 		println("账号[" + loginId + "]被解除封禁");
 	}
 
@@ -88,7 +88,7 @@ public class SaTokenListenerDefaultImpl implements SaTokenListener {
 	 * @param str 字符串
 	 */
 	public void println(String str) {
-		if(SaTokenManager.getConfig().getIsLog()) {
+		if(SaManager.getConfig().getIsLog()) {
 			System.out.println(LOG_PREFIX + str);
 		}
 	}

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

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

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

@@ -0,0 +1,154 @@
+package cn.dev33.satoken.router;
+
+import java.util.Arrays;
+import java.util.List;
+
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.context.SaHolder;
+import cn.dev33.satoken.exception.BackResultException;
+import cn.dev33.satoken.exception.StopMatchException;
+import cn.dev33.satoken.fun.IsRunFunction;
+import cn.dev33.satoken.fun.SaFunction;
+
+/**
+ * 路由匹配操作工具类 
+ * @author kong
+ *
+ */
+public class SaRouter {
+
+	// -------------------- 路由匹配相关 -------------------- 
+	
+	/**
+	 * 路由匹配
+	 * @param pattern 路由匹配符 
+	 * @param path 被匹配的路由  
+	 * @return 是否匹配成功 
+	 */
+	public static boolean isMatch(String pattern, String path) {
+		return SaManager.getSaTokenContext().matchPath(pattern, path);
+	}
+
+	/**
+	 * 路由匹配   
+	 * @param patterns 路由匹配符集合 
+	 * @param path 被匹配的路由  
+	 * @return 是否匹配成功 
+	 */
+	public static boolean isMatch(List<String> patterns, String path) {
+		for (String pattern : patterns) {
+			if(isMatch(pattern, path)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * 路由匹配 (使用当前URI) 
+	 * @param pattern 路由匹配符 
+	 * @return 是否匹配成功 
+	 */
+	public static boolean isMatchCurrURI(String pattern) {
+		return isMatch(pattern, SaHolder.getRequest().getRequestPath());
+	}
+
+	/**
+	 * 路由匹配 (使用当前URI) 
+	 * @param patterns 路由匹配符集合 
+	 * @return 是否匹配成功 
+	 */
+	public static boolean isMatchCurrURI(List<String> patterns) {
+		return isMatch(patterns, SaHolder.getRequest().getRequestPath());
+	}
+	
+
+	// -------------------- 执行相关 -------------------- 
+	
+	/**
+	 * 路由匹配，如果匹配成功则执行认证函数 
+	 * @param pattern 路由匹配符
+	 * @param function 要执行的方法 
+	 */
+	public static void match(String pattern, SaFunction function) {
+		if(isMatchCurrURI(pattern)) {
+			function.run();
+		}
+	}
+
+	/**
+	 * 路由匹配 (并指定排除匹配符)，如果匹配成功则执行认证函数 
+	 * @param pattern 路由匹配符 
+	 * @param excludePattern 要排除的路由匹配符 
+	 * @param function 要执行的方法 
+	 */
+	public static void match(String pattern, String excludePattern, SaFunction function) {
+		if(isMatchCurrURI(pattern)) {
+			if(isMatchCurrURI(excludePattern) == false) {
+				function.run();
+			}
+		}
+	}
+
+	/**
+	 * 路由匹配，如果匹配成功则执行认证函数 
+	 * @param patterns 路由匹配符集合
+	 * @param function 要执行的方法 
+	 */
+	public static void match(List<String> patterns, SaFunction function) {
+		if(isMatchCurrURI(patterns)) {
+			function.run();
+		}
+	}
+
+	/**
+	 * 路由匹配 (并指定排除匹配符)，如果匹配成功则执行认证函数 
+	 * @param patterns 路由匹配符集合
+	 * @param excludePatterns 要排除的路由匹配符集合
+	 * @param function 要执行的方法 
+	 */
+	public static void match(List<String> patterns, List<String> excludePatterns, SaFunction function) {
+		if(isMatchCurrURI(patterns)) {
+			if(isMatchCurrURI(excludePatterns) == false) {
+				function.run();
+			}
+		}
+	}
+	
+	
+	/**
+	 * 路由匹配，如果匹配成功则执行认证函数 
+	 * @param patterns 路由匹配符集合
+	 * @return 匹配结果包装对象 
+	 */
+	public static IsRunFunction match(String... patterns) {
+		boolean matchResult = isMatch(Arrays.asList(patterns), SaHolder.getRequest().getRequestPath());
+		return new IsRunFunction(matchResult);
+	}
+
+	
+	// -------------------- 其它操作 -------------------- 
+	
+	/**
+	 * 停止匹配，跳出函数 (在多个匹配链中一次性跳出Auth函数) 
+	 */
+	public static void stop() {
+		throw new StopMatchException();
+	}
+
+	/**
+	 * 停止匹配，结束执行，向前端返回结果 
+	 * @param result 要输出的结果 
+	 */
+	public static void back(Object result) {
+		throw new BackResultException(result);
+	}
+
+	/**
+	 * 停止匹配，结束执行，向前端返回结果 
+	 */
+	public static void back() {
+		throw new BackResultException("");
+	}
+	
+}

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

@@ -3,15 +3,19 @@ package cn.dev33.satoken.router;
 import java.util.Arrays;
 import java.util.List;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.context.SaHolder;
+import cn.dev33.satoken.exception.StopMatchException;
 import cn.dev33.satoken.fun.IsRunFunction;
 import cn.dev33.satoken.fun.SaFunction;
 
 /**
+ * <h1> 本类设计已过时，未来版本可能移除此类，请及时更换为 SaRouter ，使用方式保持不变 </h1>
  * 对路由匹配符相关操作的封装工具类 
  * @author kong
  *
  */
+@Deprecated
 public class SaRouterUtil {
 
 	// -------------------- 路由匹配相关 -------------------- 
@@ -23,7 +27,7 @@ public class SaRouterUtil {
 	 * @return 是否匹配成功 
 	 */
 	public static boolean isMatch(String pattern, String path) {
-		return SaTokenManager.getSaTokenContext().matchPath(pattern, path);
+		return SaManager.getSaTokenContext().matchPath(pattern, path);
 	}
 
 	/**
@@ -47,7 +51,7 @@ public class SaRouterUtil {
 	 * @return 是否匹配成功 
 	 */
 	public static boolean isMatchCurrURI(String pattern) {
-		return isMatch(pattern, SaTokenManager.getSaTokenContext().getRequest().getRequestURI());
+		return isMatch(pattern, SaHolder.getRequest().getRequestPath());
 	}
 
 	/**
@@ -56,7 +60,7 @@ public class SaRouterUtil {
 	 * @return 是否匹配成功 
 	 */
 	public static boolean isMatchCurrURI(List<String> patterns) {
-		return isMatch(patterns, SaTokenManager.getSaTokenContext().getRequest().getRequestURI());
+		return isMatch(patterns, SaHolder.getRequest().getRequestPath());
 	}
 	
 
@@ -119,12 +123,21 @@ public class SaRouterUtil {
 	 * @return 匹配结果包装对象 
 	 */
 	public static IsRunFunction match(String... patterns) {
-		boolean matchResult = isMatch(Arrays.asList(patterns), SaTokenManager.getSaTokenContext().getRequest().getRequestURI());
+		boolean matchResult = isMatch(Arrays.asList(patterns), SaHolder.getRequest().getRequestPath());
 		return new IsRunFunction(matchResult);
 	}
+
+	
+	// -------------------- 其它操作 -------------------- 
+	
+	/**
+	 * 停止匹配，跳出函数 (在多个匹配链中一次性跳出Auth函数) 
+	 */
+	public static void stop() {
+		throw new StopMatchException();
+	}
 	
 	
 	
 	
-	
 }

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

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

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

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

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

@@ -7,7 +7,9 @@ import java.util.Set;
 import java.util.Vector;
 import java.util.concurrent.ConcurrentHashMap;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.fun.SaRetFunction;
+import cn.dev33.satoken.util.SaFoxUtil;
 
 /**
  * Session Model
@@ -34,7 +36,11 @@ public class SaSession implements Serializable {
 	 * 构建一个Session对象
 	 */
 	public SaSession() {
-		this(null);
+		/*
+		 * 当Session从Redis中反序列化取出时，框架会误以为创建了新的Session，
+		 * 因此此处不可以调用this(null); 避免监听器收到错误的通知 
+		 */
+		// this(null);
 	}
 
 	/**
@@ -45,7 +51,7 @@ public class SaSession implements Serializable {
 		this.id = id;
 		this.createTime = System.currentTimeMillis();
  		// $$ 通知监听器 
- 		SaTokenManager.getSaTokenListener().doCreateSession(id);
+ 		SaManager.getSaTokenListener().doCreateSession(id);
 	}
 
 	/**
@@ -145,100 +151,6 @@ public class SaSession implements Serializable {
 		}
 	}
 
-	// ----------------------- 存取值
-
-	/**
-	 * 写入一个值
-	 *
-	 * @param key   名称
-	 * @param value 值
-	 */
-	public void setAttribute(String key, Object value) {
-		dataMap.put(key, value);
-		update();
-	}
-
-	/**
-	 * 取出一个值
-	 *
-	 * @param key 名称
-	 * @return 值
-	 */
-	public Object getAttribute(String key) {
-		return dataMap.get(key);
-	}
-
-	/**
-	 * 取值，并指定取不到值时的默认值
-	 *
-	 * @param key          名称
-	 * @param defaultValue 取不到值的时候返回的默认值
-	 * @return value
-	 */
-	public Object getAttribute(String key, Object defaultValue) {
-		Object value = getAttribute(key);
-		if (value != null) {
-			return value;
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * 移除一个值
-	 *
-	 * @param key 要移除的值的名字
-	 */
-	public void removeAttribute(String key) {
-		dataMap.remove(key);
-		update();
-	}
-
-	/**
-	 * 清空所有值
-	 */
-	public void clearAttribute() {
-		dataMap.clear();
-		update();
-	}
-
-	/**
-	 * 是否含有指定key
-	 *
-	 * @param key 是否含有指定值
-	 * @return 是否含有
-	 */
-	public boolean containsAttribute(String key) {
-		return dataMap.containsKey(key);
-	}
-
-	/**
-	 * 返回当前session会话所有key
-	 *
-	 * @return 所有值的key列表
-	 */
-	public Set<String> attributeKeys() {
-		return dataMap.keySet();
-	}
-
-	/**
-	 * 获取数据挂载集合（如果更新map里的值，请调用session.update()方法避免产生脏数据 ）
-	 *
-	 * @return 返回底层储存值的map对象
-	 */
-	public Map<String, Object> getDataMap() {
-		return dataMap;
-	}
-
-	/**
-	 * 写入数据集合 (不改变底层对象，只将此dataMap所有数据进行替换) 
-	 * @param dataMap 数据集合 
-	 */
-	public void refreshDataMap(Map<String, Object> dataMap) {
-		this.dataMap.clear();
-		this.dataMap.putAll(dataMap);
-		this.update();
-	}
-
 	
 	// ----------------------- 一些操作
 
@@ -246,14 +158,14 @@ public class SaSession implements Serializable {
 	 * 更新Session（从持久库更新刷新一下）
 	 */
 	public void update() {
-		SaTokenManager.getSaTokenDao().updateSession(this);
+		SaManager.getSaTokenDao().updateSession(this);
 	}
 
 	/** 注销Session (从持久库删除) */
 	public void logout() {
-		SaTokenManager.getSaTokenDao().deleteSession(this.id);
+		SaManager.getSaTokenDao().deleteSession(this.id);
  		// $$ 通知监听器 
- 		SaTokenManager.getSaTokenListener().doLogoutSession(id);
+ 		SaManager.getSaTokenListener().doLogoutSession(id);
 	}
 
 	/** 当Session上的tokenSign数量为零时，注销会话 */
@@ -268,7 +180,7 @@ public class SaSession implements Serializable {
 	 * @return 此Session的剩余存活时间 (单位: 秒)
 	 */
 	public long getTimeout() {
-		return SaTokenManager.getSaTokenDao().getSessionTimeout(this.id);
+		return SaManager.getSaTokenDao().getSessionTimeout(this.id);
 	}
 	
 	/**
@@ -276,7 +188,7 @@ public class SaSession implements Serializable {
 	 * @param timeout 过期时间 (单位: 秒) 
 	 */
 	public void updateTimeout(long timeout) {
-		SaTokenManager.getSaTokenDao().updateSessionTimeout(this.id, timeout);
+		SaManager.getSaTokenDao().updateSessionTimeout(this.id, timeout);
 	}
 	
 	/**
@@ -285,7 +197,7 @@ public class SaSession implements Serializable {
 	 */
 	public void updateMinTimeout(long minTimeout) {
 		if(getTimeout() < minTimeout) {
-			SaTokenManager.getSaTokenDao().updateSessionTimeout(this.id, minTimeout);
+			SaManager.getSaTokenDao().updateSessionTimeout(this.id, minTimeout);
 		}
 	}
 
@@ -295,7 +207,7 @@ public class SaSession implements Serializable {
 	 */
 	public void updateMaxTimeout(long maxTimeout) {
 		if(getTimeout() > maxTimeout) {
-			SaTokenManager.getSaTokenDao().updateSessionTimeout(this.id, maxTimeout);
+			SaManager.getSaTokenDao().updateSessionTimeout(this.id, maxTimeout);
 		}
 	}
 	
@@ -325,6 +237,24 @@ public class SaSession implements Serializable {
 		return getValueByDefaultValue(get(key), defaultValue);
 	}
 	
+	/**
+	 * 
+	 * 取值 (如果值为null，则执行fun函数获取值) 
+	 * @param <T> 返回值的类型 
+	 * @param key key 
+	 * @param fun 值为null时执行的函数 
+	 * @return 值 
+	 */
+	@SuppressWarnings("unchecked")
+	public <T> T get(String key, SaRetFunction fun) {
+		Object value = get(key);
+		if(value == null) {
+			value = fun.run();
+			set(key, value);
+		}
+		return (T) value;
+	}
+	
 	/**
 	 * 取值 (转String类型) 
 	 * @param key key 
@@ -382,7 +312,7 @@ public class SaSession implements Serializable {
 	 * @return 值 
 	 */
 	public <T> T getModel(String key, Class<T> cs) {
-		return getValueByClass(get(key), cs);
+		return SaFoxUtil.getValueByType(get(key), cs);
 	}
 
 	/**
@@ -399,9 +329,18 @@ public class SaSession implements Serializable {
 		if(valueIsNull(value)) {
 			return (T)defaultValue;
 		}
-		return getValueByClass(value, cs);
+		return SaFoxUtil.getValueByType(value, cs);
 	}
 
+	/**
+	 * 返回当前Session的所有key 
+	 *
+	 * @return 所有值的key列表
+	 */
+	public Set<String> keys() {
+		return dataMap.keySet();
+	}
+	
 	// ---- 其他
 	/**
 	 * 写值
@@ -448,7 +387,34 @@ public class SaSession implements Serializable {
 		update();
 		return this;
 	}
-	
+
+	/**
+	 * 清空所有值
+	 */
+	public void clear() {
+		dataMap.clear();
+		update();
+	}
+
+	/**
+	 * 获取数据挂载集合（如果更新map里的值，请调用session.update()方法避免产生脏数据 ）
+	 *
+	 * @return 返回底层储存值的map对象
+	 */
+	public Map<String, Object> getDataMap() {
+		return dataMap;
+	}
+
+	/**
+	 * 写入数据集合 (不改变底层对象，只将此dataMap所有数据进行替换) 
+	 * @param dataMap 数据集合 
+	 */
+	public void refreshDataMap(Map<String, Object> dataMap) {
+		this.dataMap.clear();
+		this.dataMap.putAll(dataMap);
+		this.update();
+	}
+
 	
 	// --------- 工具方法 
 
@@ -461,44 +427,6 @@ public class SaSession implements Serializable {
 		return value == null || value.equals("");
 	}
 
-	/**
-	 * 将指定值转化为指定类型
-	 * @param <T> 泛型
-	 * @param obj 值
-	 * @param cs 类型
-	 * @return 转换后的值 
-	 */
-	@SuppressWarnings("unchecked")
-	protected <T> T getValueByClass(Object obj, Class<T> cs) {
-		// 如果 obj 本来就是 cs 类型 
-		if(obj != null && obj.getClass().equals(cs)) {
-			return (T)obj;
-		}
-		// 开始转换
-		String obj2 = String.valueOf(obj);
-		Object obj3 = null;
-		if (cs.equals(String.class)) {
-			obj3 = obj2;
-		} else if (cs.equals(int.class) || cs.equals(Integer.class)) {
-			obj3 = Integer.valueOf(obj2);
-		} else if (cs.equals(long.class) || cs.equals(Long.class)) {
-			obj3 = Long.valueOf(obj2);
-		} else if (cs.equals(short.class) || cs.equals(Short.class)) {
-			obj3 = Short.valueOf(obj2);
-		} else if (cs.equals(byte.class) || cs.equals(Byte.class)) {
-			obj3 = Byte.valueOf(obj2);
-		} else if (cs.equals(float.class) || cs.equals(Float.class)) {
-			obj3 = Float.valueOf(obj2);
-		} else if (cs.equals(double.class) || cs.equals(Double.class)) {
-			obj3 = Double.valueOf(obj2);
-		} else if (cs.equals(boolean.class) || cs.equals(Boolean.class)) {
-			obj3 = Boolean.valueOf(obj2);
-		} else {
-			obj3 = (T)obj;
-		}
-		return (T)obj3;
-	}
-	
 	/**
 	 * 根据默认值来获取值
 	 * @param <T> 泛型
@@ -516,9 +444,101 @@ public class SaSession implements Serializable {
 		
 		// 开始转换
 		Class<T> cs = (Class<T>) defaultValue.getClass();
-		return getValueByClass(value, cs);
+		return SaFoxUtil.getValueByType(value, cs);
 	}
 	
 	
 	
+
+	// ----------------------- 旧API 
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.set(key) </h1>
+	 * 写入一个值
+	 *
+	 * @param key   名称
+	 * @param value 值
+	 */
+	@Deprecated
+	public void setAttribute(String key, Object value) {
+		dataMap.put(key, value);
+		update();
+	}
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.get(key) </h1>
+	 * 取出一个值
+	 *
+	 * @param key 名称
+	 * @return 值
+	 */
+	@Deprecated
+	public Object getAttribute(String key) {
+		return dataMap.get(key);
+	}
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.get(key, defaultValue) </h1>
+	 * 取值，并指定取不到值时的默认值
+	 *
+	 * @param key          名称
+	 * @param defaultValue 取不到值的时候返回的默认值
+	 * @return value
+	 */
+	@Deprecated
+	public Object getAttribute(String key, Object defaultValue) {
+		Object value = getAttribute(key);
+		if (value != null) {
+			return value;
+		}
+		return defaultValue;
+	}
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.delete(key) </h1>
+	 * 移除一个值
+	 *
+	 * @param key 要移除的值的名字
+	 */
+	@Deprecated
+	public void removeAttribute(String key) {
+		dataMap.remove(key);
+		update();
+	}
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.clear() </h1>
+	 * 清空所有值
+	 */
+	@Deprecated
+	public void clearAttribute() {
+		dataMap.clear();
+		update();
+	}
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.has(key) </h1>
+	 * 是否含有指定key
+	 *
+	 * @param key 是否含有指定值
+	 * @return 是否含有
+	 */
+	@Deprecated
+	public boolean containsAttribute(String key) {
+		return dataMap.containsKey(key);
+	}
+
+	/**
+	 * <h1> 此函数设计已过时，未来版本可能移除此类，请及时更换为: session.keys() </h1>
+	 * 返回当前session会话所有key
+	 *
+	 * @return 所有值的key列表
+	 */
+	@Deprecated
+	public Set<String> attributeKeys() {
+		return dataMap.keySet();
+	}
+
+	
+	
 }

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

@@ -1,6 +1,6 @@
 package cn.dev33.satoken.session;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
 
 /**
  * 自定义Session工具类
@@ -11,28 +11,28 @@ import cn.dev33.satoken.SaTokenManager;
 public class SaSessionCustomUtil {
 
 	/**
-	 * 添加上指定前缀，防止恶意伪造session
+	 * 添加上指定前缀，防止恶意伪造Session
 	 */
 	public static String sessionKey = "custom";
 
 	/**
-	 * 组织一下自定义Session的id
+	 * 拼接Key: 自定义Session的Id
 	 * 
 	 * @param sessionId 会话id
 	 * @return sessionId
 	 */
 	public static String splicingSessionKey(String sessionId) {
-		return SaTokenManager.getConfig().getTokenName() + ":" + sessionKey + ":session:" + sessionId;
+		return SaManager.getConfig().getTokenName() + ":" + sessionKey + ":session:" + sessionId;
 	}
 
 	/**
-	 * 验证指定key的Session是否存在
+	 * 指定key的Session是否存在
 	 * 
-	 * @param sessionId session的id
+	 * @param sessionId Session的id
 	 * @return 是否存在
 	 */
 	public static boolean isExists(String sessionId) {
-		return SaTokenManager.getSaTokenDao().getSession(splicingSessionKey(sessionId)) != null;
+		return SaManager.getSaTokenDao().getSession(splicingSessionKey(sessionId)) != null;
 	}
 
 	/**
@@ -43,10 +43,10 @@ public class SaSessionCustomUtil {
 	 * @return SaSession
 	 */
 	public static SaSession getSessionById(String sessionId, boolean isCreate) {
-		SaSession session = SaTokenManager.getSaTokenDao().getSession(splicingSessionKey(sessionId));
+		SaSession session = SaManager.getSaTokenDao().getSession(splicingSessionKey(sessionId));
 		if (session == null && isCreate) {
-			session = SaTokenManager.getSaTokenAction().createSession(sessionId);
-			SaTokenManager.getSaTokenDao().setSession(session, SaTokenManager.getConfig().getTimeout());
+			session = SaManager.getSaTokenAction().createSession(splicingSessionKey(sessionId));
+			SaManager.getSaTokenDao().setSession(session, SaManager.getConfig().getTimeout());		
 		}
 		return session;
 	}
@@ -62,12 +62,12 @@ public class SaSessionCustomUtil {
 	}
 
 	/**
-	 * 删除指定key的session
+	 * 删除指定key的Session 
 	 * 
 	 * @param sessionId 指定key
 	 */
 	public static void deleteSessionById(String sessionId) {
-		SaTokenManager.getSaTokenDao().deleteSession(splicingSessionKey(sessionId));
+		SaManager.getSaTokenDao().deleteSession(splicingSessionKey(sessionId));
 	}
 
 }

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

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

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

@@ -0,0 +1,71 @@
+package cn.dev33.satoken.sso;
+
+/**
+ * Sa-Token-SSO模块相关常量
+ * @author kong
+ *
+ */
+public class SaSsoConsts {
+
+	/**
+	 * 所有API接口 
+	 * @author kong 
+	 */
+	public static final class Api {
+		
+		/** SSO-Server端：授权地址 */ 
+		public static String ssoAuth = "/sso/auth";
+
+		/** SSO-Server端：RestAPI 登录接口 */ 
+		public static String ssoDoLogin = "/sso/doLogin";
+
+		/** SSO-Server端：校验ticket 获取账号id */ 
+		public static String ssoCheckTicket = "/sso/checkTicket";
+
+		/** SSO-Server端 (and Client端)：单点注销 */ 
+		public static String ssoLogout = "/sso/logout";
+
+		/** SSO-Client端：登录地址 */ 
+		public static String ssoLogin = "/sso/login";
+
+		/** SSO-Client端：单点注销的回调 */ 
+		public static String ssoLogoutCall = "/sso/logoutCall";
+		
+	}
+	
+	/**
+	 * 所有参数名称 
+	 * @author kong 
+	 */
+	public static final class ParamName {
+
+		/** redirect参数名称 */
+		public static String redirect = "redirect";
+		
+		/** ticket参数名称 */
+		public static String ticket = "ticket";
+
+		/** back参数名称 */
+		public static String back = "back";
+
+		/** loginId参数名称 */
+		public static String loginId = "loginId";
+
+		/** secretkey参数名称 */
+		public static String secretkey = "secretkey";
+		
+		/** Client端单点注销时-回调URL 参数名称 */
+		public static String ssoLogoutCall = "ssoLogoutCall";
+
+	}
+
+	/** Client端单点注销回调URL的Set集合，存储在Session中使用的key */
+	public static final String SLO_CALLBACK_SET_KEY = "SLO_CALLBACK_SET_KEY_";
+
+	/** 表示OK的返回结果 */
+	public static final String OK = "ok";
+
+	/** 表示请求没有得到任何有效处理 */
+	public static final String NOT_HANDLE = "not handle";
+	
+}

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

@@ -0,0 +1,190 @@
+package cn.dev33.satoken.sso;
+
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.config.SaSsoConfig;
+import cn.dev33.satoken.context.SaHolder;
+import cn.dev33.satoken.context.model.SaRequest;
+import cn.dev33.satoken.context.model.SaResponse;
+import cn.dev33.satoken.router.SaRouter;
+import cn.dev33.satoken.sso.SaSsoConsts.Api;
+import cn.dev33.satoken.sso.SaSsoConsts.ParamName;
+import cn.dev33.satoken.stp.StpLogic;
+import cn.dev33.satoken.util.SaFoxUtil;
+import cn.dev33.satoken.util.SaResult;
+
+/**
+ * Sa-Token-SSO 单点登录请求处理类封装 
+ * @author kong
+ *
+ */
+public class SaSsoHandle {
+
+	/**
+	 * 处理Server端请求 
+	 * @return 处理结果 
+	 */
+	public static Object serverRequest() {
+		
+		// 获取变量 
+		SaRequest req = SaHolder.getRequest();
+		SaResponse res = SaHolder.getResponse();
+		SaSsoConfig sso = SaManager.getConfig().getSso();
+		StpLogic stpLogic = SaSsoUtil.saSsoTemplate.stpLogic;
+		
+		// ---------- SSO-Server端：单点登录授权地址 
+		if(match(Api.ssoAuth)) {
+			// ---------- 此处两种情况分开处理：
+			// 情况1：在SSO认证中心尚未登录，则先去登登录 
+			if(stpLogic.isLogin() == false) {
+				return sso.notLoginView.get();
+			}
+			// 情况2：在SSO认证中心已经登录，开始构建授权重定向地址，下放ticket
+			String redirectUrl = SaSsoUtil.buildRedirectUrl(stpLogic.getLoginId(), req.getParameter(ParamName.redirect));
+			return res.redirect(redirectUrl);
+		}
+
+		// ---------- SSO-Server端：RestAPI 登录接口  
+		if(match(Api.ssoDoLogin)) {
+			return sso.doLoginHandle.apply(req.getParameter("name"), req.getParameter("pwd"));
+		}
+
+		// ---------- SSO-Server端：校验ticket 获取账号id 
+		if(match(Api.ssoCheckTicket) && sso.isHttp) {
+			String ticket = req.getParameter(ParamName.ticket);
+			String sloCallback = req.getParameter(ParamName.ssoLogoutCall);
+			
+			// 校验ticket，获取对应的账号id 
+			Object loginId = SaSsoUtil.checkTicket(ticket);
+			
+			// 注册此客户端的单点注销回调URL 
+			SaSsoUtil.registerSloCallbackUrl(loginId, sloCallback);
+			
+			// 返回给Client端 
+			return loginId;
+		}
+		
+		// ---------- SSO-Server端：单点注销 
+		if(match(Api.ssoLogout) && sso.isSlo) {
+			String loginId = req.getParameter(ParamName.loginId);
+			String secretkey = req.getParameter(ParamName.secretkey);
+			
+			 // 遍历通知Client端注销会话 
+	        SaSsoUtil.singleLogout(secretkey, loginId, url -> sso.sendHttp.apply(url)); 
+	        	
+	        // 完成
+	        return SaSsoConsts.OK;
+		}
+		
+		// 默认返回 
+		return SaSsoConsts.NOT_HANDLE;
+	}
+	
+	/**
+	 * 处理Client端请求 
+	 * @return 处理结果 
+	 */
+	public static Object clientRequest() {
+
+		// 获取变量 
+		SaRequest req = SaHolder.getRequest();
+		SaResponse res = SaHolder.getResponse();
+		SaSsoConfig sso = SaManager.getConfig().getSso();
+		StpLogic stpLogic = SaSsoUtil.saSsoTemplate.stpLogic;
+
+		// ---------- SSO-Client端：登录地址 
+		if(match(Api.ssoLogin)) {
+			String back = req.getParameter(ParamName.back, "/");
+			String ticket = req.getParameter(ParamName.ticket);
+			
+			// 如果当前Client端已经登录，则无需访问SSO认证中心，可以直接返回 
+			if(stpLogic.isLogin()) {
+				return res.redirect(back);
+			}
+			/*
+			 * 此时有两种情况: 
+			 * 情况1：ticket无值，说明此请求是Client端访问，需要重定向至SSO认证中心
+			 * 情况2：ticket有值，说明此请求从SSO认证中心重定向而来，需要根据ticket进行登录 
+			 */
+			if(ticket == null) {
+				String serverAuthUrl = SaSsoUtil.buildServerAuthUrl(SaHolder.getRequest().getUrl(), back);
+				return res.redirect(serverAuthUrl);
+			} else {
+				// ------- 1、校验ticket，获取账号id 
+				Object loginId = null;
+				if(sso.isHttp) {
+					// 方式1：使用http请求校验ticket 
+					String ssoLogoutCall = null; 
+					if(sso.isSlo) {
+						ssoLogoutCall = SaHolder.getRequest().getUrl().replace(Api.ssoLogin, Api.ssoLogoutCall); 
+					}
+					String checkUrl = SaSsoUtil.buildCheckTicketUrl(ticket, ssoLogoutCall);
+					Object body = sso.sendHttp.apply(checkUrl);
+					loginId = (SaFoxUtil.isEmpty(body) ? null : body);
+				} else {
+					// 方式2：直连Redis校验ticket 
+					loginId = SaSsoUtil.checkTicket(ticket);
+				}
+				// ------- 2、如果loginId有值，说明ticket有效，进行登录并重定向至back地址 
+				if(loginId != null ) {
+					stpLogic.login(loginId); 
+					return res.redirect(back);
+				} else {
+					// 如果ticket无效: 
+					return sso.ticketInvalidView.apply(ticket);
+				}
+			}
+		}
+
+		// ---------- SSO-Client端：单点注销 [模式二]
+		if(match(Api.ssoLogout) && sso.isSlo && sso.isHttp == false) {
+			stpLogic.logout();
+			if(req.getParameter(ParamName.back) == null) {
+				return SaResult.ok("单点注销成功");
+			} else {
+				return res.redirect(req.getParameter(ParamName.back, "/"));
+			}
+		}
+
+		// ---------- SSO-Client端：单点注销 [模式三]
+		if(match(Api.ssoLogout) && sso.isSlo && sso.isHttp) {
+			// 如果未登录，则无需注销 
+	        if(stpLogic.isLogin() == false) {
+	            return SaResult.ok();
+	        }
+	        // 调用SSO-Server认证中心API 
+	        String url = SaSsoUtil.buildSloUrl(stpLogic.getLoginId());
+	        String body = String.valueOf(sso.sendHttp.apply(url));
+	        if(SaSsoConsts.OK.equals(body)) {
+				if(req.getParameter(ParamName.back) == null) {
+					return SaResult.ok("单点注销成功");
+				} else {
+					return res.redirect(req.getParameter(ParamName.back, "/"));
+				}
+	        }
+	        return SaResult.error("单点注销失败"); 
+		}
+
+		// ---------- SSO-Client端：单点注销的回调 	[模式三]
+		if(match(Api.ssoLogoutCall) && sso.isSlo && sso.isHttp) {
+			String loginId = req.getParameter(ParamName.loginId);
+			String secretkey = req.getParameter(ParamName.secretkey);
+			
+			SaSsoUtil.checkSecretkey(secretkey);
+			stpLogic.logoutByTokenValue(stpLogic.getTokenValueByLoginId(loginId));
+	        return SaSsoConsts.OK;
+		}
+		
+		// 默认返回 
+		return SaSsoConsts.NOT_HANDLE;
+	}
+	
+	/**
+	 * 路由匹配算法 
+	 * @param pattern 路由表达式
+	 * @return 是否可以匹配 
+	 */
+	static boolean match(String pattern) {
+		return SaRouter.isMatchCurrURI(pattern);
+	}
+	
+}

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

@@ -0,0 +1,331 @@
+package cn.dev33.satoken.sso;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.config.SaSsoConfig;
+import cn.dev33.satoken.exception.SaTokenException;
+import cn.dev33.satoken.sso.SaSsoConsts.ParamName;
+import cn.dev33.satoken.stp.StpLogic;
+import cn.dev33.satoken.util.SaFoxUtil;
+
+/**
+ * Sa-Token-SSO 单点登录接口 
+ * @author kong
+ *
+ */
+public class SaSsoTemplate {
+	
+	public StpLogic stpLogic;
+	public SaSsoTemplate(StpLogic stpLogic) {
+		this.stpLogic = stpLogic;
+	}
+	
+	/**
+	 * 创建一个 Ticket码 
+	 * @param loginId 账号id 
+	 * @return 票据 
+	 */
+	public String createTicket(Object loginId) {
+		// 随机一个ticket
+		String ticket = randomTicket(loginId);
+		
+		// 保存入库 
+		long ticketTimeout = SaManager.getConfig().getSso().getTicketTimeout();
+		SaManager.getSaTokenDao().set(splicingKeyTicketToId(ticket), String.valueOf(loginId), ticketTimeout); 
+		SaManager.getSaTokenDao().set(splicingKeyIdToTicket(loginId), String.valueOf(ticket), ticketTimeout); 
+		
+		// 返回 
+		return ticket;
+	}
+	
+	/**
+	 * 删除一个 Ticket码
+	 * @param ticket Ticket码
+	 */
+	public void deleteTicket(String ticket) {
+		Object loginId = getLoginId(ticket);
+		if(loginId != null) {
+			SaManager.getSaTokenDao().delete(splicingKeyTicketToId(ticket)); 
+			SaManager.getSaTokenDao().delete(splicingKeyIdToTicket(loginId));
+		}
+	}
+	
+	/**
+	 * 构建URL：Server端向Client下放ticke的地址
+	 * @param loginId 账号id 
+	 * @param redirect Client端提供的重定向地址
+	 * @return see note 
+	 */
+	public String buildRedirectUrl(Object loginId, String redirect) {
+		// 校验重定向地址 
+		checkRedirectUrl(redirect);
+		
+		// 删掉旧ticket  
+		String oldTicket = SaManager.getSaTokenDao().get(splicingKeyIdToTicket(loginId));
+		if(oldTicket != null) {
+			deleteTicket(oldTicket);
+		}
+		
+		// 获取新ticket
+		String ticket = createTicket(loginId);
+		
+		// 构建 授权重定向地址
+		redirect = encodeBackParam(redirect);
+		String redirectUrl = SaFoxUtil.joinParam(redirect, ParamName.ticket, ticket);
+		return redirectUrl;
+	}
+	
+	/**
+	 * 根据 Ticket码 获取账号id，如果Ticket码无效则返回null 
+	 * @param ticket Ticket码
+	 * @return 账号id 
+	 */
+	public Object getLoginId(String ticket) {
+		if(SaFoxUtil.isEmpty(ticket)) {
+			return null;
+		}
+		return SaManager.getSaTokenDao().get(splicingKeyTicketToId(ticket));
+	}
+
+	/**
+	 * 根据 Ticket码 获取账号id，并转换为指定类型 
+	 * @param <T> 要转换的类型 
+	 * @param ticket Ticket码
+	 * @param cs 要转换的类型 
+	 * @return 账号id 
+	 */
+	public <T> T getLoginId(String ticket, Class<T> cs) {
+		return SaFoxUtil.getValueByType(getLoginId(ticket), cs);
+	}
+	
+	/**
+	 * 校验ticket码，获取账号id，如果ticket可以有效，则立刻删除 
+	 * @param ticket Ticket码
+	 * @return 账号id 
+	 */
+	public Object checkTicket(String ticket) {
+		Object loginId = getLoginId(ticket);
+		if(loginId != null) {
+			deleteTicket(ticket);
+		}
+		return loginId;
+	}
+	
+	/**
+	 * 校验重定向url合法性
+	 * @param url 下放ticket的url地址 
+	 */
+	public void checkRedirectUrl(String url) {
+		
+		// 1、是否是一个有效的url
+		if(SaFoxUtil.isUrl(url) == false) {
+			throw new SaTokenException("无效回调地址：" + url);
+		}
+		
+		// 2、截取掉?后面的部分 
+		int qIndex = url.indexOf("?");
+		if(qIndex != -1) {
+			url = url.substring(0, qIndex);
+		}
+		
+		// 3、是否在[允许地址列表]之中 
+		String authUrl = SaManager.getConfig().getSso().getAllowUrl().replaceAll(" ", "");
+		List<String> authUrlList = Arrays.asList(authUrl.split(",")); 
+		if(SaManager.getSaTokenAction().hasElement(authUrlList, url) == false) {
+			throw new SaTokenException("非法回调地址：" + url);
+		}
+		
+		// 验证通过 
+		return;
+	}
+	
+	/**
+	 * 构建URL：Server端 单点登录地址
+	 * @param clientLoginUrl Client端登录地址 
+	 * @param back 回调路径 
+	 * @return [SSO-Server端-认证地址 ]
+	 */
+	public String buildServerAuthUrl(String clientLoginUrl, String back) {
+		// 服务端认证地址 
+		String serverUrl = SaManager.getConfig().getSso().getAuthUrl();
+		
+		// 对back地址编码 
+		back = (back == null ? "" : back);
+		back = SaFoxUtil.encodeUrl(back);
+		
+		// 拼接最终地址，格式示例：serverAuthUrl = http://xxx.com?redirectUrl=xxx.com?back=xxx.com
+		clientLoginUrl = SaFoxUtil.joinParam(clientLoginUrl, ParamName.back, back); 
+		String serverAuthUrl = SaFoxUtil.joinParam(serverUrl, ParamName.redirect, clientLoginUrl);
+		
+		// 返回 
+		return serverAuthUrl;
+	}
+	
+	/**
+	 * 对url中的back参数进行URL编码, 解决超链接重定向后参数丢失的bug 
+	 * @param url url
+	 * @return 编码过后的url 
+	 */
+	public String encodeBackParam(String url) {
+		
+		// 获取back参数所在位置 
+		int index = url.indexOf("?" + ParamName.back + "=");
+		if(index == -1) {
+			index = url.indexOf("&" + ParamName.back + "=");
+			if(index == -1) {
+				return url;
+			}
+		}
+		
+		// 开始编码 
+		int length = ParamName.back.length() + 2;
+		String back = url.substring(index + length);
+		back = SaFoxUtil.encodeUrl(back);
+		
+		// 放回url中 
+		url = url.substring(0, index + length) + back;
+		return url;
+	}
+
+	/**
+	 * 随机一个 Ticket码 
+	 * @param loginId 账号id 
+	 * @return 票据 
+	 */
+	public String randomTicket(Object loginId) {
+		return SaFoxUtil.getRandomString(64);
+	}
+	
+
+	// ------------------- SSO 模式三 ------------------- 
+
+	/**
+	 * 校验secretkey秘钥是否有效 
+	 * @param secretkey 秘钥 
+	 */
+	public void checkSecretkey(String secretkey) {
+		 if(secretkey == null || secretkey.isEmpty() || secretkey.equals(SaManager.getConfig().getSso().getSecretkey()) == false) {
+			 throw new SaTokenException("无效秘钥：" + secretkey);
+		 }
+	}
+	
+	/**
+	 * 构建URL：校验ticket的URL 
+	 * @param ticket ticket码
+	 * @param ssoLogoutCallUrl 单点注销时的回调URL 
+	 * @return 构建完毕的URL 
+	 */
+	public String buildCheckTicketUrl(String ticket, String ssoLogoutCallUrl) {
+		String url = SaManager.getConfig().getSso().getCheckTicketUrl();
+		// 拼接ticket参数 
+		url = SaFoxUtil.joinParam(url, ParamName.ticket, ticket);
+		// 拼接单点注销时的回调URL 
+		if(ssoLogoutCallUrl != null) {
+			url = SaFoxUtil.joinParam(url, ParamName.ssoLogoutCall, ssoLogoutCallUrl);
+		}
+		// 返回 
+		return url;
+	}
+	
+	/**
+	 * 为指定账号id注册单点注销回调URL 
+	 * @param loginId 账号id
+	 * @param sloCallbackUrl 单点注销时的回调URL 
+	 */
+	public void registerSloCallbackUrl(Object loginId, String sloCallbackUrl) {
+		if(loginId == null || sloCallbackUrl == null || sloCallbackUrl.isEmpty()) {
+			return;
+		}
+		Set<String> urlSet = stpLogic.getSessionByLoginId(loginId).get(SaSsoConsts.SLO_CALLBACK_SET_KEY, ()-> new HashSet<String>());
+		urlSet.add(sloCallbackUrl);
+		stpLogic.getSessionByLoginId(loginId).set(SaSsoConsts.SLO_CALLBACK_SET_KEY, urlSet);
+	}
+	
+	/**
+	 * 循环调用Client端单点注销回调 
+	 * @param loginId 账号id
+	 * @param fun 调用方法 
+	 */
+	public void forEachSloUrl(Object loginId, CallSloUrlFunction fun) {
+		String secretkey = SaManager.getConfig().getSso().getSecretkey();
+		Set<String> urlSet = stpLogic.getSessionByLoginId(loginId).get(SaSsoConsts.SLO_CALLBACK_SET_KEY,
+				() -> new HashSet<String>());
+		
+		for (String url : urlSet) {
+			// 拼接：login参数、秘钥参数
+			url = SaFoxUtil.joinParam(url, ParamName.loginId, loginId);
+			url = SaFoxUtil.joinParam(url, ParamName.secretkey, secretkey);
+			// 调用 
+			fun.run(url);
+		}
+	}
+
+	/**
+	 * 构建URL：单点注销URL 
+	 * @param loginId 要注销的账号id
+	 * @return 单点注销URL 
+	 */
+	public String buildSloUrl(Object loginId) {
+		SaSsoConfig ssoConfig = SaManager.getConfig().getSso();
+		String url = ssoConfig.getSloUrl();
+		url = SaFoxUtil.joinParam(url, ParamName.loginId, loginId);
+		url = SaFoxUtil.joinParam(url, ParamName.secretkey, ssoConfig.getSecretkey());
+		return url;
+	}
+	
+	/**
+	 * 指定账号单点注销 
+	 * @param secretkey 校验秘钥
+	 * @param loginId 指定账号 
+	 * @param fun 调用方法 
+	 */
+	public void singleLogout(String secretkey, Object loginId, CallSloUrlFunction fun) {
+		// step.1 校验秘钥 
+		checkSecretkey(secretkey);
+		
+		// step.2 遍历通知Client端注销会话 
+		forEachSloUrl(loginId, fun);
+		
+		// step.3 Server端注销 
+		// StpUtil.logoutByLoginId(loginId);
+		stpLogic.logoutByTokenValue(stpLogic.getTokenValueByLoginId(loginId));
+	}
+
+	
+	
+	// ------------------- 返回相应key ------------------- 
+
+	/** 
+	 * 拼接key：Ticket 查 账号Id 
+	 * @param ticket 
+	 * @return key
+	 */
+	public String splicingKeyTicketToId(String ticket) {
+		return SaManager.getConfig().getTokenName() + ":ticket:" + ticket;
+	}
+
+	/** 
+	 * 拼接key：账号Id 反查 Ticket
+	 * @param id 账号id
+	 * @return key
+	 */
+	public String splicingKeyIdToTicket(Object id) {
+		return SaManager.getConfig().getTokenName() + ":id-ticket:" + id;
+	}
+
+	
+	@FunctionalInterface
+	static interface CallSloUrlFunction{
+		/**
+		 * 调用function 
+		 * @param url 注销回调URL
+		 */
+		public void run(String url);
+	}
+	
+	
+}

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

@@ -0,0 +1,150 @@
+package cn.dev33.satoken.sso;
+
+import cn.dev33.satoken.sso.SaSsoTemplate.CallSloUrlFunction;
+import cn.dev33.satoken.stp.StpUtil;
+
+/**
+ * Sa-Token-SSO 单点登录工具类 
+ * @author kong
+ *
+ */
+public class SaSsoUtil {
+
+	/**
+	 * 底层 SaSsoTemplate 对象 
+	 */
+	public static SaSsoTemplate saSsoTemplate = new SaSsoTemplate(StpUtil.stpLogic);
+	
+	/**
+	 * 创建一个 Ticket票据 
+	 * @param loginId 账号id 
+	 * @return 票据 
+	 */
+	public static String createTicket(Object loginId) {
+		return saSsoTemplate.createTicket(loginId);
+	}
+	
+	/**
+	 * 删除一个 Ticket码
+	 * @param ticket Ticket码
+	 */
+	public static void deleteTicket(String ticket) {
+		saSsoTemplate.deleteTicket(ticket);
+	}
+
+	/**
+	 * 构建URL：Server端向Client下放ticke的地址
+	 * @param loginId 账号id 
+	 * @param redirect Client端提供的重定向地址
+	 * @return see note 
+	 */
+	public static String buildRedirectUrl(Object loginId, String redirect) {
+		return saSsoTemplate.buildRedirectUrl(loginId, redirect);
+	}
+	
+	/**
+	 * 根据 Ticket码 获取账号id，如果Ticket码无效则返回null 
+	 * @param ticket Ticket码
+	 * @return 账号id 
+	 */
+	public static Object getLoginId(String ticket) {
+		return saSsoTemplate.getLoginId(ticket);
+	}
+
+	/**
+	 * 根据 Ticket码 获取账号id，并转换为指定类型 
+	 * @param <T> 要转换的类型 
+	 * @param ticket Ticket码
+	 * @param cs 要转换的类型 
+	 * @return 账号id 
+	 */
+	public static <T> T getLoginId(String ticket, Class<T> cs) {
+		return saSsoTemplate.getLoginId(ticket, cs);
+	}
+
+	/**
+	 * 校验ticket码，获取账号id，如果ticket可以有效，则立刻删除 
+	 * @param ticket Ticket码
+	 * @return 账号id 
+	 */
+	public static Object checkTicket(String ticket) {
+		return saSsoTemplate.checkTicket(ticket);
+	}
+	
+	/**
+	 * 校验重定向url合法性
+	 * @param url 下放ticket的url地址 
+	 */
+	public static void checkAuthUrl(String url) {
+		saSsoTemplate.checkRedirectUrl(url);
+	}
+
+	/**
+	 * 构建URL：Server端 单点登录地址
+	 * @param clientLoginUrl Client端登录地址 
+	 * @param back 回调路径 
+	 * @return [SSO-Server端-认证地址 ]
+	 */
+	public static String buildServerAuthUrl(String clientLoginUrl, String back) {
+		return saSsoTemplate.buildServerAuthUrl(clientLoginUrl, back);
+	}
+
+	
+	// ------------------- SSO 模式三 ------------------- 
+	
+	/**
+	 * 校验secretkey秘钥是否有效 
+	 * @param secretkey 秘钥 
+	 */
+	public static void checkSecretkey(String secretkey) {
+		saSsoTemplate.checkSecretkey(secretkey);
+	}
+
+	/**
+	 * 构建URL：校验ticket的URL 
+	 * @param ticket ticket码
+	 * @param ssoLogoutCallUrl 单点注销时的回调URL 
+	 * @return 构建完毕的URL 
+	 */
+	public static String buildCheckTicketUrl(String ticket, String ssoLogoutCallUrl) {
+		return saSsoTemplate.buildCheckTicketUrl(ticket, ssoLogoutCallUrl);
+	}
+
+	/**
+	 * 为指定账号id注册单点注销回调URL 
+	 * @param loginId 账号id
+	 * @param sloCallbackUrl 单点注销时的回调URL 
+	 */
+	public static void registerSloCallbackUrl(Object loginId, String sloCallbackUrl) {
+		saSsoTemplate.registerSloCallbackUrl(loginId, sloCallbackUrl);
+	}
+
+	/**
+	 * 循环调用Client端单点注销回调 
+	 * @param loginId 账号id
+	 * @param fun 调用方法 
+	 */
+	public static void forEachSloUrl(Object loginId, CallSloUrlFunction fun) {
+		saSsoTemplate.forEachSloUrl(loginId, fun);
+	}
+
+	/**
+	 * 构建URL：单点注销URL 
+	 * @param loginId 要注销的账号id
+	 * @return 单点注销URL 
+	 */
+	public static String buildSloUrl(Object loginId) {
+		return saSsoTemplate.buildSloUrl(loginId);
+	}
+
+	/**
+	 * 指定账号单点注销 
+	 * @param secretkey 校验秘钥
+	 * @param loginId 指定账号 
+	 * @param fun 调用方法 
+	 */
+	public static void singleLogout(String secretkey, Object loginId, CallSloUrlFunction fun) {
+		saSsoTemplate.singleLogout(secretkey, loginId, fun); 
+	}
+
+}

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

@@ -1,12 +1,12 @@
 package cn.dev33.satoken.stp;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
 import cn.dev33.satoken.config.SaTokenConfig;
 import cn.dev33.satoken.dao.SaTokenDao;
 import cn.dev33.satoken.util.SaTokenConsts;
 
 /**
- * 调用 `StpUtil.setLogin()` 时的 [配置参数 Model ]
+ * 调用 `StpUtil.login()` 时的 [配置参数 Model ]
  * @author kong
  *
  */
@@ -30,14 +30,14 @@ public class SaLoginModel {
 
 	
 	/**
-	 * @return device
+	 * @return 参考 {@link #device}
 	 */
 	public String getDevice() {
 		return device;
 	}
 
 	/**
-	 * @param device 要设置的 device
+	 * @param device 参考 {@link #device}
 	 * @return 对象自身
 	 */
 	public SaLoginModel setDevice(String device) {
@@ -46,14 +46,14 @@ public class SaLoginModel {
 	}
 
 	/**
-	 * @return isLastingCookie
+	 * @return 参考 {@link #isLastingCookie}
 	 */
 	public Boolean getIsLastingCookie() {
 		return isLastingCookie;
 	}
 
 	/**
-	 * @param isLastingCookie 要设置的 isLastingCookie
+	 * @param isLastingCookie 参考 {@link #isLastingCookie}
 	 * @return 对象自身
 	 */
 	public SaLoginModel setIsLastingCookie(Boolean isLastingCookie) {
@@ -62,14 +62,14 @@ public class SaLoginModel {
 	}
 
 	/**
-	 * @return timeout
+	 * @return 参考 {@link #timeout}
 	 */
 	public Long getTimeout() {
 		return timeout;
 	}
 
 	/**
-	 * @param timeout 要设置的 timeout
+	 * @param timeout 参考 {@link #timeout}
 	 * @return 对象自身
 	 */
 	public SaLoginModel setTimeout(long timeout) {
@@ -79,7 +79,7 @@ public class SaLoginModel {
 
 
 	/**
-	 * @return cookie时长
+	 * @return Cookie时长
 	 */
 	public int getCookieTimeout() {
 		if(isLastingCookie == false) {
@@ -91,13 +91,12 @@ public class SaLoginModel {
 		return (int)(long)timeout;
 	}
 
-	
 	/**
 	 * 构建对象，初始化默认值 
 	 * @return 对象自身
 	 */
 	public SaLoginModel build() {
-		return build(SaTokenManager.getConfig());
+		return build(SaManager.getConfig());
 	}
 	
 	/**
@@ -118,7 +117,6 @@ public class SaLoginModel {
 		return this;
 	}
 	
-	
 	/**
 	 * 静态方法获取一个 SaLoginModel 对象
 	 * @return SaLoginModel 对象 
@@ -127,7 +125,6 @@ public class SaLoginModel {
 		return new SaLoginModel();
 	}
 
-	
 	/**
 	 * toString
 	 */
@@ -136,7 +133,4 @@ public class SaLoginModel {
 		return "SaLoginModel [device=" + device + ", isLastingCookie=" + isLastingCookie + ", timeout=" + timeout + "]";
 	}
 
-	
-	
-	
 }

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

@@ -1,7 +1,7 @@
 package cn.dev33.satoken.stp;
 
 /**
- * token信息Model: 用来描述一个token的常用参数
+ * Token信息Model: 用来描述一个Token的常用参数
  * 
  * @author kong
  *
@@ -20,8 +20,8 @@ public class SaTokenInfo {
 	/** 此token对应的LoginId，未登录时为null */
 	public Object loginId;
 
-	/** LoginKey账号体系标识 */
-	public String loginKey;
+	/** 账号类型 */
+	public String loginType;
 
 	/** token剩余有效期 (单位: 秒) */
 	public long tokenTimeout;
@@ -38,6 +38,11 @@ public class SaTokenInfo {
 	/** 登录设备标识 */
 	public String loginDevice;
 
+	/** 自定义数据 */
+	public String tag;
+	
+
+
 	/**
 	 * @return token名称 
 	 */
@@ -95,17 +100,17 @@ public class SaTokenInfo {
 	}
 
 	/**
-	 * @return LoginKey账号体系标识 
+	 * @return 账号类型
 	 */
-	public String getLoginKey() {
-		return loginKey;
+	public String getLoginType() {
+		return loginType;
 	}
 
 	/**
-	 * @param loginKey LoginKey账号体系标识 
+	 * @param loginType 账号类型
 	 */
-	public void setLoginKey(String loginKey) {
-		this.loginKey = loginKey;
+	public void setLoginType(String loginType) {
+		this.loginType = loginType;
 	}
 
 	/**
@@ -178,15 +183,32 @@ public class SaTokenInfo {
 		this.loginDevice = loginDevice;
 	}
 
+	/**
+	 * @return 自定义数据
+	 */
+	public String getTag() {
+		return tag;
+	}
+
+	/**
+	 * @param tag 自定义数据
+	 */
+	public void setTag(String tag) {
+		this.tag = tag;
+	}
+
 	/**
 	 * toString
 	 */
 	@Override
 	public String toString() {
 		return "SaTokenInfo [tokenName=" + tokenName + ", tokenValue=" + tokenValue + ", isLogin=" + isLogin
-				+ ", loginId=" + loginId + ", loginKey=" + loginKey + ", tokenTimeout=" + tokenTimeout
+				+ ", loginId=" + loginId + ", loginType=" + loginType + ", tokenTimeout=" + tokenTimeout
 				+ ", sessionTimeout=" + sessionTimeout + ", tokenSessionTimeout=" + tokenSessionTimeout
-				+ ", tokenActivityTimeout=" + tokenActivityTimeout + ", loginDevice=" + loginDevice + "]";
+				+ ", tokenActivityTimeout=" + tokenActivityTimeout + ", loginDevice=" + loginDevice + ", tag=" + tag
+				+ "]";
 	}
+	
+	
 
 }

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

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

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

@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * 对StpInterface接口默认的实现类
+ * 对 {@link StpInterface} 接口默认的实现类
  * <p>
  * 如果开发者没有实现StpInterface接口，则使用此默认实现
  * 
@@ -13,12 +13,12 @@ import java.util.List;
 public class StpInterfaceDefaultImpl implements StpInterface {
 
 	@Override
-	public List<String> getPermissionList(Object loginId, String loginKey) {
+	public List<String> getPermissionList(Object loginId, String loginType) {
 		return new ArrayList<String>();
 	}
 
 	@Override
-	public List<String> getRoleList(Object loginId, String loginKey) {
+	public List<String> getRoleList(Object loginId, String loginType) {
 		return new ArrayList<String>();
 	}
 

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

@@ -6,23 +6,27 @@ import cn.dev33.satoken.fun.SaFunction;
 import cn.dev33.satoken.session.SaSession;
 
 /**
- * 一个默认的实现 
+ * Sa-Token 权限验证工具类 
  * @author kong 
  */
 public class StpUtil {
-
+	
+	/**
+	 * 账号类型标识 
+	 */
+	public static final String TYPE = "login";
+	
 	/**
 	 * 底层的 StpLogic 对象  
 	 */
-	public static StpLogic stpLogic = new StpLogic("login"); 
+	public static StpLogic stpLogic = new StpLogic(TYPE); 
 
-	
 	/**
-	 * 获取当前StpLogin的loginKey 
-	 * @return 当前StpLogin的loginKey
+	 * 获取当前 StpLogic 的账号类型
+	 * @return See Note 
 	 */
-	public static String getLoginKey(){
-		return stpLogic.getLoginKey();
+	public static String getLoginType(){
+		return stpLogic.getLoginType();
 	}
 
 	
@@ -37,7 +41,7 @@ public class StpUtil {
  	}
 
  	/**
- 	 * 在当前会话写入当前tokenValue 
+ 	 * 在当前会话写入当前TokenValue 
  	 * @param tokenValue token值 
  	 * @param cookieTimeout Cookie存活时间(秒)
  	 */
@@ -46,7 +50,7 @@ public class StpUtil {
 	}
  	
 	/**
-	 * 获取当前tokenValue
+	 * 获取当前TokenValue
 	 * @return 当前tokenValue
 	 */
 	public static String getTokenValue() {
@@ -54,7 +58,7 @@ public class StpUtil {
 	}
 
 	/**
-	 * 获取当前会话的token信息 
+	 * 获取当前会话的Token信息 
 	 * @return token信息 
 	 */
 	public static SaTokenInfo getTokenInfo() {
@@ -65,49 +69,49 @@ public class StpUtil {
 	// =================== 登录相关操作 ===================
 
 	/**
-	 * 在当前会话上登录id 
-	 * @param loginId 登录id，建议的类型：（long | int | String）
+	 * 会话登录 
+	 * @param id 账号id，建议的类型：（long | int | String）
 	 */
-	public static void setLoginId(Object loginId) {
-		stpLogic.setLoginId(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 setLoginId(Object loginId, String device) {
-		stpLogic.setLoginId(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 setLoginId(Object loginId, boolean isLastingCookie) {
-		stpLogic.setLoginId(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 setLoginId(Object loginId, SaLoginModel loginModel) {
-		stpLogic.setLoginId(loginId, loginModel);
+	public static void login(Object id, SaLoginModel loginModel) {
+		stpLogic.login(id, loginModel);
 	}
 	
 	/** 
-	 * 当前会话注销登录
+	 * 会话注销
 	 */
 	public static void logout() {
 		stpLogic.logout();
 	}
 
 	/**
-	 * 指定token的会话注销登录 
+	 * 会话注销，根据指定Token
 	 * @param tokenValue 指定token
 	 */
 	public static void logoutByTokenValue(String tokenValue) {
@@ -115,8 +119,8 @@ public class StpUtil {
 	}
 	
 	/**
-	 * 指定loginId的会话注销登录（踢人下线）
-	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
+	 * 会话注销，根据账号id （踢人下线）
+	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2 </p>
 	 * @param loginId 账号id 
 	 */
 	public static void logoutByLoginId(Object loginId) {
@@ -124,7 +128,7 @@ public class StpUtil {
 	}
 
 	/**
-	 * 指定loginId指定设备的会话注销登录（踢人下线）
+	 * 会话注销，根据账号id and 设备标识 （踢人下线）
 	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
 	 * @param loginId 账号id 
 	 * @param device 设备标识 
@@ -133,53 +137,17 @@ public class StpUtil {
 		stpLogic.logoutByLoginId(loginId, device);
 	}
 
-	/**
-	 * 封禁指定账号
-	 * <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常 
-	 * @param loginId 指定账号id 
-	 * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
-	 */
-	public static void disable(Object loginId, long disableTime) {
-		stpLogic.disable(loginId, disableTime);
-	}
-	
-	/**
-	 * 指定账号是否已被封禁 (true=已被封禁, false=未被封禁) 
-	 * @param loginId 账号id
-	 * @return see note
-	 */
-	public static boolean isDisable(Object loginId) {
-		return stpLogic.isDisable(loginId);
-	}
-	
-	/**
-	 * 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
-	 * @param loginId 账号id
-	 * @return see note 
-	 */
-	public static long getDisableTime(Object loginId) {
-		return stpLogic.getDisableTime(loginId);
-	}
-
-	/**
-	 * 解封指定账号
-	 * @param loginId 账号id 
-	 */
-	public static void untieDisable(Object loginId) {
-		stpLogic.untieDisable(loginId);
-	}
-	
 	// 查询相关
 
- 	/** 
- 	 * 获取当前会话是否已经登录 
+	/** 
+ 	 * 当前会话是否已经登录 
  	 * @return 是否已登录 
  	 */
 	public static boolean isLogin() {
 		return stpLogic.isLogin();
 	}
 
- 	/** 
+	/** 
  	 * 检验当前会话是否已经登录，如未登录，则抛出异常 
  	 */
  	public static void checkLogin() {
@@ -195,7 +163,7 @@ public class StpUtil {
 	}
 
 	/** 
-	 * 获取当前会话登录id, 如果未登录，则返回默认值 
+	 * 获取当前会话账号id, 如果未登录，则返回默认值 
 	 * @param <T> 返回类型 
 	 * @param defaultValue 默认值
 	 * @return 登录id 
@@ -205,7 +173,7 @@ public class StpUtil {
 	}
 
 	/** 
-	 * 获取当前会话登录id, 如果未登录，则返回null 
+	 * 获取当前会话账号id, 如果未登录，则返回null 
 	 * @return 账号id 
 	 */
 	public static Object getLoginIdDefaultNull() {
@@ -213,7 +181,7 @@ public class StpUtil {
  	}
 
 	/** 
-	 * 获取当前会话登录id, 并转换为String
+	 * 获取当前会话账号id, 并转换为String类型
 	 * @return 账号id 
 	 */
 	public static String getLoginIdAsString() {
@@ -221,7 +189,7 @@ public class StpUtil {
 	}
 
 	/** 
-	 * 获取当前会话登录id, 并转换为int
+	 * 获取当前会话账号id, 并转换为int类型
 	 * @return 账号id 
 	 */
 	public static int getLoginIdAsInt() {
@@ -229,17 +197,17 @@ public class StpUtil {
 	}
 
 	/**
-	 * 获取当前会话登录id, 并转换为long
+	 * 获取当前会话账号id, 并转换为long类型 
 	 * @return 账号id 
 	 */
 	public static long getLoginIdAsLong() {
 		return stpLogic.getLoginIdAsLong();
 	}
 
- 	/** 
- 	 * 获取指定token对应的登录id，如果未登录，则返回 null 
+	/** 
+ 	 * 获取指定Token对应的账号id，如果未登录，则返回 null 
  	 * @param tokenValue token
- 	 * @return 登录id
+ 	 * @return 账号id
  	 */
  	public static Object getLoginIdByToken(String tokenValue) {
  		return stpLogic.getLoginIdByToken(tokenValue);
@@ -248,46 +216,46 @@ public class StpUtil {
  	
 	// =================== session相关 ===================
 
-	/** 
-	 * 获取指定loginId的session, 如果session尚未创建，isCreate=是否新建并返回
+ 	/** 
+	 * 获取指定账号id的Session, 如果Session尚未创建，isCreate=是否新建并返回
 	 * @param loginId 账号id
 	 * @param isCreate 是否新建
-	 * @return SaSession
+	 * @return Session对象
 	 */
 	public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
 		return stpLogic.getSessionByLoginId(loginId, isCreate);
 	}
 
 	/** 
-	 * 获取指定key的session, 如果session尚未创建，则返回null
-	 * @param sessionId sessionId
-	 * @return session对象 
+	 * 获取指定key的Session, 如果Session尚未创建，则返回null
+	 * @param sessionId SessionId
+	 * @return Session对象 
 	 */
 	public static SaSession getSessionBySessionId(String sessionId) {
 		return stpLogic.getSessionBySessionId(sessionId);
 	}
 
 	/** 
-	 * 获取指定loginId的session，如果session尚未创建，则新建并返回 
+	 * 获取指定账号id的Session，如果Session尚未创建，则新建并返回 
 	 * @param loginId 账号id 
-	 * @return session会话 
+	 * @return Session对象 
 	 */
 	public static SaSession getSessionByLoginId(Object loginId) {
 		return stpLogic.getSessionByLoginId(loginId);
 	}
 
 	/** 
-	 * 获取当前会话的session, 如果session尚未创建，isCreate=是否新建并返回 
+	 * 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回 
 	 * @param isCreate 是否新建 
-	 * @return 当前会话的session 
+	 * @return Session对象 
 	 */
 	public static SaSession getSession(boolean isCreate) {
 		return stpLogic.getSession(isCreate);
 	}
 
 	/** 
-	 * 获取当前会话的session，如果session尚未创建，则新建并返回 
-	 * @return 当前会话的session 
+	 * 获取当前会话的Session，如果Session尚未创建，则新建并返回 
+	 * @return Session对象 
 	 */
 	public static SaSession getSession() {
 		return stpLogic.getSession();
@@ -297,17 +265,17 @@ public class StpUtil {
 	// =================== token专属session ===================  
 	
 	/** 
-	 * 获取指定token的专属session，如果session尚未创建，则新建并返回 
-	 * @param tokenValue token值
-	 * @return session会话 
+	 * 获取指定Token-Session，如果Session尚未创建，则新建并返回 
+	 * @param tokenValue Token值
+	 * @return Session对象  
 	 */
 	public static SaSession getTokenSessionByToken(String tokenValue) {
 		return stpLogic.getTokenSessionByToken(tokenValue);
 	}
 	
 	/** 
-	 * 获取当前token的专属-session，如果session尚未创建，则新建并返回 
-	 * @return session会话 
+	 * 获取当前Token-Session，如果Session尚未创建，则新建并返回
+	 * @return Session对象 
 	 */
 	public static SaSession getTokenSession() {
 		return stpLogic.getTokenSession();
@@ -316,7 +284,7 @@ public class StpUtil {
 
 	// =================== [临时过期] 验证相关 ===================  
 
- 	/**
+	/**
  	 * 检查当前token 是否已经[临时过期]，如果已经过期则抛出异常  
  	 */
  	public static void checkActivityTimeout() {
@@ -372,7 +340,7 @@ public class StpUtil {
 	// =================== 角色验证操作 ===================  
 
  	/** 
- 	 * 指定账号id是否含有角色标识, 返回true或false  
+ 	 * 指定账号id是否含有角色标识, 返回true或false 
  	 * @param loginId 账号id
  	 * @param role 角色标识
  	 * @return 是否含有指定角色标识
@@ -464,7 +432,7 @@ public class StpUtil {
 	// =================== id 反查token 相关操作 ===================  
 	
 	/** 
-	 * 获取指定loginId的tokenValue 
+	 * 获取指定账号id的tokenValue 
 	 * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
 	 * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId 
 	 * @param loginId 账号id
@@ -475,7 +443,7 @@ public class StpUtil {
 	}
 
 	/** 
-	 * 获取指定loginId指定设备端的tokenValue  
+	 * 获取指定账号id指定设备端的tokenValue 
 	 * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
 	 * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId 
 	 * @param loginId 账号id
@@ -486,8 +454,8 @@ public class StpUtil {
 		return stpLogic.getTokenValueByLoginId(loginId, device);
 	}
 	
- 	/** 
-	 * 获取指定loginId的tokenValue集合 
+	/** 
+	 * 获取指定账号id的tokenValue集合 
 	 * @param loginId 账号id 
 	 * @return 此loginId的所有相关token 
  	 */
@@ -495,8 +463,8 @@ public class StpUtil {
 		return stpLogic.getTokenValueListByLoginId(loginId);
 	}
 
- 	/** 
-	 * 获取指定loginId指定设备端的tokenValue集合 
+	/** 
+	 * 获取指定账号id指定设备端的tokenValue 集合 
 	 * @param loginId 账号id 
 	 * @param device 设备标识 
 	 * @return 此loginId的所有相关token 
@@ -506,7 +474,7 @@ public class StpUtil {
 	}
 	
 	/**
-	 * 返回当前token的登录设备 
+	 * 返回当前会话的登录设备 
 	 * @return 当前令牌的登录设备 
 	 */
 	public static String getLoginDevice() {
@@ -517,7 +485,7 @@ public class StpUtil {
 	// =================== 会话管理 ===================  
 
 	/**
-	 * 根据条件查询token 
+	 * 根据条件查询Token 
 	 * @param keyword 关键字 
 	 * @param start 开始处索引 (-1代表查询所有) 
 	 * @param size 获取数量 
@@ -539,7 +507,7 @@ public class StpUtil {
 	}
 
 	/**
-	 * 根据条件查询token专属Session的Id 
+	 * 根据条件查询Token专属Session的Id 
 	 * @param keyword 关键字 
 	 * @param start 开始处索引 (-1代表查询所有) 
 	 * @param size 获取数量 
@@ -548,12 +516,51 @@ public class StpUtil {
 	public static List<String> searchTokenSessionId(String keyword, int start, int size) {
 		return stpLogic.searchTokenSessionId(keyword, start, size);
 	}
-	
 
+	
+	// ------------------- 账号封禁 -------------------  
+
+	/**
+	 * 封禁指定账号
+	 * <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常 
+	 * @param loginId 指定账号id 
+	 * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
+	 */
+	public static void disable(Object loginId, long disableTime) {
+		stpLogic.disable(loginId, disableTime);
+	}
+	
+	/**
+	 * 指定账号是否已被封禁 (true=已被封禁, false=未被封禁) 
+	 * @param loginId 账号id
+	 * @return see note
+	 */
+	public static boolean isDisable(Object loginId) {
+		return stpLogic.isDisable(loginId);
+	}
+	
+	/**
+	 * 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
+	 * @param loginId 账号id
+	 * @return see note 
+	 */
+	public static long getDisableTime(Object loginId) {
+		return stpLogic.getDisableTime(loginId);
+	}
+
+	/**
+	 * 解封指定账号
+	 * @param loginId 账号id 
+	 */
+	public static void untieDisable(Object loginId) {
+		stpLogic.untieDisable(loginId);
+	}
+	
+	
 	// =================== 身份切换 ===================  
 
 	/**
-	 * 临时切换身份为指定loginId 
+	 * 临时切换身份为指定账号id 
 	 * @param loginId 指定loginId 
 	 */
 	public static void switchTo(Object loginId) {
@@ -576,13 +583,109 @@ public class StpUtil {
 	}
 
 	/**
-	 * 在一个代码段里方法内，临时切换身份为指定loginId
-	 * @param loginId 指定loginId 
+	 * 在一个代码段里方法内，临时切换身份为指定账号id
+	 * @param loginId 指定账号id 
 	 * @param function 要执行的方法 
 	 */
 	public static void switchTo(Object loginId, SaFunction function) {
 		stpLogic.switchTo(loginId, function);
 	}
 	
+
+	// ------------------- 二级认证 -------------------  
+	
+	/**
+	 * 在当前会话 开启二级认证 
+	 * @param safeTime 维持时间 (单位: 秒) 
+	 */
+	public static void openSafe(long safeTime) {
+		stpLogic.openSafe(safeTime);
+	}
+
+	/**
+	 * 当前会话 是否处于二级认证时间内 
+	 * @return true=二级认证已通过, false=尚未进行二级认证或认证已超时 
+	 */
+	public static boolean isSafe() {
+		return stpLogic.isSafe();
+	}
+
+	/**
+	 * 检查当前会话是否已通过二级认证，如未通过则抛出异常 
+	 */
+	public static void checkSafe() {
+		stpLogic.checkSafe();
+	}
+	
+	/**
+	 * 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
+	 * @return 剩余有效时间
+	 */
+	public static long getSafeTime() {
+		return stpLogic.getSafeTime();
+	}
+
+	/**
+	 * 在当前会话 结束二级认证 
+	 */
+	public static void closeSafe() {
+		stpLogic.closeSafe();
+	}
+
+
+	// =================== 历史API，兼容旧版本 ===================  
+
+	/**
+	 * <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);
+	}
 	
 }

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

@@ -0,0 +1,10 @@
+package cn.dev33.satoken.temp;
+
+/**
+ * Sa-Token 临时令牌验证模块 默认实现类 
+ * @author kong
+ *
+ */
+public class SaTempDefaultImpl implements SaTempInterface {
+	
+}

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

@@ -0,0 +1,80 @@
+package cn.dev33.satoken.temp;
+
+import cn.dev33.satoken.SaManager;
+import cn.dev33.satoken.util.SaFoxUtil;
+
+/**
+ * Sa-Token 临时令牌验证模块接口 
+ * @author kong
+ *
+ */
+public interface SaTempInterface {
+
+	/**
+	 * 根据value创建一个token 
+	 * @param value 指定值
+	 * @param timeout 有效期，单位：秒 
+	 * @return 生成的token
+	 */
+	public default String createToken(Object value, long timeout) {
+		
+		// 生成 token 
+		String token = SaManager.getSaTokenAction().createToken(null, null);
+		
+		// 持久化映射关系 
+		String key = splicingKeyTempToken(token);
+		SaManager.getSaTokenDao().setObject(key, value, timeout);
+		
+		// 返回 
+		return token;
+	}
+	
+	/**
+	 *  解析token获取value 
+	 * @param token 指定token 
+	 * @return  See Note 
+	 */
+	public default Object parseToken(String token) {
+		String key = splicingKeyTempToken(token);
+		return SaManager.getSaTokenDao().getObject(key);
+	}
+
+	/**
+	 * 解析token获取value，并转换为指定类型 
+	 * @param token 指定token 
+	 * @param cs 指定类型 
+	 * @param <T> 默认值的类型 
+	 * @return  See Note 
+	 */
+	public default<T> T parseToken(String token, Class<T> cs) {
+		return SaFoxUtil.getValueByType(parseToken(token), cs);
+	}
+	
+	/**
+	 * 获取指定 token 的剩余有效期，单位：秒 
+	 * <p> 返回值 -1 代表永久，-2 代表token无效 
+	 * @param token see note 
+	 * @return see note 
+	 */
+	public default long getTimeout(String token) {
+		String key = splicingKeyTempToken(token);
+		return SaManager.getSaTokenDao().getObjectTimeout(key);
+	}
+	
+	/**  
+	 * 获取映射关系的持久化key 
+	 * @param token token值
+	 * @return key
+	 */
+	public default String splicingKeyTempToken(String token) {
+		return SaManager.getConfig().getTokenName() + ":temp-token:" + token;
+	}
+
+	/**
+	 * @return jwt秘钥 (只有集成 sa-token-temp-jwt 模块时此参数才会生效)  
+	 */
+	public default String getJwtSecretKey() {
+		return null;
+	}
+	
+}

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

@@ -0,0 +1,52 @@
+package cn.dev33.satoken.temp;
+
+import cn.dev33.satoken.SaManager;
+
+/**
+ * Sa-Token 临时验证令牌模块 
+ * @author kong
+ *
+ */
+public class SaTempUtil {
+
+	/**
+	 * 根据value创建一个token 
+	 * @param value 指定值
+	 * @param timeout 有效期，单位：秒 
+	 * @return 生成的token
+	 */
+	public static String createToken(Object value, long timeout) {
+		return SaManager.getSaTemp().createToken(value, timeout);
+	}
+	
+	/**
+	 *  解析token获取value 
+	 * @param token 指定token 
+	 * @return  See Note 
+	 */
+	public static Object parseToken(String token) {
+		return SaManager.getSaTemp().parseToken(token);
+	}
+
+	/**
+	 * 解析token获取value，并转换为指定类型 
+	 * @param token 指定token 
+	 * @param cs 指定类型 
+	 * @param <T> 默认值的类型 
+	 * @return  See Note 
+	 */
+	public static<T> T parseToken(String token, Class<T> cs) {
+		return SaManager.getSaTemp().parseToken(token, cs);
+	}
+	
+	/**
+	 * 获取指定 token 的剩余有效期，单位：秒 
+	 * <p> 返回值 -1 代表永久，-2 代表token无效 
+	 * @param token see note 
+	 * @return see note 
+	 */
+	public static long getTimeout(String token) {
+		return SaManager.getSaTemp().getTimeout(token);
+	}
+	
+}

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

@@ -0,0 +1,307 @@
+package cn.dev33.satoken.util;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.regex.Pattern;
+
+import cn.dev33.satoken.exception.SaTokenException;
+
+/**
+ * Sa-Token 内部工具类 
+ * 
+ * @author kong
+ *
+ */
+public class SaFoxUtil {
+
+	/**
+	 * 打印 Sa-Token 版本字符画
+	 */
+	public static void printSaToken() {
+		String str = "____ ____    ___ ____ _  _ ____ _  _ \r\n" + "[__  |__| __  |  |  | |_/  |___ |\\ | \r\n"
+				+ "___] |  |     |  |__| | \\_ |___ | \\| " 
+//				+ "sa-token：" 
+				+ "\r\n" + "DevDoc：" + SaTokenConsts.DEV_DOC_URL // + "\r\n";
+				+ " (" + SaTokenConsts.VERSION_NO + ")" 
+				+ "\r\n" + "GitHub：" + SaTokenConsts.GITHUB_URL // + "\r\n";
+				;
+		System.out.println(str);
+	}
+
+	/**
+	 * 生成指定长度的随机字符串
+	 * 
+	 * @param length 字符串的长度
+	 * @return 一个随机字符串
+	 */
+	public static String getRandomString(int length) {
+		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+		Random random = new Random();
+		StringBuffer sb = new StringBuffer();
+		for (int i = 0; i < length; i++) {
+			int number = random.nextInt(62);
+			sb.append(str.charAt(number));
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 指定元素是否为null或者空字符串
+	 * @param str 指定元素 
+	 * @return 是否为null或者空字符串
+	 */
+	public static boolean isEmpty(Object str) {
+		return str == null || "".equals(str);
+	}
+	
+	/**
+	 * 以当前时间戳和随机int数字拼接一个随机字符串
+	 * 
+	 * @return 随机字符串
+	 */
+	public static String getMarking28() {
+		return System.currentTimeMillis() + "" + new Random().nextInt(Integer.MAX_VALUE);
+	}
+
+	/**
+	 * 将日期格式化 （yyyy-MM-dd HH:mm:ss）
+	 * @param date 日期
+	 * @return 格式化后的时间 
+	 */
+	public static String formatDate(Date date){
+		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
+	}
+	
+	/**
+	 * 从集合里查询数据
+	 * 
+	 * @param dataList 数据集合
+	 * @param prefix   前缀
+	 * @param keyword  关键字
+	 * @param start    起始位置 (-1代表查询所有)
+	 * @param size     获取条数
+	 * @return 符合条件的新数据集合
+	 */
+	public static List<String> searchList(Collection<String> dataList, String prefix, String keyword, int start,
+			int size) {
+		if (prefix == null) {
+			prefix = "";
+		}
+		if (keyword == null) {
+			keyword = "";
+		}
+		// 挑选出所有符合条件的
+		List<String> list = new ArrayList<String>();
+		Iterator<String> keys = dataList.iterator();
+		while (keys.hasNext()) {
+			String key = keys.next();
+			if (key.startsWith(prefix) && key.indexOf(keyword) > -1) {
+				list.add(key);
+			}
+		}
+		// 取指定段数据
+		return searchList(list, start, size);
+	}
+
+	/**
+	 * 从集合里查询数据
+	 * 
+	 * @param list  数据集合
+	 * @param start 起始位置 (-1代表查询所有)
+	 * @param size  获取条数
+	 * @return 符合条件的新数据集合
+	 */
+	public static List<String> searchList(List<String> list, int start, int size) {
+		// 取指定段数据
+		if (start < 0) {
+			return list;
+		}
+		int end = start + size;
+		List<String> list2 = new ArrayList<String>();
+		for (int i = start; i < end; i++) {
+			if (i >= list.size()) {
+				return list2;
+			}
+			list2.add(list.get(i));
+		}
+		return list2;
+	}
+	
+	/**
+	 * 字符串模糊匹配
+	 * <p>example:
+	 * <p> user* user-add   --  true 
+	 * <p> user* art-add    --  false  
+	 * @param patt 表达式 
+	 * @param str 待匹配的字符串 
+	 * @return 是否可以匹配 
+	 */
+	public static boolean vagueMatch(String patt, String str) {
+		// 如果表达式不带有*号，则只需简单equals即可 (速度提升200倍) 
+		if(patt.indexOf("*") == -1) {
+			return patt.equals(str);
+		}
+		return Pattern.matches(patt.replaceAll("\\*", ".*"), str);
+	}
+
+	/**
+	 * 将指定值转化为指定类型
+	 * @param <T> 泛型
+	 * @param obj 值
+	 * @param cs 类型
+	 * @return 转换后的值 
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> T getValueByType(Object obj, Class<T> cs) {
+		// 如果 obj 为 null 或者本来就是 cs 类型 
+		if(obj == null || obj.getClass().equals(cs)) {
+			return (T)obj;
+		}
+		// 开始转换
+		String obj2 = String.valueOf(obj);
+		Object obj3 = null;
+		if (cs.equals(String.class)) {
+			obj3 = obj2;
+		} else if (cs.equals(int.class) || cs.equals(Integer.class)) {
+			obj3 = Integer.valueOf(obj2);
+		} else if (cs.equals(long.class) || cs.equals(Long.class)) {
+			obj3 = Long.valueOf(obj2);
+		} else if (cs.equals(short.class) || cs.equals(Short.class)) {
+			obj3 = Short.valueOf(obj2);
+		} else if (cs.equals(byte.class) || cs.equals(Byte.class)) {
+			obj3 = Byte.valueOf(obj2);
+		} else if (cs.equals(float.class) || cs.equals(Float.class)) {
+			obj3 = Float.valueOf(obj2);
+		} else if (cs.equals(double.class) || cs.equals(Double.class)) {
+			obj3 = Double.valueOf(obj2);
+		} else if (cs.equals(boolean.class) || cs.equals(Boolean.class)) {
+			obj3 = Boolean.valueOf(obj2);
+		} else {
+			obj3 = (T)obj;
+		}
+		return (T)obj3;
+	}
+	
+	/**
+	 * 在url上拼接上kv参数并返回 
+	 * @param url url
+	 * @param parameStr 参数, 例如 id=1001
+	 * @return 拼接后的url字符串 
+	 */
+	public static String joinParam(String url, String parameStr) {
+		// 如果参数为空, 直接返回 
+		if(parameStr == null || parameStr.length() == 0) {
+			return url;
+		}
+		if(url == null) {
+			url = "";
+		}
+		int index = url.indexOf('?');
+		// ? 不存在
+		if(index == -1) {
+			return url + '?' + parameStr;
+		}
+		// ? 是最后一位
+		if(index == url.length() - 1) {
+			return url + parameStr;
+		}
+		// ? 是其中一位
+		if(index > -1 && index < url.length() - 1) {
+			String separatorChar = "&";
+			// 如果最后一位是 不是&, 且 parameStr 第一位不是 &, 就增送一个 &
+			if(url.lastIndexOf(separatorChar) != url.length() - 1 && parameStr.indexOf(separatorChar) != 0) {
+				return url + separatorChar + parameStr;
+			} else {
+				return url + parameStr;
+			}
+		}
+		// 正常情况下, 代码不可能执行到此 
+		return url;
+	}
+
+	/**
+	 * 在url上拼接上kv参数并返回 
+	 * @param url url
+	 * @param key 参数名称
+	 * @param value 参数值 
+	 * @return 拼接后的url字符串 
+	 */
+	public static String joinParam(String url, String key, Object value) {
+		// 如果参数为空, 直接返回 
+		if(isEmpty(url) || isEmpty(key) || isEmpty(String.valueOf(value))) {
+			return url;
+		}
+		return joinParam(url, key + "=" + value);
+	}
+	
+	/**
+	 * 将数组的所有元素使用逗号拼接在一起
+	 * @param arr 数组
+	 * @return 字符串，例: a,b,c
+	 */
+	public static String arrayJoin(String[] arr) {
+		if(arr == null) {
+			return "";
+		}
+		String str = "";
+		for (int i = 0; i < arr.length; i++) {
+			str += arr[i];
+			if(i != arr.length - 1) {
+				str += ",";
+			}
+		}
+		return str;
+	}
+	
+	/**
+	 * 验证URL的正则表达式 
+	 */
+	public static final String URL_REGEX = "(https?|ftp|file)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]"; 
+	
+	/**
+	 * 使用正则表达式判断一个字符串是否为URL
+	 * @param str 字符串 
+	 * @return 拼接后的url字符串 
+	 */
+	public static boolean isUrl(String str) {
+		if(str == null) {
+			return false;
+		}
+        return str.toLowerCase().matches(URL_REGEX);
+	}
+	
+	/**
+	 * URL编码 
+	 * @param url see note 
+	 * @return see note 
+	 */
+	public static String encodeUrl(String url) {
+		try {
+			return URLEncoder.encode(url, "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			throw new SaTokenException(e);
+		}
+	}
+
+	/**
+	 * URL解码 
+	 * @param url see note 
+	 * @return see note 
+	 */
+	public static String decoderUrl(String url) {
+		try {
+			return URLDecoder.decode(url, "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			throw new SaTokenException(e);
+		}
+	}
+	
+}

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

@@ -0,0 +1,102 @@
+package cn.dev33.satoken.util;
+
+import java.io.Serializable;
+
+
+/**
+ * 对Ajax请求返回Json格式数据的简易封装 
+ * @author kong
+ *
+ */
+public class SaResult implements Serializable{
+
+	private static final long serialVersionUID = 1L;	
+	
+	public static final int CODE_SUCCESS = 200;		
+	public static final int CODE_ERROR = 500;		
+
+	/**
+	 * 状态码
+	 */
+	public int code; 	
+	
+	/**
+	 * 描述信息 
+	 */
+	public String msg; 	
+	
+	/**
+	 * 携带对象
+	 */
+	public Object data; 
+
+	/**
+	 * 给code赋值，连缀风格
+	 */
+	public SaResult setCode(int code) {
+		this.code = code;
+		return this;
+	}
+
+	/**
+	 * 给msg赋值，连缀风格
+	 */
+	public SaResult setMsg(String msg) {
+		this.msg = msg;
+		return this;
+	}
+
+	/**
+	 * 给data赋值，连缀风格
+	 */
+	public SaResult setData(Object data) {
+		this.data = data;
+		return this;
+	}
+
+	// ============================  构建  ================================== 
+	
+	public SaResult(int code, String msg, Object data) {
+		this.code = code;
+		this.msg = msg;
+		this.data = data;
+	}
+	
+	// 构建成功
+	public static SaResult ok() {
+		return new SaResult(CODE_SUCCESS, "ok", null);
+	}
+	public static SaResult ok(String msg) {
+		return new SaResult(CODE_SUCCESS, msg, null);
+	}
+	public static SaResult data(Object data) {
+		return new SaResult(CODE_SUCCESS, "ok", data);
+	}
+	
+	// 构建失败
+	public static SaResult error() {
+		return new SaResult(CODE_ERROR, "error", null);
+	}
+	public static SaResult error(String msg) {
+		return new SaResult(CODE_ERROR, msg, null);
+	}
+
+	// 构建指定状态码 
+	public static SaResult get(int code, String msg, Object data) {
+		return new SaResult(code, msg, data);
+	}
+	
+	
+	/* (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		return "{"
+				+ "\"code\": " + this.code
+				+ ", \"msg\": \"" + this.msg + "\""
+				+ ", \"data\": \"" + this.data + "\""
+				+ "}";
+	}
+	
+}

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

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

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

@@ -1,132 +0,0 @@
-package cn.dev33.satoken.util;
-
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Date;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Random;
-
-/**
- * sa-token 内部代码工具类
- * 
- * @author kong
- *
- */
-public class SaTokenInsideUtil {
-
-	/**
-	 * 打印 sa-token 版本字符画
-	 */
-	public static void printSaToken() {
-		String str = "____ ____    ___ ____ _  _ ____ _  _ \r\n" + "[__  |__| __  |  |  | |_/  |___ |\\ | \r\n"
-				+ "___] |  |     |  |__| | \\_ |___ | \\| " 
-//				+ "sa-token：" 
-				+ "\r\n" + "DevDoc：" + SaTokenConsts.DEV_DOC_URL // + "\r\n";
-				+ " (" + SaTokenConsts.VERSION_NO + ")" 
-				+ "\r\n" + "GitHub：" + SaTokenConsts.GITHUB_URL // + "\r\n";
-				;
-		System.out.println(str);
-	}
-
-	/**
-	 * 生成指定长度的随机字符串
-	 * 
-	 * @param length 字符串的长度
-	 * @return 一个随机字符串
-	 */
-	public static String getRandomString(int length) {
-		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-		Random random = new Random();
-		StringBuffer sb = new StringBuffer();
-		for (int i = 0; i < length; i++) {
-			int number = random.nextInt(62);
-			sb.append(str.charAt(number));
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 指定字符串是否为null或者空字符串
-	 * @param str 指定字符串
-	 * @return 是否为null或者空字符串
-	 */
-	public static boolean isEmpty(String str) {
-		return str == null || "".equals(str);
-	}
-	
-	/**
-	 * 以当前时间戳和随机int数字拼接一个随机字符串
-	 * 
-	 * @return 随机字符串
-	 */
-	public static String getMarking28() {
-		return System.currentTimeMillis() + "" + new Random().nextInt(Integer.MAX_VALUE);
-	}
-
-	/**
-	 * 将日期格式化
-	 * @param date 日期
-	 * @return 格式化后的时间 
-	 */
-	public static String formatDate(Date date){
-		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
-	}
-	
-	/**
-	 * 从集合里查询数据
-	 * 
-	 * @param dataList 数据集合
-	 * @param prefix   前缀
-	 * @param keyword  关键字
-	 * @param start    起始位置 (-1代表查询所有)
-	 * @param size     获取条数
-	 * @return 符合条件的新数据集合
-	 */
-	public static List<String> searchList(Collection<String> dataList, String prefix, String keyword, int start,
-			int size) {
-		if (prefix == null) {
-			prefix = "";
-		}
-		if (keyword == null) {
-			keyword = "";
-		}
-		// 挑选出所有符合条件的
-		List<String> list = new ArrayList<String>();
-		Iterator<String> keys = dataList.iterator();
-		while (keys.hasNext()) {
-			String key = keys.next();
-			if (key.startsWith(prefix) && key.indexOf(keyword) > -1) {
-				list.add(key);
-			}
-		}
-		// 取指定段数据
-		return searchList(list, start, size);
-	}
-
-	/**
-	 * 从集合里查询数据
-	 * 
-	 * @param list  数据集合
-	 * @param start 起始位置 (-1代表查询所有)
-	 * @param size  获取条数
-	 * @return 符合条件的新数据集合
-	 */
-	public static List<String> searchList(List<String> list, int start, int size) {
-		// 取指定段数据
-		if (start < 0) {
-			return list;
-		}
-		int end = start + size;
-		List<String> list2 = new ArrayList<String>();
-		for (int i = start; i < end; i++) {
-			if (i >= list.size()) {
-				return list2;
-			}
-			list2.add(list.get(i));
-		}
-		return list2;
-	}
-
-}

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

@@ -1,50 +0,0 @@
-package com.pj.satoken;
-
-import org.springframework.context.annotation.Configuration;
-import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
-
-import cn.dev33.satoken.interceptor.SaAnnotationInterceptor;
-
-
-/**
- * [Sa-Token 权限认证] 配置类 
- * @author kong
- *
- */
-@Configuration
-public class SaTokenConfigure implements WebMvcConfigurer {
-
-	/**
-	 * 注册sa-token的拦截器，打开注解式鉴权功能 
-	 */
-	@Override
-	public void addInterceptors(InterceptorRegistry registry) {
-		// 注册注解拦截器 
-		registry.addInterceptor(new SaAnnotationInterceptor()).addPathPatterns("/**").excludePathPatterns("");
-	}
-	
-//	/**
-//     * 注册 [sa-token全局过滤器] 
-//     */
-//    @Bean
-//    public SaServletFilter getSaReactorFilter() {
-//        return new SaServletFilter()
-//        		// 指定 [拦截路由]
-//        		.addInclude("/**")
-//        		// 指定 [放行路由]
-//        		.addExclude("/favicon.ico")
-//        		// 指定[认证函数]: 每次请求执行 
-//        		.setAuth(r -> {
-//        			System.out.println("---------- sa全局认证");
-//                    SaRouterUtil.match("/test/test", () -> StpUtil.checkLogin());
-//        		})
-//        		// 指定[异常处理函数]：每次[认证函数]发生异常时执行此函数 
-//        		.setError(e -> {
-//        			System.out.println("---------- sa全局异常 ");
-//        			return AjaxJson.getError(e.getMessage());
-//        		})
-//        		;
-//    }
-    
-}

sa-token-demo/sa-token-demo-alone-redis/pom.xml

@@ -0,0 +1,71 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>cn.dev33</groupId>
+	<artifactId>sa-token-demo-alone-redis</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	
+	<!-- SpringBoot -->
+	<parent>
+		<groupId>org.springframework.boot</groupId>
+		<artifactId>spring-boot-starter-parent</artifactId>
+		<version>2.0.0.RELEASE</version>
+		<relativePath/>
+	</parent>
+	
+	<!-- 定义sa-token版本号 -->
+	<properties>
+		<sa-token-version>1.22.0</sa-token-version>
+	</properties>
+
+	<dependencies>
+
+		<!-- springboot依赖 -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-web</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-aop</artifactId>
+		</dependency>
+		
+		<!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
+		<dependency>
+            <groupId>cn.dev33</groupId>
+            <artifactId>sa-token-spring-boot-starter</artifactId>
+            <version>${sa-token-version}</version>
+        </dependency>
+        
+		<!-- sa-token整合redis (使用jackson序列化方式) -->
+		<dependency>
+            <groupId>cn.dev33</groupId>
+            <artifactId>sa-token-dao-redis-jackson</artifactId>
+            <version>${sa-token-version}</version>
+        </dependency>
+        
+		<!-- 提供redis连接池 -->
+		<dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
+        
+		<!-- Sa-Token插件：权限缓存与业务缓存分离 -->
+		<dependency>
+            <groupId>cn.dev33</groupId>
+            <artifactId>sa-token-alone-redis</artifactId>
+            <version>${sa-token-version}</version>
+        </dependency>
+        
+		<!-- @ConfigurationProperties -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-configuration-processor</artifactId>
+			<optional>true</optional>
+		</dependency>
+		
+	</dependencies>
+	
+	
+</project>

sa-token-demo/sa-token-demo-alone-redis/src/main/java/com/pj/SaTokenAloneRedisApplication.java

@@ -0,0 +1,21 @@
+package com.pj;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+import cn.dev33.satoken.SaManager;
+
+/**
+ * Sa-Token整合SpringBoot 示例 
+ * @author kong
+ *
+ */
+@SpringBootApplication
+public class SaTokenAloneRedisApplication {
+
+	public static void main(String[] args) throws ClassNotFoundException {
+		SpringApplication.run(SaTokenAloneRedisApplication.class, args);
+		System.out.println("\n启动成功：Sa-Token配置如下：" + SaManager.getConfig());
+	}
+	
+}

sa-token-demo/sa-token-demo-alone-redis/src/main/java/com/pj/test/AjaxJson.java

@@ -0,0 +1,162 @@
+package com.pj.test;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ * ajax请求返回Json格式数据的封装 
+ */
+public class AjaxJson implements Serializable{
+
+	private static final long serialVersionUID = 1L;	// 序列化版本号
+	
+	public static final int CODE_SUCCESS = 200;			// 成功状态码
+	public static final int CODE_ERROR = 500;			// 错误状态码
+	public static final int CODE_WARNING = 501;			// 警告状态码
+	public static final int CODE_NOT_JUR = 403;			// 无权限状态码
+	public static final int CODE_NOT_LOGIN = 401;		// 未登录状态码
+	public static final int CODE_INVALID_REQUEST = 400;	// 无效请求状态码
+
+	public int code; 	// 状态码
+	public String msg; 	// 描述信息 
+	public Object data; // 携带对象
+	public Long dataCount;	// 数据总数，用于分页 
+	
+	/**
+	 * 返回code  
+	 * @return
+	 */
+	public int getCode() {
+		return this.code;
+	}
+
+	/**
+	 * 给msg赋值，连缀风格
+	 */
+	public AjaxJson setMsg(String msg) {
+		this.msg = msg;
+		return this;
+	}
+	public String getMsg() {
+		return this.msg;
+	}
+
+	/**
+	 * 给data赋值，连缀风格
+	 */
+	public AjaxJson setData(Object data) {
+		this.data = data;
+		return this;
+	}
+
+	/**
+	 * 将data还原为指定类型并返回
+	 */
+	@SuppressWarnings("unchecked")
+	public <T> T getData(Class<T> cs) {
+		return (T) data;
+	}
+	
+	// ============================  构建  ================================== 
+	
+	public AjaxJson(int code, String msg, Object data, Long dataCount) {
+		this.code = code;
+		this.msg = msg;
+		this.data = data;
+		this.dataCount = dataCount;
+	}
+	
+	// 返回成功
+	public static AjaxJson getSuccess() {
+		return new AjaxJson(CODE_SUCCESS, "ok", null, null);
+	}
+	public static AjaxJson getSuccess(String msg) {
+		return new AjaxJson(CODE_SUCCESS, msg, null, null);
+	}
+	public static AjaxJson getSuccess(String msg, Object data) {
+		return new AjaxJson(CODE_SUCCESS, msg, data, null);
+	}
+	public static AjaxJson getSuccessData(Object data) {
+		return new AjaxJson(CODE_SUCCESS, "ok", data, null);
+	}
+	public static AjaxJson getSuccessArray(Object... data) {
+		return new AjaxJson(CODE_SUCCESS, "ok", data, null);
+	}
+	
+	// 返回失败
+	public static AjaxJson getError() {
+		return new AjaxJson(CODE_ERROR, "error", null, null);
+	}
+	public static AjaxJson getError(String msg) {
+		return new AjaxJson(CODE_ERROR, msg, null, null);
+	}
+	
+	// 返回警告 
+	public static AjaxJson getWarning() {
+		return new AjaxJson(CODE_ERROR, "warning", null, null);
+	}
+	public static AjaxJson getWarning(String msg) {
+		return new AjaxJson(CODE_WARNING, msg, null, null);
+	}
+	
+	// 返回未登录
+	public static AjaxJson getNotLogin() {
+		return new AjaxJson(CODE_NOT_LOGIN, "未登录，请登录后再次访问", null, null);
+	}
+	
+	// 返回没有权限的 
+	public static AjaxJson getNotJur(String msg) {
+		return new AjaxJson(CODE_NOT_JUR, msg, null, null);
+	}
+	
+	// 返回一个自定义状态码的
+	public static AjaxJson get(int code, String msg){
+		return new AjaxJson(code, msg, null, null);
+	}
+	
+	// 返回分页和数据的
+	public static AjaxJson getPageData(Long dataCount, Object data){
+		return new AjaxJson(CODE_SUCCESS, "ok", data, dataCount);
+	}
+	
+	// 返回，根据受影响行数的(大于0=ok，小于0=error)
+	public static AjaxJson getByLine(int line){
+		if(line > 0){
+			return getSuccess("ok", line);
+		}
+		return getError("error").setData(line); 
+	}
+
+	// 返回，根据布尔值来确定最终结果的  (true=ok，false=error)
+	public static AjaxJson getByBoolean(boolean b){
+		return b ? getSuccess("ok") : getError("error"); 
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
+	@SuppressWarnings("rawtypes")
+	@Override
+	public String toString() {
+		String data_string = null;
+		if(data == null){
+			
+		} else if(data instanceof List){
+			data_string = "List(length=" + ((List)data).size() + ")";
+		} else {
+			data_string = data.toString();
+		}
+		return "{"
+				+ "\"code\": " + this.getCode()
+				+ ", \"msg\": \"" + this.getMsg() + "\""
+				+ ", \"data\": " + data_string
+				+ ", \"dataCount\": " + dataCount
+				+ "}";
+	}
+	
+	
+	
+	
+	
+}

sa-token-demo/sa-token-demo-alone-redis/src/main/java/com/pj/test/TestController.java

@@ -0,0 +1,39 @@
+package com.pj.test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import cn.dev33.satoken.stp.StpUtil;
+
+/**
+ * 测试专用Controller 
+ * @author kong
+ *
+ */
+@RestController
+@RequestMapping("/test/")
+public class TestController {
+
+	@Autowired
+	StringRedisTemplate stringRedisTemplate;
+	
+	// 测试Sa-Token缓存， 浏览器访问： http://localhost:8081/test/login
+	@RequestMapping("login")
+	public AjaxJson login(@RequestParam(defaultValue="10001") String id) {
+		System.out.println("--------------- 测试Sa-Token缓存");
+		StpUtil.login(id);	
+		return AjaxJson.getSuccess();
+	}
+	
+	// 测试业务缓存   浏览器访问： http://localhost:8081/test/test
+	@RequestMapping("test")
+	public AjaxJson test() {
+		System.out.println("--------------- 测试业务缓存");
+		stringRedisTemplate.opsForValue().set("hello", "Hello World");
+		return AjaxJson.getSuccess();
+	}
+	
+}

sa-token-demo/sa-token-demo-alone-redis/src/main/resources/application.yml

@@ -0,0 +1,63 @@
+# 端口
+server:
+    port: 8081
+
+# Sa-Token配置
+sa-token: 
+    # Token名称 (同时也是cookie名称)
+    token-name: satoken
+    # Token有效期，单位s 默认30天, -1代表永不过期 
+    timeout: 2592000
+    # Token风格
+    token-style: uuid
+    # 配置Sa-Token单独使用的Redis连接 
+    alone-redis: 
+        # Redis数据库索引（默认为0）
+        database: 2
+        # Redis服务器地址
+        host: 127.0.0.1
+        # Redis服务器连接端口
+        port: 6379
+        # Redis服务器连接密码（默认为空）
+        password: 
+        # 连接超时时间（毫秒）
+        timeout: 10ms
+        lettuce: 
+            pool:
+                # 连接池最大连接数
+                max-active: 200
+                # 连接池最大阻塞等待时间（使用负值表示没有限制）
+                max-wait: -1ms
+                # 连接池中的最大空闲连接
+                max-idle: 10
+                # 连接池中的最小空闲连接
+                min-idle: 0
+        
+spring: 
+    # 配置业务使用的Redis连接 
+    redis: 
+        # Redis数据库索引（默认为0）
+        database: 0
+        # Redis服务器地址
+        host: 127.0.0.1
+        # Redis服务器连接端口
+        port: 6379
+        # Redis服务器连接密码（默认为空）
+        password: 
+        # 连接超时时间（毫秒）
+        timeout: 10ms
+        lettuce: 
+            pool:
+                # 连接池最大连接数
+                max-active: 200
+                # 连接池最大阻塞等待时间（使用负值表示没有限制）
+                max-wait: -1ms
+                # 连接池中的最大空闲连接
+                max-idle: 10
+                # 连接池中的最小空闲连接
+                min-idle: 0
+        
+        
+        
+        
+        

sa-token-demo/sa-token-demo-jwt/pom.xml

@@ -16,7 +16,7 @@
 	
 	<!-- 定义sa-token版本号 -->
 	<properties>
-		<sa-token-version>1.17.0</sa-token-version>
+		<sa-token-version>1.22.0</sa-token-version>
 	</properties>
 
 	<dependencies>
@@ -79,8 +79,13 @@
 			<optional>true</optional>
 		</dependency>
 		
+		<dependency>
+			<groupId>javax.xml.bind</groupId>
+			<artifactId>jaxb-api</artifactId>
+			<!-- <version>2.3.1</version> -->
+		</dependency>
 
 	</dependencies>
 	
 	
-</project>
+</project>

sa-token-demo/sa-token-demo-jwt/src/main/java/com/pj/SaTokenJwtDemoApplication.java

@@ -3,14 +3,14 @@ package com.pj;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
 
 @SpringBootApplication
 public class SaTokenJwtDemoApplication {
 	
 	public static void main(String[] args) {
 		SpringApplication.run(SaTokenJwtDemoApplication.class, args); 
-		System.out.println("\n启动成功：sa-token配置如下：" + SaTokenManager.getConfig());
+		System.out.println("\n启动成功：sa-token配置如下：" + SaManager.getConfig());
 	}
 	
 }

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

@@ -4,7 +4,7 @@ import java.util.Date;
 
 import org.springframework.stereotype.Component;
 
-import cn.dev33.satoken.SaTokenManager;
+import cn.dev33.satoken.SaManager;
 import cn.dev33.satoken.config.SaTokenConfig;
 import cn.dev33.satoken.context.model.SaStorage;
 import cn.dev33.satoken.dao.SaTokenDao;
@@ -90,10 +90,10 @@ public class SaTokenJwtUtil {
         	}
         	return String.valueOf(loginId);
         } catch (ExpiredJwtException e) {
-//        	throw NotLoginException.newInstance(StpUtil.stpLogic.loginKey, NotLoginException.TOKEN_TIMEOUT);
+//        	throw NotLoginException.newInstance(StpUtil.TYPE, NotLoginException.TOKEN_TIMEOUT);
         	return NotLoginException.TOKEN_TIMEOUT;
 		} catch (MalformedJwtException e) {
-        	throw NotLoginException.newInstance(StpUtil.stpLogic.loginKey, NotLoginException.INVALID_TOKEN);
+        	throw NotLoginException.newInstance(StpUtil.stpLogic.loginType, NotLoginException.INVALID_TOKEN);
 		} catch (Exception e) {
         	throw new SaTokenException(e);
         }
@@ -122,15 +122,15 @@ public class SaTokenJwtUtil {
     		
     		// 重写 (在当前会话上登录id )
     		@Override
-    		public void setLoginId(Object loginId, SaLoginModel loginModel) {
+    		public void login(Object loginId, SaLoginModel loginModel) {
     			// ------ 1、获取相应对象  
-    			SaStorage storage = SaTokenManager.getSaTokenContext().getStorage();
+    			SaStorage storage = SaManager.getSaTokenContext().getStorage();
     			SaTokenConfig config = getConfig();
     			// ------ 2、生成一个token 
     			String tokenValue = createTokenValue(loginId);
     			storage.set(splicingKeyJustCreatedSave(), tokenValue);	// 将token保存到本次request里  
     			if(config.getIsReadCookie() == true){	// cookie注入 
-    				SaTokenManager.getSaTokenContext().getResponse().addCookie(getTokenName(), tokenValue, "/", config.getCookieDomain(), (int)config.getTimeout());		
+    				SaManager.getSaTokenContext().getResponse().addCookie(getTokenName(), tokenValue, "/", config.getCookieDomain(), (int)config.getTimeout());		
     			}
     		}
     		
@@ -154,7 +154,7 @@ public class SaTokenJwtUtil {
     	 		}
     	 		// 如果打开了cookie模式，把cookie清除掉 
     	 		if(getConfig().getIsReadCookie() == true){
-    				SaTokenManager.getSaTokenContext().getResponse().deleteCookie(getTokenName()); 	
+    				SaManager.getSaTokenContext().getResponse().deleteCookie(getTokenName()); 	
     			}
     		}
     		
@@ -203,7 +203,7 @@ public class SaTokenJwtUtil {
     			info.tokenValue = getTokenValue();
     			info.isLogin = isLogin();
     			info.loginId = getLoginIdDefaultNull();
-    			info.loginKey = getLoginKey();
+    			info.loginType = getLoginType();
     			info.tokenTimeout = getTokenTimeout();
 //    			info.sessionTimeout = getSessionTimeout();
 //    			info.tokenSessionTimeout = getTokenSessionTimeout();

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

@@ -32,7 +32,7 @@ public class TestJwtController {
 		System.out.println("当前是否登录：" + StpUtil.isLogin());
 		System.out.println("当前登录账号：" + StpUtil.getLoginIdDefaultNull());
 		
-		StpUtil.setLoginId(id);			// 在当前会话登录此账号 	
+		StpUtil.login(id);			// 在当前会话登录此账号 	
 		System.out.println("登录成功");
 		System.out.println("当前是否登录：" + StpUtil.isLogin());
 		System.out.println("当前登录账号：" + StpUtil.getLoginId());
@@ -60,9 +60,9 @@ public class TestJwtController {
 		System.out.println("当前是否登录：" + StpUtil.isLogin());
 		System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
 		System.out.println("当前登录账号session的id" + StpUtil.getSession().getId());
-		System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
-		StpUtil.getSession().setAttribute("name", new Date());	// 写入一个值 
-		System.out.println("测试取值name：" + StpUtil.getSession().getAttribute("name"));
+		System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
+		StpUtil.getSession().set("name", new Date());	// 写入一个值 
+		System.out.println("测试取值name：" + StpUtil.getSession().get("name"));
 		System.out.println( new ObjectMapper().writeValueAsString(StpUtil.getSession()));
 		return AjaxJson.getSuccess();
 	}
@@ -71,8 +71,10 @@ public class TestJwtController {
 	// 测试   浏览器访问： http://localhost:8081/test/test
 	@RequestMapping("test")
 	public AjaxJson test() {
-		StpUtil.getTokenSession().logout();
-		StpUtil.logoutByLoginId(10001);
+		System.out.println();
+		System.out.println("--------------进入请求--------------");
+		StpUtil.login(10001);	
+		System.out.println(StpUtil.getTokenInfo().getTokenValue());
 		return AjaxJson.getSuccess();
 	}
 

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

@@ -2,25 +2,21 @@
 server:
     port: 8081
 
+# sa-token配置
+sa-token: 
+    # token名称 (同时也是cookie名称)
+    token-name: satoken
+    # token有效期，单位s 默认30天, -1代表永不过期 
+    timeout: 2592000
+    # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
+    activity-timeout: -1
+    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
+    is-concurrent: true
+    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) 
+    is-share: true
+    # token风格
+    token-style: uuid
 spring: 
-    # sa-token配置
-    sa-token: 
-        # token名称 (同时也是cookie名称)
-        token-name: satoken
-        # token有效期，单位s 默认30天, -1代表永不过期 
-        timeout: 2592000
-        # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
-        activity-timeout: -1
-        # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
-        allow-concurrent-login: true
-        # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) 
-        is-share: true
-        # token风格
-        token-style: uuid
-        # 是否输出操作日志 
-        is-log: false
-        
-        
     # redis配置 
     redis:
         # Redis数据库索引（默认为0）

sa-token-demo/sa-token-demo-oauth2-client/pom.xml

@@ -17,7 +17,7 @@
 		<java.version>1.8</java.version>
 		<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
 		<!-- 定义sa-token版本号 -->
-		<sa-token-version>1.15.0.RELEASE</sa-token-version>
+		<sa-token-version>1.22.0</sa-token-version>
 	</properties>
 	
 	<dependencies>

sa-token-demo/sa-token-demo-oauth2-client/src/main/java/com/pj/controller/ClientAccController.java

@@ -58,7 +58,7 @@ public class ClientAccController {
 		long userId = getUserIdByOpenid(openid);
 		
 		// 登录并返回账号信息 
-		StpUtil.setLoginId(userId);
+		StpUtil.login(userId);
 		return AjaxJson.getSuccessData(userId).set("openid", openid);
 	}
 	

sa-token-demo/sa-token-demo-oauth2-client/src/main/resources/application.yml

@@ -1,14 +1,13 @@
 server:
     port: 8002
 
+# sa-token配置
+sa-token: 
+    # token名称 (同时也是cookie名称)
+    token-name: satoken-client
+
 spring: 
     # 静态文件路径映射 
     resources: 
         static-locations: classpath:/META-INF/resources/,classpath:/resources/, classpath:/static/, classpath:/public/
         # static-locations: file:E:\work\project-yun\sa-token\sa-token-demo-oauth2\sa-token-demo-oauth2-client\src\main\resources\static\
-
-    # sa-token配置
-    sa-token: 
-        # token名称 (同时也是cookie名称)
-        token-name: satoken-client
-        

sa-token-demo/sa-token-demo-oauth2-server/pom.xml

@@ -17,7 +17,7 @@
 		<java.version>1.8</java.version>
 		<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
 		<!-- 定义sa-token版本号 -->
-		<sa-token-version>1.15.0.RELEASE</sa-token-version>
+		<sa-token-version>1.22.0</sa-token-version>
 	</properties>
 	
 	<dependencies>
@@ -39,7 +39,7 @@
 		<dependency>
             <groupId>cn.dev33</groupId>
             <artifactId>sa-token-oauth2</artifactId>
-            <version>1.15.0-alpha</version>
+            <version>${sa-token-version}</version>
         </dependency>
 
 		<!-- sa-token整合redis (使用jackson序列化方式) -->

sa-token-demo/sa-token-demo-oauth2-server/src/main/java/com/pj/controller/ServerAccController.java

@@ -19,7 +19,7 @@ public class ServerAccController {
 	public AjaxJson test(String username, String password) {
 		System.out.println("------------------ 成功进入请求 ------------------");
 		if("test".equals(username) && "test".equals(password)) {
-			StpUtil.setLoginId(10001);
+			StpUtil.login(10001);
 			return AjaxJson.getSuccess();
 		}
 		return AjaxJson.getError();

sa-token-demo/sa-token-demo-oauth2-server/src/main/java/com/pj/oauth2/SaOAuth2SpringAutowired.java

@@ -7,7 +7,8 @@ import org.springframework.stereotype.Component;
 
 import cn.dev33.satoken.oauth2.SaOAuth2Manager;
 import cn.dev33.satoken.oauth2.config.SaOAuth2Config;
-import cn.dev33.satoken.oauth2.logic.SaOAuth2Interface;
+import cn.dev33.satoken.oauth2.logic.SaOAuth2Template;
+import cn.dev33.satoken.oauth2.logic.SaOAuth2Util;
 
 /**
  * 利用Spring完成自动装配
@@ -24,7 +25,7 @@ public class SaOAuth2SpringAutowired {
 	 * @return 配置对象
 	 */
 	@Bean
-	@ConfigurationProperties(prefix = "spring.sa-token.oauth2")
+	@ConfigurationProperties(prefix = "sa-token.oauth2")
 	public SaOAuth2Config getSaOAuth2Config() {
 		return new SaOAuth2Config();
 	}
@@ -45,8 +46,8 @@ public class SaOAuth2SpringAutowired {
 	 * @param saOAuth2Interface OAuth2接口Bean 
 	 */
 	@Autowired(required = false)
-	public void setSaOAuth2Interface(SaOAuth2Interface saOAuth2Interface) {
-		SaOAuth2Manager.setInterface(saOAuth2Interface);
+	public void setSaOAuth2Interface(SaOAuth2Template saOAuth2Interface) {
+		SaOAuth2Util.saOAuth2Template = saOAuth2Interface;
 	}
 	
 

sa-token-demo/sa-token-demo-oauth2-server/src/main/java/com/pj/oauth2/SaOAuth2TemplateImpl.java

@@ -5,14 +5,14 @@ import java.util.List;
 
 import org.springframework.stereotype.Component;
 
-import cn.dev33.satoken.oauth2.logic.SaOAuth2Interface;
+import cn.dev33.satoken.oauth2.logic.SaOAuth2Template;
 
 /**
  * 使用oauth2.0 所必须的一些自定义实现 
  * @author kong
  */
 @Component
-public class SaOAuth2InterfaceImpl implements SaOAuth2Interface {
+public class SaOAuth2TemplateImpl extends SaOAuth2Template {
 	
 
 	/*

sa-token-demo/sa-token-demo-oauth2-server/src/main/resources/application.yml

@@ -1,18 +1,17 @@
 server: 
     port: 8001
 
+# sa-token配置
+sa-token: 
+    # token名称 (同时也是cookie名称)
+    token-name: satoken-server
+    
 spring: 
     # 静态文件路径映射 
     resources: 
         static-locations: classpath:/META-INF/resources/,classpath:/resources/, classpath:/static/, classpath:/public/
         # static-locations: file:E:\work\project-yun\sa-token\sa-token-demo-oauth2\sa-token-demo-oauth2-server\src\main\resources\static\
 
-    # sa-token配置
-    sa-token: 
-        # token名称 (同时也是cookie名称)
-        token-name: satoken-server
-        
-        
     # redis配置 
     redis:
         # Redis数据库索引（默认为0）