Sa-token 之 SaManager

已于 2022-03-03 18:19:13 修改
阅读量2.1k 收藏 8
点赞数
分类专栏： 技术 文章标签： java spring
于 2022-03-01 14:21:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KsamaLi/article/details/123199667
版权

SaManager 负责 Sa-token 所有全局组件管理，其中包含如下：
1、负责全局配置的组件 SaTokenConfig；

2、负责持久化处理的组件 SaTokenDao；

3、负责权限认证的组件 StpInterface；

4、负责框架行为的组件 SaTokenAction；

5、负责上下文处理器的组件 SaTokenContext 与 SaTokenSecondContext；

6、负责认证活动监听的组件 SaTokenListener；

7、负责临时令牌验证的组件 SaTempInterface；

8、负责认证处理逻辑的组件 StpLogic；

接下来分别对以上8个组件逐个介绍。

目录

一、SaTokenConfig 全局配置

二、SaTokenDao 持久化处理

三、StpInterface 权限认证

四、SaTokenAction 框架行为

五、SaTokenContext与SaTokenSecondContext 上下文处理器

六、SaTokenListener 认证活动监听

七、SaTempInterface 临时令牌验证

八、StpLogic 认证处理逻辑

（一）Token 相关

（二）登录相关

（三）Session 相关

 1、Token-Session

2、User-Session

（四）Key 相关

一、SaTokenConfig 全局配置

通过源码注释说明可以大致了解各项配置的含义（以下仅对关键配置重点说明）

public class SaTokenConfig implements Serializable {

	private static final long serialVersionUID = -6541180061782004705L;

	/** token名称 (同时也是cookie名称) */
	private String tokenName = "satoken";

	/** token的长久有效期(单位:秒) 默认30天, -1代表永久 */
	private long timeout = 60 * 60 * 24 * 30;

	/**
	 * token临时有效期 [指定时间内无操作就视为token过期] (单位: 秒), 默认-1 代表不限制
	 * (例如可以设置为1800代表30分钟内无操作就过期)
	 */
	private long activityTimeout = -1;

	/** 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) */
	private Boolean isConcurrent = true;

	/** 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) */
	private Boolean isShare = true;

	/** 是否尝试从请求体里读取token */
	private Boolean isReadBody = true;

	/** 是否尝试从header里读取token */
	private Boolean isReadHead = true;

	/** 是否尝试从cookie里读取token */
	private Boolean isReadCookie = true;

	/** token风格(默认可取值：uuid、simple-uuid、random-32、random-64、random-128、tik) */
	private String tokenStyle = "uuid";

	/** 默认dao层实现类中，每次清理过期数据间隔的时间 (单位: 秒) ，默认值30秒，设置为-1代表不启动定时清理 */
	private int dataRefreshPeriod = 30;

	/** 获取[token专属session]时是否必须登录 (如果配置为true，会在每次获取[token-session]时校验是否登录) */
	private Boolean tokenSessionCheckLogin = true;

	/** 是否打开自动续签 (如果此值为true, 框架会在每次直接或间接调用getLoginId()时进行一次过期检查与续签操作)  */
	private Boolean autoRenew = true;

	/** token前缀, 格式样例(satoken: Bearer xxxx-xxxx-xxxx-xxxx) */
	private String tokenPrefix;

	/** 是否在初始化配置时打印版本字符画 */
	private Boolean isPrint = true;

	/** 是否打印操作日志 */
	private Boolean isLog = false;

	/**
	 * jwt秘钥 (只有集成 jwt 模块时此参数才会生效)   
	 */
	private String jwtSecretKey;
	
	/**
	 * Id-Token的有效期 (单位: 秒)
	 */
	private long idTokenTimeout = 60 * 60 * 24;

	/**
	 * Http Basic 认证的账号和密码 
	 */
	private String basic = "";

	/** 配置当前项目的网络访问地址 */
	private String currDomain;

	/** 是否校验Id-Token（部分rpc插件有效） */
	private Boolean checkIdToken = false;

	/**
	 * Cookie配置对象 
	 */
	public SaCookieConfig cookie = new SaCookieConfig();
	
	/**
	 * SSO单点登录配置对象 
	 */
	public SaSsoConfig sso = new SaSsoConfig();
}
SaTokenConfig全局配置
配置项默认值说明配置方式
tokenNamesatoken

token键的前缀，

例如：Session、Id-Token、Sso-Ticket等的键值

sa-token.token-name
tokenPrefix

token值的前缀，

默认无前缀，

例如：

设置为 Bearer，那么生成的token值为：satoken: Bearer xxxx-xxxx-xxxx-xxxx

sa-token.token-prefix
timeout60*60*24*30

token的长久有效期限（单位秒），

默认30天，

-1代表不限制

sa-token.timeout
activityTimeout-1

token的临时有效期限（单位秒），

指定时间内无操作的过期时间，

默认 -1，代表不限制

sa-token.activity-timeout
idTokenTimeout60*60*24

Id-Token的有效期（单位秒），

可用于微服务之间调用鉴权，

默认 1天

sa-token.id-token-timeout
autoRenewtrue

是否开启自动续签，

默认开启

sa-token.auto-renew
basic""

Http Basic 认证的默认账号和密码

格式为 user:password

可搭配使用 @SaCheckBasic 注解实现自定义认证配置

sa-token.basic
currDomain

配置当前项目的网络访问地址，

影响采用SaToken默认提供的SaSsoHandle中客户端访问服务端获取授权以及校验Ticket，

默认从客户端请求中获取，当服务端与客户端访问地址不一致时，可通过配置服务端地址的方式进行覆盖。

sa-token.curr-domain
cookieSaCookieConfig配置sa-token.cookie.
ssoSaSsoConfig配置sa-token.sso.
public class SaCookieConfig {
	
    /**
     * 域（写入Cookie时显式指定的作用域, 常用于单点登录二级域名共享Cookie的场景）
     */
    private String domain; 

    /**
     * 路径 
     */
    private String path;

    /**
     * 是否只在 https 协议下有效 
     */
    private Boolean secure = false; 
    
    /**
     * 是否禁止 js 操作 Cookie 
     */
    private Boolean httpOnly = false; 
    
    /**
     * 第三方限制级别（Strict=完全禁止，Lax=部分允许，None=不限制）
     */
	private String sameSite;
}
SaCookieConfig全局配置
配置项默认值说明配置方式
domain

写入Cookie时显式指定作用域

1、不可指定顶级域名，

2、指定顶级+二级域名，二级子域名都可获取Cookie

3、指定二级子域名，仅指定域名可获取Cookie

sa-token.cookie.domain
path

写入Cookie时显示指定路径

非指定path的请求不会携带Cookie

sa-token.cookie.path
securefalse

是否只在 https 协议下有效

默认不限制

sa-token.cookie.secure
httpOnlyfalse是否禁止 javascript 操作 Cookiesa-token.cookie.http-only
sameSite

第三方限制级别：

Strict=完全禁止，只允许同站（顶级+二级域名相同）请求携Cookie；

Lax=部分允许；

None=不限制，必须配置 secure 为true；

sa-token.cookie.same-site
public class SaSsoConfig implements Serializable {

	private static final long serialVersionUID = -6541180061782004705L;

	
	// ----------------- Server端相关配置 
	
	/**
	 * Ticket有效期 (单位: 秒) 
	 */
	public long ticketTimeout = 60 * 5;
	
	/**
	 * 所有允许的授权回调地址，多个用逗号隔开 (不在此列表中的URL将禁止下放ticket) 
	 */
	public String allowUrl = "*";

	/**
	 * 是否打开单点注销功能 
	 */
	public Boolean isSlo = true; 
	
	/**
	 * 是否打开模式三（此值为 true 时将使用 http 请求：校验ticket值、单点注销、获取userinfo） 
	 */
	public Boolean isHttp = false; 

	/**
	 * 接口调用秘钥 (用于SSO模式三单点注销的接口通信身份校验) 
	 */
	public String secretkey;

	
	// ----------------- Client端相关配置 

	/**
	 * 配置 Server 端单点登录授权地址 
	 */
	public String authUrl;

	/**
	 * 是否打开单点注销功能 
	 */
	// public Boolean isSlo = true;  // 同上 

	/**
	 * 是否打开模式三（此值为 true 时将使用 http 请求：校验ticket值、单点注销、获取userinfo） 
	 */
	// public Boolean isHttp = false;  // 同上 

	/**
	 * 接口调用秘钥 (用于SSO模式三单点注销的接口通信身份校验) 
	 */
	// public String secretkey;  // 同上 

	/**
	 * 配置 Server 端的 ticket 校验地址 
	 */
	public String checkTicketUrl;

	/**
	 * 配置 Server 端查询 userinfo 地址 
	 */
	public String userinfoUrl;
	
	/**
	 * 配置 Server 端单点注销地址 
	 */
	public String sloUrl;

	/**
	 * 配置当前 Client 端的单点注销回调URL （为空时自动获取） 
	 */
	public String ssoLogoutCall;
}
SaSsoConfig全局配置
配置项默认值说明配置方式
isSlotrue

是否开启单点注销功能

特别提示：客户端需要开启模式三（isHttp=true）

1、客户端在进行 ticket 校验请求时，将向服务端注册注销回调地址

2、服务端将在账号注销过程多播调用注销用户Session中所有已注册的客户端注销回调地址

sa-token.sso.is-slo
isHttpfalse

是否开启模式三（基于http请求校验ticket）

sa-token.sso.is-http
secretkey

接口调用密钥（用于SSO模式三单点注销的接口通信身份校验，服务端与客户端配置密钥需保持一致，否则校验失败）

sa-token.sso.secretkey
httpOnlyfalse是否禁止 javascript 操作 Cookiesa-token.cookie.http-only
sameSite

第三方限制级别：

Strict=完全禁止，只允许同站（顶级+二级域名相同）请求携Cookie；

Lax=部分允许；

None=不限制，必须配置 secure 为true；

sa-token.cookie.same-site

二、SaTokenDao 持久化处理

与Spring Security 认证授权框架类似，Sa-Token的对用户登录、授权后的状态是通过在服务端进行保留实现，SaTokenDao就是为其持久化处理这一关键要素进行了通用封装。整体上包含：字符串的读写、对象的读写、Session读写，项目框架（以及插件）中提供了三种实现：

1、SaTokenDaoDefaultImpl 默认实现

2、SaTokenDaoRedis Redis存储+JDK默认序列化方式实现

3、SaTokenDaoRedisJackson Redis存储+jackson序列化方式实现

重点关注 SaTokenDaoRedisJackson 实现中的 init() 方式，基于RedisConnnetionFactory初始化处理过程：

1、指定序列化方式：

（1）键：StringRedisSerializer

（2）值：GenericJackson2JsonRedisSerializer

2、增强值序列化方法

（1）通过反射获取Mapper对象

（2）时间类型序列化与反序列化模版配置

3、构建Redis操作对象

（1）String类型操作对象 StringRedisTemplate

（2）Object类型操作对象 RedisTemplate<String, Object>

4、初始化SaTokenDao相关组件

public interface SaTokenDao {

	/** 常量，表示一个key永不过期 (在一个key被标注为永远不过期时返回此值) */ 
	public static final long NEVER_EXPIRE = -1;
	
	/** 常量，表示系统中不存在这个缓存 (在对不存在的key获取剩余存活时间时返回此值) */ 
	public static final long NOT_VALUE_EXPIRE = -2;

	
	// --------------------- 字符串读写 ---------------------
	
	/**
	 * 获取Value，如无返空 
	 * @param key 键名称 
	 * @return value
	 */
	public String get(String key);

	/**
	 * 写入Value，并设定存活时间 (单位: 秒)
	 * @param key 键名称 
	 * @param value 值 
	 * @param timeout 过期时间(值大于0时限时存储，值=-1时永久存储，值=0或小于-2时不存储)
	 */
	public void set(String key, String value, long timeout);

	/**
	 * 更新Value (过期时间不变) 
	 * @param key 键名称 
	 * @param value 值 
	 */
	public void update(String key, String value);

	/**
	 * 删除Value 
	 * @param key 键名称 
	 */
	public void delete(String key);
	
	/**
	 * 获取Value的剩余存活时间 (单位: 秒) 
	 * @param key 指定key 
	 * @return 这个key的剩余存活时间 
	 */
	public long getTimeout(String key);
	
	/**
	 * 修改Value的剩余存活时间 (单位: 秒) 
	 * @param key 指定key
	 * @param timeout 过期时间 
	 */
	public void updateTimeout(String key, long timeout);

	
	// --------------------- 对象读写 ---------------------

	/**
	 * 获取Object，如无返空 
	 * @param key 键名称 
	 * @return object
	 */
	public Object getObject(String key);

	/**
	 * 写入Object，并设定存活时间 (单位: 秒)
	 * @param key 键名称 
	 * @param object 值 
	 * @param timeout 存活时间 (值大于0时限时存储，值=-1时永久存储，值=0或小于-2时不存储)
	 */
	public void setObject(String key, Object object, long timeout);

	/**
	 * 更新Object (过期时间不变) 
	 * @param key 键名称 
	 * @param object 值 
	 */
	public void updateObject(String key, Object object);

	/**
	 * 删除Object 
	 * @param key 键名称 
	 */
	public void deleteObject(String key);
	
	/**
	 * 获取Object的剩余存活时间 (单位: 秒)
	 * @param key 指定key 
	 * @return 这个key的剩余存活时间 
	 */
	public long getObjectTimeout(String key);
	
	/**
	 * 修改Object的剩余存活时间 (单位: 秒)
	 * @param key 指定key
	 * @param timeout 过期时间 
	 */
	public void updateObjectTimeout(String key, long timeout);

	
	// --------------------- Session读写 ---------------------

	/**
	 * 获取Session，如无返空 
	 * @param sessionId sessionId
	 * @return SaSession
	 */
	public default SaSession getSession(String sessionId) {
		return (SaSession)getObject(sessionId);
	}

	/**
	 * 写入Session，并设定存活时间 (单位: 秒) 
	 * @param session 要保存的Session对象
	 * @param timeout 过期时间 (单位: 秒)
	 */
	public default void setSession(SaSession session, long timeout) {
		setObject(session.getId(), session, timeout);
	}

	/**
	 * 更新Session
	 * @param session 要更新的session对象
	 */
	public default void updateSession(SaSession session) {
		updateObject(session.getId(), session);
	}
	
	/**
	 * 删除Session
	 * @param sessionId sessionId
	 */
	public default void deleteSession(String sessionId) {
		deleteObject(sessionId);
	}

	/**
	 * 获取Session剩余存活时间 (单位: 秒) 
	 * @param sessionId 指定Session 
	 * @return 这个Session的剩余存活时间 
	 */
	public default long getSessionTimeout(String sessionId) {
		return getObjectTimeout(sessionId);
	}
	
	/**
	 * 修改Session剩余存活时间 (单位: 秒) 
	 * @param sessionId 指定Session 
	 * @param timeout 过期时间 
	 */
	public default void updateSessionTimeout(String sessionId, long timeout) {
		updateObjectTimeout(sessionId, timeout);
	}
	
	
	// --------------------- 会话管理 ---------------------

	/**
	 * 搜索数据 
	 * @param prefix 前缀 
	 * @param keyword 关键字 
	 * @param start 开始处索引 (-1代表查询所有)
	 * @param size 获取数量 
	 * @return 查询到的数据集合 
	 */
	public List<String> searchData(String prefix, String keyword, int start, int size);
}
public class SaTokenDaoRedisJackson implements SaTokenDao {

	public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
	public static final String DATE_PATTERN = "yyyy-MM-dd";
	public static final String TIME_PATTERN = "HH:mm:ss";
	public static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern(DATE_TIME_PATTERN);
	public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DATE_PATTERN);
	public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(TIME_PATTERN);

	/**
	 * ObjectMapper对象 (以public作用域暴露出此对象，方便开发者二次更改配置)
	 */
	public ObjectMapper objectMapper;
	
	/**
	 * String专用
	 */
	public StringRedisTemplate stringRedisTemplate;	

	/**
	 * Object专用 
	 */
	public RedisTemplate<String, Object> objectRedisTemplate;
	
	/**
	 * 标记：是否已初始化成功
	 */
	public boolean isInit;
	
	@Autowired
	public void init(RedisConnectionFactory connectionFactory) {
		
		// 指定相应的序列化方案 
		StringRedisSerializer keySerializer = new StringRedisSerializer();
		GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
		// 通过反射获取Mapper对象, 增加一些配置, 增强兼容性 
		try {
			Field field = GenericJackson2JsonRedisSerializer.class.getDeclaredField("mapper");
			field.setAccessible(true);
			ObjectMapper objectMapper = (ObjectMapper) field.get(valueSerializer);
			this.objectMapper = objectMapper;
			// 配置[忽略未知字段]
			this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
			// 配置[时间类型转换]
			JavaTimeModule timeModule = new JavaTimeModule();
			// LocalDateTime序列化与反序列化
			timeModule.addSerializer(new LocalDateTimeSerializer(DATE_TIME_FORMATTER));
			timeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DATE_TIME_FORMATTER));
			// LocalDate序列化与反序列化
			timeModule.addSerializer(new LocalDateSerializer(DATE_FORMATTER));
			timeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DATE_FORMATTER));
			// LocalTime序列化与反序列化
			timeModule.addSerializer(new LocalTimeSerializer(TIME_FORMATTER));
			timeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(TIME_FORMATTER));
			this.objectMapper.registerModule(timeModule);
		} catch (Exception e) {
			System.err.println(e.getMessage());
		}
		// 构建StringRedisTemplate
		StringRedisTemplate stringTemplate = new StringRedisTemplate();
		stringTemplate.setConnectionFactory(connectionFactory);
		stringTemplate.afterPropertiesSet();
		// 构建RedisTemplate
		RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
		template.setConnectionFactory(connectionFactory);
		template.setKeySerializer(keySerializer);
		template.setHashKeySerializer(keySerializer);
		template.setValueSerializer(valueSerializer);
		template.setHashValueSerializer(valueSerializer);
		template.afterPropertiesSet();
		
		// 开始初始化相关组件 
		if(this.isInit == false) {
			this.stringRedisTemplate = stringTemplate;
			this.objectRedisTemplate = template;
			this.isInit = true;
		}
	}
}

三、StpInterface 权限认证

提供了获取用户权限集以及用户角色标识接口定义，可自定义该接口的实现并结合 SaCheckPermission以及SaCheckRole注解使用，集成权限认证功能。

public interface StpInterface {

	/**
	 * 返回指定账号id所拥有的权限码集合 
	 * 
	 * @param loginId  账号id
	 * @param loginType 账号类型
	 * @return 该账号id具有的权限码集合
	 */
	public List<String> getPermissionList(Object loginId, String loginType);

	/**
	 * 返回指定账号id所拥有的角色标识集合 
	 * 
	 * @param loginId  账号id
	 * @param loginType 账号类型
	 * @return 该账号id具有的角色标识集合
	 */
	public List<String> getRoleList(Object loginId, String loginType);

}

SaToken 框架支持多账户认证体系，例如在需区分内部用户以及外部用户的使用场景下，loginType 为不同账户类型标识，可基于 loginType 分别提供不同账户类型的权限、角色信息。 

四、SaTokenAction 框架行为

提供了框架内部的关键性处理逻辑定义，包括如下：

1、createToken 创建 Token

2、createSession 创建 Session

3、hasElement 判断集合是否包含指定元素

4、checkMethodAnnotation 注解鉴权内部实现

5、validateAnnotation 注解校验

该接口标记为 @Deprecated，替代组件为 SaStrategy，目前其内部默认实现基于 SaTokenAction，个人项目可通过覆盖其中策略方法进行自定义实现。

@Deprecated
public interface SaTokenAction {

	/**
	 * 创建一个Token 
	 * @param loginId 账号id 
	 * @param loginType 账号类型 
	 * @return token
	 */
	public String createToken(Object loginId, String loginType); 
	
	/**
	 * 创建一个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);
	
	/**
	 * 从指定元素校验注解 
	 * @param target /
	 */
	public void validateAnnotation(AnnotatedElement target);
	
}
public final class SaStrategy {

	private SaStrategy() {
	}

	/**
	 * 获取 SaStrategy 对象的单例引用 
	 */
	public static final SaStrategy me = new SaStrategy();

	// 
	// 所有策略  
	// 
	
	/**
	 * 创建 Token 的策略 
	 * <p> 参数 [账号id, 账号类型] 
	 */
	public BiFunction<Object, String, String> createToken = (loginId, loginType) -> {
		return SaManager.getSaTokenAction().createToken(loginId, loginType);
	};
	
	/**
	 * 创建 Session 的策略 
	 * <p> 参数 [SessionId] 
	 */
	public Function<String, SaSession> createSession = (sessionId) -> {
		return SaManager.getSaTokenAction().createSession(sessionId);
	};

	/**
	 * 判断：集合中是否包含指定元素（模糊匹配） 
	 * <p> 参数 [集合, 元素] 
	 */
	public BiFunction<List<String>, String, Boolean> hasElement = (list, element) -> {
		return SaManager.getSaTokenAction().hasElement(list, element);
	};

	/**
	 * 对一个 [Method] 对象进行注解校验 （注解鉴权内部实现） 
	 * <p> 参数 [Method句柄] 
	 */
	public Consumer<Method> checkMethodAnnotation = (method) -> {

		// 先校验 Method 所属 Class 上的注解 
		me.checkElementAnnotation.accept(method.getDeclaringClass());

		// 再校验 Method 上的注解  
		me.checkElementAnnotation.accept(method);
	};

	/**
	 * 对一个 [元素] 对象进行注解校验 （注解鉴权内部实现） 
	 * <p> 参数 [element元素] 
	 */
	public Consumer<AnnotatedElement> checkElementAnnotation = (element) -> {
		// 为了兼容旧版本 
		SaManager.getSaTokenAction().validateAnnotation(element);
	};

	/**
	 * 从元素上获取注解（注解鉴权内部实现） 
	 * <p> 参数 [element元素，要获取的注解类型] 
	 */
	public BiFunction<AnnotatedElement, Class<? extends Annotation> , Annotation> getAnnotation = (element, annotationClass)->{
		// 默认使用jdk的注解处理器 
		return element.getAnnotation(annotationClass);
	};
	

	// 
	// 重写策略 set连缀风格 
	// 
	
	/**
	 * 重写创建 Token 的策略 
	 * <p> 参数 [账号id, 账号类型] 
	 * @param createToken / 
	 * @return 对象自身 
	 */
	public SaStrategy setCreateToken(BiFunction<Object, String, String> createToken) {
		this.createToken = createToken;
		return this;
	}

	/**
	 * 重写创建 Session 的策略 
	 * <p> 参数 [SessionId] 
	 * @param createSession / 
	 * @return 对象自身 
	 */
	public SaStrategy setCreateSession(Function<String, SaSession> createSession) {
		this.createSession = createSession;
		return this;
	}

	/**
	 * 判断：集合中是否包含指定元素（模糊匹配） 
	 * <p> 参数 [集合, 元素] 
	 * @param hasElement /
	 * @return 对象自身 
	 */
	public SaStrategy setHasElement(BiFunction<List<String>, String, Boolean> hasElement) {
		this.hasElement = hasElement;
		return this;
	}

	/**
	 * 对一个 [Method] 对象进行注解校验 （注解鉴权内部实现） 
	 * <p> 参数 [Method句柄] 
	 * @param checkMethodAnnotation /
	 * @return 对象自身 
	 */
	public SaStrategy setCheckMethodAnnotation(Consumer<Method> checkMethodAnnotation) {
		this.checkMethodAnnotation = checkMethodAnnotation;
		return this;
	}

	/**
	 * 对一个 [元素] 对象进行注解校验 （注解鉴权内部实现） 
	 * <p> 参数 [element元素] 
	 * @param checkElementAnnotation / 
	 * @return 对象自身 
	 */
	public SaStrategy setCheckElementAnnotation(Consumer<AnnotatedElement> checkElementAnnotation) {
		this.checkElementAnnotation = checkElementAnnotation;
		return this;
	}

	/**
	 * 从元素上获取注解（注解鉴权内部实现） 
	 * <p> 参数 [element元素，要获取的注解类型] 
	 * @param getAnnotation / 
	 * @return 对象自身 
	 */
	public SaStrategy setGetAnnotation(BiFunction<AnnotatedElement, Class<? extends Annotation> , Annotation> getAnnotation) {
		this.getAnnotation = getAnnotation;
		return this;
	}
	
	
}

五、SaTokenContext与SaTokenSecondContext 上下文处理器

上下文处理器是维持会话跟踪的关键，SaTokenContext 中封装定义如下：
1、getRequest 获取当前会话的「请求对象」

2、getResponse 获取当前会话的「响应对象」

3、getStorage 获取当前会话的「存储器对象」

4、matchPath 检验路由是否匹配

5、isValid 判断当前上下文是否有效

SaTokenSecondContext 完全继承至 SaTokenContext，用于区分 一级/二级上下文；类似微服务项目中，同时存在基于 http 的 web 访问以及 dubbo 的 rpc 调时，就需要提供二级上下文兼容支持。如果采用 feign 的服务间 rpc 调用，则无需二级上下文支持。

public interface SaTokenContext {

	/**
	 * 获取当前请求的 [Request] 对象
	 * 
	 * @return see note 
	 */
	public SaRequest getRequest();

	/**
	 * 获取当前请求的 [Response] 对象
	 * 
	 * @return see note 
	 */
	public SaResponse getResponse();

	/**
	 * 获取当前请求的 [存储器] 对象 
	 * 
	 * @return see note 
	 */
	public SaStorage getStorage();

	/**
	 * 校验指定路由匹配符是否可以匹配成功指定路径 
	 * 
	 * @param pattern 路由匹配符 
	 * @param path 需要匹配的路径 
	 * @return see note 
	 */
	public boolean matchPath(String pattern, String path);

	/**
	 * 此上下文是否有效 
	 * @return / 
	 */
	public default boolean isValid() {
		return false;
	}
	
}
public interface SaTokenSecondContext extends SaTokenContext {
	
}

六、SaTokenListener 认证活动监听

封装定义了认证活动中的关键性操作行为监听，包括登录、注销、被踢下线、禁用等操作。可自定义各操作的实现，扩展功能支持，例如：用户认证日志、账号安全通知等。

public interface SaTokenListener {

	/**
	 * 每次登录时触发 
	 * @param loginType 账号类别
	 * @param loginId 账号id
	 * @param loginModel 登录参数
	 */
	public void doLogin(String loginType, Object loginId, SaLoginModel loginModel);
			
	/**
	 * 每次注销时触发 
	 * @param loginType 账号类别
	 * @param loginId 账号id
	 * @param tokenValue token值
	 */
	public void doLogout(String loginType, Object loginId, String tokenValue);
	
	/**
	 * 每次被踢下线时触发 
	 * @param loginType 账号类别 
	 * @param loginId 账号id 
	 * @param tokenValue token值 
	 */
	public void doKickout(String loginType, Object loginId, String tokenValue);

	/**
	 * 每次被顶下线时触发
	 * @param loginType 账号类别
	 * @param loginId 账号id
	 * @param tokenValue token值
	 */
	public void doReplaced(String loginType, Object loginId, String tokenValue);

	/**
	 * 每次被封禁时触发
	 * @param loginType 账号类别
	 * @param loginId 账号id
	 * @param disableTime 封禁时长，单位: 秒
	 */
	public void doDisable(String loginType, Object loginId, long disableTime);
	
	/**
	 * 每次被解封时触发
	 * @param loginType 账号类别
	 * @param loginId 账号id
	 */
	public void doUntieDisable(String loginType, Object loginId);
	
	/**
	 * 每次创建Session时触发
	 * @param id SessionId
	 */
	public void doCreateSession(String id);
	
	/**
	 * 每次注销Session时触发
	 * @param id SessionId
	 */
	public void doLogoutSession(String id);
	
}

七、SaTempInterface 临时令牌验证

封装定义了临时令牌的生成、删除、解析、获取过期时间等接口定义，默认基于SaTokenDao支持持久化处理，sa-token-temp-jwt 插件中提供了基于 jwt 的自校验实现。以「邀请链接」的临时令牌应用分析使用特点：

1、有效期时间短，通常在5分钟，10分钟等；

2、需要隐蔽掉具备规律性的关键信息，比如某游戏工会的邀请链接中需要提供的工会标识信息，如果明文传输 id=1000 形式，就可以通过 修改 id=1001 尝试加入其他工会。在邀请链接中携带随机生成的临时令牌替代明文标识，服务端通过解析临时令牌获取其对应明文标识再做业务处理，支持规律性信息的隐蔽目的。

public interface SaTempInterface {

	/**
	 * 根据value创建一个token 
	 * @param value 指定值
	 * @param timeout 有效期，单位：秒 
	 * @return 生成的token
	 */
	public default String createToken(Object value, long timeout) {
		
		// 生成 token 
		String token = SaStrategy.me.createToken.apply(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);
	}

	/**
	 * 删除一个 token
	 * @param token 指定token 
	 */
	public default void deleteToken(String token) {
		String key = splicingKeyTempToken(token);
		SaManager.getSaTokenDao().deleteObject(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;
	}
}

八、StpLogic 认证处理逻辑

StpLogic 是 Sa-token 框架各个组件能够协同配合，提供认证鉴权功能的关键。

在 SaManager 中 StpLogic 是以 Map 集合的形式初始化，Map 的键为 StpLogic 的 loginType（账号类型），值为 StpLogic 操作对象，这就是 Sa-token 支持多账号认证体系的基础，基于不同的loginType，实现不同账号类型的认证逻辑隔离。

public class SaManager {
	
	/**
	 * StpLogic集合, 记录框架所有成功初始化的StpLogic 
	 */
	public static Map<String, StpLogic> stpLogicMap = new HashMap<String, StpLogic>();
	
	/**
	 * 向集合中 put 一个 StpLogic 
	 * @param stpLogic StpLogic
	 */
	public static void putStpLogic(StpLogic stpLogic) {
		stpLogicMap.put(stpLogic.getLoginType(), stpLogic);
	}

	/**
	 * 根据 LoginType 获取对应的StpLogic，如果不存在则抛出异常 
	 * @param loginType 对应的账号类型 
	 * @return 对应的StpLogic
	 */
	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;
	}
	
	
}

以下分场景介绍 StpLogic 中接口功能：

（一）Token 相关

  • 创建 Token
	/**
	 * 创建一个TokenValue 
	 * @param loginId loginId 
	 * @param device 设备标识 
	 * @param timeout 过期时间 
	 * @return 生成的tokenValue 
	 */
 	public String createTokenValue(Object loginId, String device, long timeout) {
 		return SaStrategy.me.createToken.apply(loginId, loginType);
	}

                默认基于 SaStrategy 创建 Token 策略实现，生成无实际含义的随机字符串。可通过以下方式自定义实现：

        （1）新建 StpLogic 子类 重写 createTokenValue 方法；例如 sa-token-jwt 插件中提供的StpLogicJwtForStyle 重写

        （2）由于 SaStrategy 全局单例，可通过以下方式实现其创建 Token 策略的重写

SaStrategy.me.setCreateToken((loginId, loginType) -> {
		// 自定义Token生成的算法 
		return "xxxx";
});
  • 存储 Token 至当前会话
    • 保存至 Storage
      • 保存在 request 域
      • 仅在当前请求中有效，重定向客户端后将无法获取到 Token
    • 保存至 Cookie
      • 保存在 cookie 域
      • 在 Cookie 有效期内，符合 Cookie 安全策略的请求中都可以再次获取
    /**
 	 * 在当前会话写入当前TokenValue 
 	 * @param tokenValue token值 
 	 */
	public void setTokenValue(String tokenValue){
		setTokenValue(tokenValue, (int)SaManager.getConfig().getTimeout());
	}
	
 	/**
 	 * 在当前会话写入当前TokenValue 
 	 * @param tokenValue token值 
 	 * @param cookieTimeout Cookie存活时间(秒)
 	 */
	public void setTokenValue(String tokenValue, int cookieTimeout){
		
		if(SaFoxUtil.isEmpty(tokenValue)) {
			return;
		}
		
		// 1. 将token保存到[存储器]里  
		setTokenValueToStorage(tokenValue);
		
		// 2. 将 Token 保存到 [Cookie] 里 
		if (getConfig().getIsReadCookie()) {
			setTokenValueToCookie(tokenValue, cookieTimeout);
		}
	}

 	/**
 	 * 将 Token 保存到 [Storage] 里 
 	 * @param tokenValue token值 
 	 */
	public void setTokenValueToStorage(String tokenValue){
		// 1. 将token保存到[存储器]里  
		SaStorage storage = SaHolder.getStorage();
		
		// 2. 如果打开了 Token 前缀模式，则拼接上前缀
		String tokenPrefix = getConfig().getTokenPrefix();
		if(SaFoxUtil.isEmpty(tokenPrefix) == false) {
			storage.set(splicingKeyJustCreatedSave(), tokenPrefix + SaTokenConsts.TOKEN_CONNECTOR_CHAT + tokenValue);	
		} else {
			storage.set(splicingKeyJustCreatedSave(), tokenValue);	
		}
		
		// 3. 写入 (无前缀) 
		storage.set(SaTokenConsts.JUST_CREATED_NOT_PREFIX, tokenValue);  
	}
	
 	/**
 	 * 将 Token 保存到 [Cookie] 里 
 	 * @param tokenValue token值 
 	 * @param cookieTimeout Cookie存活时间(秒)
 	 */
	public void setTokenValueToCookie(String tokenValue, int cookieTimeout){
		SaCookieConfig cfg = getConfig().getCookie();
		SaCookie cookie = new SaCookie()
				.setName(getTokenName())
				.setValue(tokenValue)
				.setMaxAge(cookieTimeout)
				.setDomain(cfg.getDomain())
				.setPath(cfg.getPath())
				.setSecure(cfg.getSecure())
				.setHttpOnly(cfg.getHttpOnly())
				.setSameSite(cfg.getSameSite())
				;
		SaHolder.getResponse().addCookie(cookie);
	}
  • 获取当前会话的 Token

        分优先级从以下途径获取

  1. Storage 获取
  2. RequestParam 获取
  3. Header 获取
  4. Cookie 获取
    /**
	 * 获取当前TokenValue
	 * @return 当前tokenValue
	 */
	public String getTokenValue(){
		// 1. 获取
		String tokenValue = getTokenValueNotCut();
		
		// 2. 如果打开了前缀模式，则裁剪掉 
		String tokenPrefix = getConfig().getTokenPrefix();
		if(SaFoxUtil.isEmpty(tokenPrefix) == false) {
			// 如果token并没有按照指定的前缀开头，则视为未提供token 
			if(SaFoxUtil.isEmpty(tokenValue) || tokenValue.startsWith(tokenPrefix + SaTokenConsts.TOKEN_CONNECTOR_CHAT) == false) {
				tokenValue = null;
			} else {
				// 则裁剪掉前缀 
				tokenValue = tokenValue.substring(tokenPrefix.length() + SaTokenConsts.TOKEN_CONNECTOR_CHAT.length());
			}
		}
		
		// 3. 返回 
		return tokenValue;
	}
	
	/**
	 * 获取当前TokenValue (不裁剪前缀)
	 * @return / 
	 */
	public String getTokenValueNotCut(){
		// 0. 获取相应对象 
		SaStorage storage = SaHolder.getStorage();
		SaRequest request = SaHolder.getRequest();
		SaTokenConfig config = getConfig();
		String keyTokenName = getTokenName();
		String tokenValue = null;
		
		// 1. 尝试从Storage里读取 
		if(storage.get(splicingKeyJustCreatedSave()) != null) {
			tokenValue = String.valueOf(storage.get(splicingKeyJustCreatedSave()));
		}
		// 2. 尝试从请求体里面读取 
		if(tokenValue == null && config.getIsReadBody()){
			tokenValue = request.getParam(keyTokenName);
		}
		// 3. 尝试从header里读取 
		if(tokenValue == null && config.getIsReadHead()){
			tokenValue = request.getHeader(keyTokenName);
		}
		// 4. 尝试从cookie里读取 
		if(tokenValue == null && config.getIsReadCookie()){
			tokenValue = request.getCookieValue(keyTokenName);
		}
		
		// 5. 返回 
		return tokenValue;
	}

（二）登录相关

  • 会话登录
    • 支持多端设备模式
      • 不同端设备登录每次新建 Token，一端设备进行注销，不影响其他端
    • 开启并发登录模式（默认启用）
      • 共享模式（默认）：（同端设备）共用同一 Token，一方进行注销，整体都不可登录
      • 独立模式：（同端设备）每次新建 Token，各方进行注销，互不影响
    • 禁用并发登录模式：（同端设备）一方登录，将顶替掉另一登录方
	/**
	 * 会话登录 
	 * @param id 账号id，建议的类型：（long | int | String）
	 */
	public void login(Object id) {
		login(id, new SaLoginModel());
	}

	/**
	 * 会话登录，并指定登录设备 
	 * @param id 账号id，建议的类型：（long | int | String）
	 * @param device 设备标识 
	 */
	public void login(Object id, String device) {
		login(id, new SaLoginModel().setDevice(device));
	}

	/**
	 * 会话登录，并指定是否 [记住我] 
	 * @param id 账号id，建议的类型：（long | int | String）
	 * @param isLastingCookie 是否为持久Cookie 
	 */
	public void login(Object id, boolean isLastingCookie) {
		login(id, new SaLoginModel().setIsLastingCookie(isLastingCookie));
	}
	
	/**
	 * 会话登录，并指定所有登录参数Model 
	 * @param id 登录id，建议的类型：（long | int | String）
	 * @param loginModel 此次登录的参数Model 
	 */
	public void login(Object id, SaLoginModel loginModel) {
		
		SaTokenException.throwByNull(id, "账号id不能为空");
		
		// ------ 0、前置检查：如果此账号已被封禁. 
		if(isDisable(id)) {
			throw new DisableLoginException(loginType, id, getDisableTime(id));
		}
		
		// ------ 1、初始化 loginModel 
		SaTokenConfig config = getConfig();
		loginModel.build(config);
		
		// ------ 2、生成一个token  
		String tokenValue = null;
		// --- 如果允许并发登录 
		if(config.getIsConcurrent()) {
			// 如果配置为共享token, 则尝试从Session签名记录里取出token 
			if(getConfigOfIsShare()) {
				tokenValue = getTokenValueByLoginId(id, loginModel.getDeviceOrDefault());
			}
		} else {
			// --- 如果不允许并发登录，则将这个账号的历史登录标记为：被顶下线 
			replaced(id, loginModel.getDevice());
		}
		// 如果至此，仍未成功创建tokenValue, 则开始生成一个 
		if(tokenValue == null) {
			tokenValue = createTokenValue(id, loginModel.getDeviceOrDefault(), loginModel.getTimeout());
		}
		
		// ------ 3. 获取 User-Session , 续期 
		SaSession session = getSessionByLoginId(id, true);
		session.updateMinTimeout(loginModel.getTimeout());
		
		// 在 User-Session 上记录token签名 
		session.addTokenSign(tokenValue, loginModel.getDeviceOrDefault());
		
		// ------ 4. 持久化其它数据 
		// token -> id 映射关系  
		saveTokenToIdMapping(tokenValue, id, loginModel.getTimeout());
		
		// 在当前会话写入tokenValue 
		setTokenValue(tokenValue, loginModel.getCookieTimeout());

		// 写入 [token-last-activity] 
		setLastActivityToNow(tokenValue); 
		
		// $$ 通知监听器，账号xxx 登录成功 
		SaManager.getSaTokenListener().doLogin(loginType, id, loginModel);
	}
  • 会话注销
    • 注销当前会话
    • 注销指定会话
      • 注销方式
        • 注销指定账号：账号下属所有登录都将强制下线
        • 注销指定账号登录设备：账号下属指定设备登录都将强制下线（关注：独立模式的并发登录）
        • 注销指定会话：与指定 Token 关联的会话都将强制下线（关注：共享模式的并发登录）
	/** 
	 * 会话注销 
	 */
	public void logout() {
		// 如果连token都没有，那么无需执行任何操作 
		String tokenValue = getTokenValue();
 		if(SaFoxUtil.isEmpty(tokenValue)) {
 			return;
 		}
 		
 		// 从当前 [storage存储器] 里删除 
 		SaHolder.getStorage().delete(splicingKeyJustCreatedSave());
 		
 		// 如果打开了Cookie模式，则把cookie清除掉 
 		if(getConfig().getIsReadCookie()){
 			SaHolder.getResponse().deleteCookie(getTokenName());
		}
 		
 		// 清除这个token的相关信息
 		logoutByTokenValue(tokenValue);
	}

	/**
	 * 会话注销，根据账号id 
	 * 
	 * @param loginId 账号id 
	 */
	public void logout(Object loginId) {
		logout(loginId, null);
	}
	
	/**
	 * 会话注销，根据账号id 和 设备标识 
	 * 
	 * @param loginId 账号id 
	 * @param device 设备标识 (填null代表所有注销设备) 
	 */
	public void logout(Object loginId, String device) {
		clearTokenCommonMethod(loginId, device, tokenValue -> {
	 		// 删除Token-Id映射 & 清除Token-Session 
			deleteTokenToIdMapping(tokenValue);
			deleteTokenSession(tokenValue);
			SaManager.getSaTokenListener().doLogout(loginType, loginId, tokenValue);
		}, true);
	}
	
	/**
	 * 会话注销，根据指定 Token 
	 * 
	 * @param tokenValue 指定token
	 */
	public void logoutByTokenValue(String tokenValue) {
		// 1. 清理 token-last-activity
		clearLastActivity(tokenValue); 	
		
		// 2. 注销 Token-Session 
		deleteTokenSession(tokenValue);

		// if. 无效 loginId 立即返回 
 		String loginId = getLoginIdNotHandle(tokenValue);
 	 	if(isValidLoginId(loginId) == false) {
 	 		if(loginId != null) {
 	 			deleteTokenToIdMapping(tokenValue);
 	 		}
 			return;
 		}
 		// 3. 清理token-id索引 
 	 	deleteTokenToIdMapping(tokenValue);
 	 	
 	 	// $$ 通知监听器，某某Token注销下线了 
		SaManager.getSaTokenListener().doLogout(loginType, loginId, tokenValue);

		// 4. 清理User-Session上的token签名 & 尝试注销User-Session 
 	 	SaSession session = getSessionByLoginId(loginId, false);
 	 	if(session != null) {
 	 	 	session.removeTokenSign(tokenValue); 
 			session.logoutByTokenSignCountToZero();
 	 	}
	}
  • 踢人下线：会话标记为 KICK_OUT，在 Token 有效期内，再次访问将反馈“Token已被踢下线”
    • 指定账号：影响账号下属所有会话
    • 指定设备：影响账号下属指定设备相关会话（关注：独立模式的并发登录）
    • 指定会话：影响与指定 Token 关联的所有会话（关注：共享模式的并发登录）
	/**
	 * 踢人下线，根据账号id 
	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
	 * 
	 * @param loginId 账号id 
	 */
	public void kickout(Object loginId) {
		kickout(loginId, null);
	}
	
	/**
	 * 踢人下线，根据账号id 和 设备标识 
	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
	 * 
	 * @param loginId 账号id 
	 * @param device 设备标识 (填null代表踢出所有设备) 
	 */
	public void kickout(Object loginId, String device) {
		clearTokenCommonMethod(loginId, device, tokenValue -> {
			// 将此 token 标记为已被踢下线  
			updateTokenToIdMapping(tokenValue, NotLoginException.KICK_OUT);
	 		SaManager.getSaTokenListener().doKickout(loginType, loginId, tokenValue);
		}, true);
	}

	/**
	 * 踢人下线，根据指定 Token 
	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
	 * 
	 * @param tokenValue 指定token
	 */
	public void kickoutByTokenValue(String tokenValue) {
		// 1. 清理 token-last-activity
		clearLastActivity(tokenValue); 	
		
		// 2. 不注销 Token-Session 

 		// if. 无效 loginId 立即返回 
 		String loginId = getLoginIdNotHandle(tokenValue);
 	 	if(isValidLoginId(loginId) == false) {
 			return;
 		}
 	 	
 		// 3. 给token打上标记：被踢下线 
 	 	updateTokenToIdMapping(tokenValue, NotLoginException.KICK_OUT);
		
 	 	// $$. 否则通知监听器，某某Token被踢下线了 
		SaManager.getSaTokenListener().doKickout(loginType, loginId, tokenValue);

		// 4. 清理User-Session上的token签名 & 尝试注销User-Session 
 	 	SaSession session = getSessionByLoginId(loginId, false);
 	 	if(session != null) {
 	 	 	session.removeTokenSign(tokenValue); 
 			session.logoutByTokenSignCountToZero();
 	 	}
	}
  • 顶人下线：会话标记为 BE_REPLACED，在 Token 有效期内，再次访问将反馈“Token已被顶下线”
    • 仅指定账号：影响账号下属所有会话
    • 同时指定设备：影响账号下属指定设备相关会话（关注：独立模式的并发登录）
	/**
	 * 顶人下线，根据账号id 和 设备标识 
	 * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
	 * 
	 * @param loginId 账号id 
	 * @param device 设备标识 (填null代表顶替所有设备) 
	 */
	public void replaced(Object loginId, String device) {
		clearTokenCommonMethod(loginId, device, tokenValue -> {
			// 将此 token 标记为已被顶替 
			updateTokenToIdMapping(tokenValue, NotLoginException.BE_REPLACED);
	 		SaManager.getSaTokenListener().doReplaced(loginType, loginId, tokenValue);
		}, false);
	}

（三）Session 相关

Sa-Token 框架中，在 StpLogic 中有以下两类 Session：

  • Token-Session：为每个 Token 分配的 Session
  • User-Session：为每个 Session 分配的 Session

两类 Session 的创建、获取都以 sessionId 作为依据。

/** 
	 * 获取指定key的Session, 如果Session尚未创建，isCreate=是否新建并返回
	 * @param sessionId SessionId
	 * @param isCreate 是否新建
	 * @return Session对象 
	 */
	public SaSession getSessionBySessionId(String sessionId, boolean isCreate) {
		SaSession session = getSaTokenDao().getSession(sessionId);
		if(session == null && isCreate) {
			session = SaStrategy.me.createSession.apply(sessionId);
			getSaTokenDao().setSession(session, getConfig().getTimeout());
		}
		return session;
	}

	/** 
	 * 获取指定key的Session, 如果Session尚未创建，则返回null
	 * @param sessionId SessionId
	 * @return Session对象 
	 */
	public SaSession getSessionBySessionId(String sessionId) {
		return getSessionBySessionId(sessionId, false);
	}

	/** 
	 * 获取指定账号id的User-Session, 如果Session尚未创建，isCreate=是否新建并返回
	 * @param loginId 账号id
	 * @param isCreate 是否新建
	 * @return Session对象
	 */
	public SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
		return getSessionBySessionId(splicingKeySession(loginId), isCreate);
	}

接下来分别介绍这两类 Session，梳理两者之间是如何配合以支撑 Sa-token 框架的认证。

 1、Token-Session

Token-Session 与 tokenValue 强相关：

  • Token-Session 的创建、更新、获取都需要以 loginId 作为依据
  • Token-Session 的 sessionId 是以 tokenValue 为基础，拼接上特定字符串生成，因此可通过 tokenValue 获取到其对应 Token-Session
    /** 
	 * 获取指定Token-Session，如果Session尚未创建，isCreate代表是否新建并返回
	 * @param tokenValue token值
	 * @param isCreate 是否新建 
	 * @return session对象
	 */
	public SaSession getTokenSessionByToken(String tokenValue, boolean isCreate) {
		return getSessionBySessionId(splicingKeyTokenSession(tokenValue), isCreate);
	}
	
	/** 
	 * 获取指定Token-Session，如果Session尚未创建，则新建并返回 
	 * @param tokenValue Token值
	 * @return Session对象  
	 */
	public SaSession getTokenSessionByToken(String tokenValue) {
		return getSessionBySessionId(splicingKeyTokenSession(tokenValue), true);
	}

	/** 
	 * 获取当前Token-Session，如果Session尚未创建，isCreate代表是否新建并返回 
	 * @param isCreate 是否新建 
	 * @return Session对象  
	 */
	public SaSession getTokenSession(boolean isCreate) {
		// 如果配置了需要校验登录状态，则验证一下
		if(getConfig().getTokenSessionCheckLogin()) {
			checkLogin();
		} else {
			// 如果配置忽略token登录校验，则必须保证token不为null (token为null的时候随机创建一个) 
			String tokenValue = getTokenValue();
			if(tokenValue == null || Objects.equals(tokenValue, "")) {
				// 随机一个token送给Ta 
				tokenValue = createTokenValue(null, null, getConfig().getTimeout());
				// 写入 [最后操作时间]
				setLastActivityToNow(tokenValue);  
				// 在当前会话写入这个tokenValue 
				int cookieTimeout = (int)(getConfig().getTimeout() == SaTokenDao.NEVER_EXPIRE ? Integer.MAX_VALUE : getConfig().getTimeout());
				setTokenValue(tokenValue, cookieTimeout);
			}
		}
		// 返回这个token对应的Token-Session 
		return getSessionBySessionId(splicingKeyTokenSession(getTokenValue()), isCreate);
	}
	
	/** 
	 * 获取当前Token-Session，如果Session尚未创建，则新建并返回
	 * @return Session对象 
	 */
	public SaSession getTokenSession() {
		return getTokenSession(true);
	}
	
	/**
	 * 删除Token-Session 
	 * @param tokenValue token值 
	 */
	public void deleteTokenSession(String tokenValue) {
		getSaTokenDao().delete(splicingKeyTokenSession(tokenValue));
	}

	/**  
	 * 拼接key： tokenValue的专属session 
	 * @param tokenValue token值
	 * @return key
	 */
	public String splicingKeyTokenSession(String tokenValue) {
		return getConfig().getTokenName() + ":" + loginType + ":token-session:" + tokenValue;
	}

2、User-Session

User-Session 与 loginId 强相关：

  • User-Session 的创建、更新、获取都需要以 loginId 作为依据
  • User-Session 的 sessionId 是以 loginId 为基础，拼接上特定字符串生成，因此可通过 loginId 获取到其对应 User-Session
	/** 
	 * 获取指定账号id的User-Session，如果Session尚未创建，则新建并返回 
	 * @param loginId 账号id 
	 * @return Session对象 
	 */
	public SaSession getSessionByLoginId(Object loginId) {
		return getSessionBySessionId(splicingKeySession(loginId), true);
	}

	/** 
	 * 获取当前User-Session, 如果Session尚未创建，isCreate=是否新建并返回 
	 * @param isCreate 是否新建 
	 * @return Session对象 
	 */
	public SaSession getSession(boolean isCreate) {
		return getSessionByLoginId(getLoginId(), isCreate);
	}
	
	/** 
	 * 获取当前User-Session，如果Session尚未创建，则新建并返回 
	 * @return Session对象 
	 */
	public SaSession getSession() {
		return getSession(true);
	}

	/** 
	 * 拼接key： Session 持久化  
	 * @param loginId 账号id
	 * @return key
	 */
	public String splicingKeySession(Object loginId) {
		return getConfig().getTokenName() + ":" + loginType + ":session:" + loginId;
	}

（四）Key 相关

无论是在浏览器 token 的获取，还是在服务端 session 的获取都是基于 key 进行匹配，通过梳理 Sa-token 框架中的相关 key，更有利于了解从客户端、服务端之间完成登录认证以及用户识别的处理方式。SptLogic 中定义了 8 种 key：

  • TokenName-key 获取认证凭证的键（session 域有效）
    /**
	 * 拼接key：客户端 tokenName 
	 * @return key
	 */
	public String splicingKeyTokenName() {
 		return getConfig().getTokenName();
 	}
  • TokenValue-key 获取凭证解析值（loginId）的键（session 域有效）
	/**  
	 * 拼接key： tokenValue 持久化 token-id
	 * @param tokenValue token值
	 * @return key
	 */
	public String splicingKeyTokenValue(String tokenValue) {
		return getConfig().getTokenName() + ":" + loginType + ":token:" + tokenValue;
	}
  • UserSession-key 获取 UserSession 信息的键（session+ 域有效）
	/** 
	 * 拼接key： Session 持久化  
	 * @param loginId 账号id
	 * @return key
	 */
	public String splicingKeySession(Object loginId) {
		return getConfig().getTokenName() + ":" + loginType + ":session:" + loginId;
	}
  • TokenSession-key 获取 TokenSession 信息的键（session 域有效）
	/**  
	 * 拼接key： tokenValue的专属session 
	 * @param tokenValue token值
	 * @return key
	 */
	public String splicingKeyTokenSession(String tokenValue) {
		return getConfig().getTokenName() + ":" + loginType + ":token-session:" + tokenValue;
	}
  • LastActivityTime-key 获取会话最后活跃时间的键（session 域有效）
	/** 
	 * 拼接key： 指定token的最后操作时间 持久化 
	 * @param tokenValue token值
	 * @return key
	 */
	public String splicingKeyLastActivityTime(String tokenValue) {
		return getConfig().getTokenName() + ":" + loginType + ":last-activity:" + tokenValue;
	}
  • Switch-key 获临时切换身份信息（loginId）的键（request 域有效）
	/**
	 * 在进行身份切换时，使用的存储key 
	 * @return key
	 */
	public String splicingKeySwitch() {
		return SaTokenConsts.SWITCH_TO_SAVE_KEY + loginType;
	}
  • JustCreatedSave-key 获取新凭证的键（request 域有效）
	/**
	 * 如果token为本次请求新创建的，则以此字符串为key存储在当前request中 
	 * @return key
	 */
	public String splicingKeyJustCreatedSave() {
//		return SaTokenConsts.JUST_CREATED_SAVE_KEY + loginType;
		return SaTokenConsts.JUST_CREATED;
	}
  • Disable-key 获取账号封禁信息的键（session+ 域有效）
	/**  
	 * 拼接key： 账号封禁
	 * @param loginId 账号id
	 * @return key 
	 */
	public String splicingKeyDisable(Object loginId) {
		return getConfig().getTokenName() + ":" + loginType + ":disable:" + loginId;
	}

KsamaLi
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sa-token封装了一下
03-15
sa-token封装了一下
SpringBoot(51) 整合Sa-Token实现权限认证
08-17
SpringBoot(51) 整合Sa-Token实现权限认证
sa-token在多体系用户系统中最佳实践
最新发布
weixin_43994234的博客
03-17 900
Sa-Token框架多系统用户登录最佳实践
Sa-Token权限认证框架.rar
07-08
Sa-Token是一个轻量级Java权限验证框架。它不仅支持SpringBoot等主流框架，也可以适配Servlet、JFinal等非主流框架。Sa-Token可以用于身份验证、角色权限验证、API接口鉴权等场景。本文将重点介绍在SpringBoot框架中如何使用Sa-Token进行身份验证和角色权限验证。 在Sa-Token中，可以使用 LoginUtil 来进行登录操作。该工具类提供了多种登录方式，包括账号密码登录、二维码登录、微信登录等。 上面的示例中，我们在AuthController中创建了一个 /auth/login 接口，用于处理账号密码登录请求。LoginUtil.login()方法会根据传入的用户名和密码进行身份验证，并返回一个token值。 当登录成功后，我们可以在接口调用的其他方法中获取当前用户信息：
sa-token:这可能是史上功能最全的Java权限认证框架！目前已集成-登录验证，权限验证，会话会话，踢人下线，分布式会话，单点登录，OAuth2.0，记住我模式，模拟公众账号，临时身份切换，集成Redis，多账号认证体系，前后台分离模式，注解式鉴权，路由拦截式鉴权，花式令牌生成，自动续签，同端互斥登录，会话治理，密码加密，jwt集成，Spring集成..
04-02
sa-token v1.15.2 这可能是史上功能最全的Java权限认证框架！ 在线资料 Sa-Token是什么？ sa-token是一个轻量级Java权限认证框架，主要解决：登录认证，权限认证，会话会话，单点登录，OAuth2.0等长度权限相关问题 框架针对踢人下线，自动续签，前后台分离，分散会话……等常见业务进行N多适应，通过sa-token，你可以以一种极简的方式实现系统的权限认证部分 与其他权限认证框架索引， sa-token具有以下优点： 简单：可零配置启动框架，真正的开箱即用，规定上手 强大：目前已集成数十项权限相关特性，涵盖了大部分业务场景的解决方案 易用：如丝般顺滑的API调用，大量高级特性统统立即一行代码即可实现 高扩展：几乎所有组件都提供了扩展接口，90％以上的逻辑都可以按需重写 有了sa-token，你所有的权限认证问题，都不再是问题！ Sa-Token能做什么？
springboot整合Sa-Token 实现前后端分离登录注销功能，刚学习Sa-Token，用来练手，适合初学者。仅作学习使用
05-22
springboot整合Sa-Token 实现前后端分离登录注销功能，刚学习Sa-Token，用来练手，适合初学者。仅作学习使用 前端使用html jquery ajax异步请求 后端springboot框架，Sa-Token框架。 jdk使用1.8 mysql 8.0
SaToken学习笔记-03
qq_47815451的博客
08-13 995
#SaToken学习笔记-03 如果排版有问题，请点击：传送门 ##核心思想 所谓权限验证，验证的核心就是一个账号是否拥有一个权限码 有，就让你通过。没有？那么禁止访问! 再往底了说，就是每个账号都会拥有一个权限码集合，我来验证这个集合中是否包含指定的权限码 例如：当前账号拥有权限码集合：[“user-add”, “user-delete”, “user-get”]，这时候我来验证权限 “user-update”，则其结果就是：验证失败，禁止访问 所以现在问题的核心就是: 如何获取一个账号所拥有的的权限
探索 Sa-Token (五)SaManager # SaTokenConfig 全局组件设计原理
weixin_38982591的博客
01-23 452
*** 注入 Sa-Token 所需要的 Bean*/= null) {
SaToken学习笔记-02
qq_47815451的博客
08-13 952
#SaToken学习笔记-02 如果排版有问题，请点击：传送门 ##常用的登录有关的方法 - StpUtil.logout() 作用为：当前会话注销登录 调用此方法，其实做了哪些操作呢，我们来一起看一下源码 /** * 当前会话注销登录 */ public static void logout() { stpLogic.logout(); } 一开始调用了stpLogic.logout()方法 #####什么是stpLogic? stpLogic是在StpUtil类中定义的一个底层的S
sa-token源码解析二
weixin_40118044的博客
11-24 1751
SaManager SaManager 负责管理 Sa-Token 所有运行时对象 SaManager.getConfig(); // 获取全局配置对象 SaManager.getSaTokenDao(); // 获取数据持久化对象 SaManager.getStpInterface(); // 获取权限认证对象 SaManager.getSaTokenAction(); // 获取框架行为对象 SaManager.ge...
基于SpringBoot的影像注册系统04 sa-token使用（源码解析 + 万字
m0_67614284的博客
05-03 1562
逻辑：查询username存不存在，再查询密码是否正确，只要没有抛异常就调用sa-token的login方法。 StpUtil.login(userReal.getId()); login方法传入我们user的id，比如： 把int类型的数值传进去了。 步骤 4 sa-token登录认证 ================= [核心思想](() 所谓登录认证，说白了就是限制某些API接口必须登录后才能访问（例：查询我的账号资料） 那么如何判断一个会话是否登录？框架会在登录成功后给你做个标记，每次登录认证时校
sa-token 多端登录思路和遇到的坑
ControlDemo的博客
01-28 6450
sa-token 多端登录思路和遇到的坑
Sa-Token简单登录认证
沧海一粟
10-14 5086
sa token是一个全新的权限框架，相比spring security和apache shiro来说，使用起来更加便捷，配置更少，侵入性更小。 下面是一个简单的登录认证示例，以一个spring boot+thymeleaf来实现具体逻辑 首先导入sa token的Maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boo
【Sa-Token】5、Sa-Token授权操作
热门推荐
Asurplus
08-01 20万+
Sa-Token 在用户登录之后，并不会马上授权，而是等到需要验证的时候，才会去授权，授权也非常简单，我们只需要实现 StpInterface 接口，重写 getRoleList、getPermissionList 两个方法就好了，与 shiro 一样，同样返回 role 的标识集合，和 permission 的标识集合就好了 1、用户授权 package com.asurplus.common.satoken; import cn.dev33.satoken.stp.StpInterface; impo
Sa-Token 多账号认证：同时为系统的 Admin 账号和 User 账号提供鉴权操作
shengzhang_的博客
07-24 917
前面几篇介绍的api调用，都是经过 StpUtil 类的各种静态方法进行授权认证，而如果我们深入它的源码，点此阅览就会发现，此类并没有任何代码逻辑，唯一做的事就是对成员变量stpLogic的各个API包装一下进行转发。StpLogic 类的所有函数都可以被重写，按需扩展。在构造方法时随意传入一个不同的loginType，就可以再造一套账号登录体系。/*** 登录认证(User版)：只有登录之后才能进入该方法* 可标注在函数、类上（效果等同于标注在此类的所有方法上）
Sa-Token浅谈
imVainiycos的博客
12-14 4859
官网介绍的非常详细，主要突出这是一个轻量级鉴权框架的特点，详情可自行访问：https://sa-token.dev33.cn/doc.html#/
sa-token进阶
imVainiycos的博客
12-19 1133
介绍sa-token实际应用的高阶用法。
Spring Boot 集成并开发 Sa-token
吴名氏的博客
06-05 10万+
Spring Boot 集成并开发 Sa-token
sa-token部分源码分析
ZHANGLIZENG的博客
02-14 1103
to-token基本介绍及部分源码分析...
sa-token如何校验token
07-28
sa-token可以通过以下配置来校验token： 1. 配置token名称：在yml配置文件中，可以通过设置`sa-token.token-name`来指定token的名称，例如`sa-token.token-name: X-Token`\[1\]。 2. 配置token有效期：可以通过设置`sa-token.timeout`来指定token的有效期，单位为秒，默认为30天，可以设置为-1代表永不过期，例如`sa-token.timeout: 2592000`\[1\]。 3. 配置token临时有效期：可以通过设置`sa-token.activity-timeout`来指定token的临时有效期，即在指定时间内无操作就视为token过期，单位为秒，默认为-1，表示不设置临时有效期，例如`sa-token.activity-timeout: -1`\[1\]。 4. 配置是否允许同一账号并发登录：可以通过设置`sa-token.is-concurrent`来指定是否允许同一账号并发登录，为true时允许一起登录，为false时新登录会挤掉旧登录，例如`sa-token.is-concurrent: true`\[1\]。 5. 配置是否共用一个token：可以通过设置`sa-token.is-share`来指定在多人登录同一账号时，是否共用一个token，为true时所有登录共用一个token，为false时每次登录会新建一个token，例如`sa-token.is-share: true`\[1\]。 6. 配置是否输出操作日志：可以通过设置`sa-token.is-log`来指定是否输出操作日志，为true时输出操作日志，为false时不输出操作日志，例如`sa-token.is-log: false`\[1\]。 7. 配置是否使用cookie保存token：可以通过设置`sa-token.is-read-cookie`来指定是否使用cookie保存token，为true时使用cookie保存token，为false时不使用cookie保存token，例如`sa-token.is-read-cookie: false`\[1\]。 8. 配置是否使用head保存token：可以通过设置`sa-token.is-read-head`来指定是否使用head保存token，为true时使用head保存token，为false时不使用head保存token，例如`sa-token.is-read-head: true`\[1\]。 通过以上配置，sa-token可以根据配置的规则来校验token的有效性。 #### 引用[.reference_title] - *1* [最简单的权限验证实现——使用Sa-Token进行权限验证](https://blog.csdn.net/lp840312696/article/details/127072424)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [探索 Sa-Token (一) SpringBoot 集成 Sa-Token](https://blog.csdn.net/weixin_38982591/article/details/126764928)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值