lsm/sa-token
1
0
Fork 0
mirror of https://gitee.com/dromara/sa-token.git synced 2025-09-19 10:08:07 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

升级Jboot版本到3.14.2，使用jBoot框架默认的缓存存取token的方法

Browse Source
This commit is contained in:
星痕
2022-03-21 14:13:12 +08:00
parent 81daf2c300
commit 914d9c4d1e
7 changed files with 128 additions and 740 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sa-token-starter/sa-token-jboot-plugin/pom.xml
View File

@@ -22,7 +22,7 @@
<dependency>
<groupId>io.jboot</groupId>
<artifactId>jboot</artifactId>
<version>3.11.4</version>
<version>3.14.2</version>
<scope>provided</scope>
</dependency>
<dependency>

460
sa-token-starter/sa-token-jboot-plugin/src/main/java/cn/dev33/satoken/jboot/SaJedisImpl.java
View File

@@ -1,460 +0,0 @@
package cn.dev33.satoken.jboot;
import cn.dev33.satoken.util.SaFoxUtil;
import com.jfinal.log.Log;
import io.jboot.Jboot;
import io.jboot.components.serializer.JbootSerializer;
import io.jboot.components.serializer.JbootSerializerManager;
import io.jboot.exception.JbootIllegalConfigException;
import io.jboot.utils.StrUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class SaJedisImpl {
private final JbootSerializer serializer;
protected JedisPool jedisPool;
@SuppressWarnings("unused")
private static final Log LOG = Log.getLog(SaJedisImpl.class);
private final SaRedisConfig config;
public SaJedisImpl(SaRedisConfig config) {
if (config == null || StrUtil.isBlank(config.getSerializer())) {
serializer = Jboot.getSerializer();
} else {
serializer = JbootSerializerManager.me().getSerializer(config.getSerializer());
}
this.config = config;
assert this.config != null;
String host = this.config.getHost();
Integer port = this.config.getPort();
Integer timeout = this.config.getTimeout();
String password = this.config.getPassword();
Integer database = this.config.getSaDb()==null?this.config.getDatabase():this.config.getSaDb();
String clientName = this.config.getClientName();
if (host.contains(":")) {
port = Integer.valueOf(host.split(":")[1]);
}
JedisPoolConfig poolConfig = new JedisPoolConfig();
if (StrUtil.isNotBlank(config.getTestWhileIdle())) {
poolConfig.setTestWhileIdle(config.getTestWhileIdle());
}
if (StrUtil.isNotBlank(config.getTestOnBorrow())) {
poolConfig.setTestOnBorrow(config.getTestOnBorrow());
}
if (StrUtil.isNotBlank(config.getTestOnCreate())) {
poolConfig.setTestOnCreate(config.getTestOnCreate());
}
if (StrUtil.isNotBlank(config.getTestOnReturn())) {
poolConfig.setTestOnReturn(config.getTestOnReturn());
}
if (StrUtil.isNotBlank(config.getMinEvictableIdleTimeMillis())) {
poolConfig.setMinEvictableIdleTime(Duration.ofMillis(config.getMinEvictableIdleTimeMillis()));
}
if (StrUtil.isNotBlank(config.getTimeBetweenEvictionRunsMillis())) {
poolConfig.setSoftMinEvictableIdleTime(Duration.ofMillis(config.getTimeBetweenEvictionRunsMillis()));
}
if (StrUtil.isNotBlank(config.getNumTestsPerEvictionRun())) {
poolConfig.setNumTestsPerEvictionRun(config.getNumTestsPerEvictionRun());
}
if (StrUtil.isNotBlank(config.getMaxTotal())) {
poolConfig.setMaxTotal(config.getMaxTotal());
}
if (StrUtil.isNotBlank(config.getMaxIdle())) {
poolConfig.setMaxIdle(config.getMaxIdle());
}
if (StrUtil.isNotBlank(config.getMinIdle())) {
poolConfig.setMinIdle(config.getMinIdle());
}
if (StrUtil.isNotBlank(config.getMaxWaitMillis())) {
poolConfig.setMaxWaitMillis(config.getMaxWaitMillis());
}
this.jedisPool = new JedisPool(poolConfig, host, port, timeout, timeout, password, database, clientName);
}
/**
* 获取Value，如无返空
* @param key
* @return
*/
public String get(String key){
Jedis jedis = getJedis();
try{
return jedis.get(key);
}finally {
returnResource(jedis);
}
}
/**
* 写入Value
* @param key
* @param value
*/
public void set(String key, String value) {
Jedis jedis = getJedis();
try{
jedis.set(key, value);
}finally {
returnResource(jedis);
}
}
/**
* 写入Value，并设定存活时间 (单位: 秒)
* @param key
* @param value
* @param timeout
*/
public void setex(String key, String value, long timeout){
Jedis jedis = getJedis();
try{
jedis.setex(key,timeout,value);
}finally {
returnResource(jedis);
}
}
/**
* 删除Value
* @param key
*/
public void del(String key) {
Jedis jedis = getJedis();
try{
jedis.del(key);
}finally {
returnResource(jedis);
}
}
/**
* 获取Value的剩余存活时间 (单位: 秒)
* @param key
* @return
*/
public long ttl(String key) {
Jedis jedis = getJedis();
try{
return jedis.ttl(key);
}finally {
returnResource(jedis);
}
}
public void expire(String key,long timeout){
Jedis jedis = getJedis();
try {
jedis.expire(key,timeout);
} finally {
returnResource(jedis);
}
}
/**
* 获取Object，如无返空
* @param key
* @return
*/
public Object getObject(String key) {
Jedis jedis = getJedis();
try {
return valueFromBytes(jedis.get(keyToBytes(key)));
} finally {
returnResource(jedis);
}
}
/**
* 写入Object
* @param key
* @param value
*/
public void setObject(Object key, Object value) {
Jedis jedis = getJedis();
try {
jedis.set(keyToBytes(key), valueToBytes(value));
} finally {
returnResource(jedis);
}
}
/**
* 写入Object，并设定存活时间 (单位: 秒)
* @param key
* @param object
* @param timeout
*/
public void setexObject(String key, Object object,long timeout) {
Jedis jedis = getJedis();
try {
jedis.setex(keyToBytes(key),timeout, valueToBytes(object));
} finally {
returnResource(jedis);
}
}
/**
* 删除Object
* @param key
*/
public void deleteObject(String key) {
Jedis jedis = getJedis();
try {
jedis.del(keyToBytes(key));
} finally {
returnResource(jedis);
}
}
public long getObjectTimeout(String key) {
Jedis jedis = getJedis();
try {
return getJedis().ttl(keyToBytes(key));
} finally {
returnResource(jedis);
}
}
/**
* 修改Object的剩余存活时间 (单位: 秒)
* @param key
* @param timeout
*/
public void expireObject(String key, long timeout) {
Jedis jedis = getJedis();
try {
jedis.expire(keyToBytes(key), timeout);
}
finally {
returnResource(jedis);
}
}
/**
* 查找所有符合给定模式 pattern 的 key 。
* KEYS * 匹配数据库中所有 key 。
* KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
* KEYS h*llo 匹配 hllo 和 heeeeello 等。
* KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
* 特殊符号用 \ 隔开
*/
public Set<String> keys(String pattern) {
Jedis jedis = getJedis();
try {
return jedis.keys(pattern);
} finally {
returnResource(jedis);
}
}
/**
* 将哈希表 key 中的域 field 的值设为 value 。
* 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
* 如果域 field 已经存在于哈希表中，旧值将被覆盖。
*/
public Long hset(String key, String field, String value) {
Jedis jedis = getJedis();
try {
return jedis.hset(key, field, value);
} finally {
returnResource(jedis);
}
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。
* 此命令会覆盖哈希表中已存在的域。
* 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
*/
public String hmset(String key, Map<String, String> hash) {
Jedis jedis = getJedis();
try {
return jedis.hmset(key,hash);
} finally {
returnResource(jedis);
}
}
/**
* 返回哈希表 key 中给定域 field 的值。
* @param key
* @param field
* @return
*/
public String hget(String key,String field){
Jedis jedis = getJedis();
try {
return jedis.hget(key,field);
} finally {
returnResource(jedis);
}
}
/**
* 返回哈希表 key 中，一个或多个给定域的值。
* 如果给定的域不存在于哈希表，那么返回一个 nil 值。
* 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
*/
public List<String> hmget(String key, String... fields) {
Jedis jedis = getJedis();
try {
return jedis.hmget(key,fields);
} finally {
returnResource(jedis);
}
}
/**
* 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
* @param key
* @param fields
* @return
*/
public Long hdel(String key, String... fields) {
Jedis jedis = getJedis();
try {
return jedis.hdel(key,fields);
} finally {
returnResource(jedis);
}
}
/**
* 查看哈希表 key 中，给定域 field 是否存在。
* @param key
* @param field
* @return
*/
public boolean hexists(String key, String field){
Jedis jedis = getJedis();
try {
return jedis.hexists(key,field);
} finally {
returnResource(jedis);
}
}
/**
* 返回哈希表 key 中，所有的域和值。
* 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
*/
public Map<String, String> hgetAll(String key) {
Jedis jedis = getJedis();
try {
return jedis.hgetAll(key);
} finally {
returnResource(jedis);
}
}
/**
* 返回哈希表 key 中所有域的值。
* @param key
* @return
*/
public List<String> hvals(String key) {
Jedis jedis = getJedis();
try {
return jedis.hvals(key);
} finally {
returnResource(jedis);
}
}
/**
* 返回哈希表 key 中的所有域。
* @param key
* @return
*/
public Set<String> hkeys(String key){
Jedis jedis = getJedis();
try {
return jedis.hkeys(key);
} finally {
returnResource(jedis);
}
}
/**
* 返回哈希表 key 中域的数量。
* @param key
* @return
*/
public Long hlen(String key){
Jedis jedis = getJedis();
try {
return jedis.hlen(key);
} finally {
returnResource(jedis);
}
}
public Jedis getJedis() {
try {
return jedisPool.getResource();
} catch (JedisConnectionException e) {
throw new JbootIllegalConfigException("can not connect to redis host " + config.getHost() + ":" + config.getPort() + " ," +
" cause : " + e.toString(), e);
}
}
public void returnResource(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
public byte[] keyToBytes(Object key) {
return key.toString().getBytes();
}
public String bytesToKey(byte[] bytes) {
return new String(bytes);
}
public byte[] valueToBytes(Object value) {
return serializer.serialize(value);
}
public Object valueFromBytes(byte[] bytes) {
if (bytes == null || bytes.length == 0) {
return null;
}
return serializer.deserialize(bytes);
}
/**
* 搜索数据
* @param prefix
* @param keyword
* @param start
* @param size
* @return
*/
public List<String> searchData(String prefix, String keyword, int start, int size) {
Set<String> keys = getJedis().keys(prefix + "*" + keyword + "*");
List<String> list = new ArrayList<String>(keys);
return SaFoxUtil.searchList(list, start, size);
}
}

27
sa-token-starter/sa-token-jboot-plugin/src/main/java/cn/dev33/satoken/jboot/SaRedisConfig.java
View File

@@ -1,27 +0,0 @@
package cn.dev33.satoken.jboot;
import io.jboot.app.config.annotation.ConfigModel;
import io.jboot.support.redis.JbootRedisConfig;
/**
* SA-Token redis缓存配置,获取database
*/
@ConfigModel(
prefix = "jboot.redis"
)
public class SaRedisConfig extends JbootRedisConfig{
private Integer saDb;
public SaRedisConfig(){
}
public Integer getSaDb() {
return this.saDb;
}
public void setSaDb(Integer saDb) {
this.saDb = saDb;
}
}

38
sa-token-starter/sa-token-jboot-plugin/src/main/java/cn/dev33/satoken/jboot/SaRedisManager.java
View File

@@ -1,38 +0,0 @@
package cn.dev33.satoken.jboot;
import io.jboot.Jboot;
public class SaRedisManager {
private static SaRedisManager manager = new SaRedisManager();
private SaRedisManager() {
}
public static SaRedisManager me() {
return manager;
}
private SaJedisImpl redis;
public SaJedisImpl getRedis() {
if (redis == null) {
SaRedisConfig config = Jboot.config(SaRedisConfig.class);
redis = getRedis(config);
}
return redis;
}
public SaJedisImpl getRedis(SaRedisConfig config) {
if (config == null || !config.isConfigOk()) {
return null;
}
return getJedisClient(config);
}
private SaJedisImpl getJedisClient(SaRedisConfig config) {
return new SaJedisImpl(config);
}
}

125
sa-token-starter/sa-token-jboot-plugin/src/main/java/cn/dev33/satoken/jboot/SaTokenCacheDao.java Normal file
View File

@@ -0,0 +1,125 @@
package cn.dev33.satoken.jboot;
import cn.dev33.satoken.dao.SaTokenDao;
import cn.dev33.satoken.session.SaSession;
import cn.dev33.satoken.util.SaFoxUtil;
import io.jboot.utils.CacheUtil;
import io.jboot.utils.StrUtil;
import java.util.List;
/**
* 使用jBoot的缓存方法存取Token数据
*/
public class SaTokenCacheDao implements SaTokenDao {
private final String cacheName;
/**
* 调用的Cache名称
*
* @param cacheName 使用的缓存配置名，默认为 default
*/
public SaTokenCacheDao(String cacheName) {
if (StrUtil.isBlank(cacheName)) {
cacheName = "default";
}
this.cacheName = cacheName;
}
@Override
public String get(String s) {
return CacheUtil.use(cacheName).get("SA", s);
}
@Override
public void set(String s, String s1, long l) {
CacheUtil.use(cacheName).put("SA", s, s1, Integer.parseInt(l + ""));
}
@Override
public void update(String s, String s1) {
CacheUtil.use(cacheName).put("SA", s, s1);
}
@Override
public void delete(String s) {
CacheUtil.use(cacheName).remove("SA", s);
}
@Override
public long getTimeout(String s) {
return CacheUtil.use(cacheName).getTtl("SA", s);
}
@Override
public void updateTimeout(String s, long l) {
CacheUtil.use(cacheName).setTtl("SA", s, Integer.parseInt(l + ""));
}
@Override
public Object getObject(String s) {
return CacheUtil.use(cacheName).get("SA", s);
}
@Override
public void setObject(String s, Object o, long l) {
CacheUtil.use(cacheName).put("SA", s, o, Integer.parseInt(l + ""));
}
@Override
public void updateObject(String s, Object o) {
CacheUtil.use(cacheName).put("SA", s, o);
}
@Override
public void deleteObject(String s) {
CacheUtil.use(cacheName).remove("SA", s);
}
@Override
public long getObjectTimeout(String s) {
return CacheUtil.use(cacheName).getTtl("SA", s);
}
@Override
public void updateObjectTimeout(String s, long l) {
CacheUtil.use(cacheName).setTtl("SA", s, Integer.parseInt(l + ""));
}
@Override
public SaSession getSession(String sessionId) {
return SaTokenDao.super.getSession(sessionId);
}
@Override
public void setSession(SaSession session, long timeout) {
SaTokenDao.super.setSession(session, timeout);
}
@Override
public void updateSession(SaSession session) {
SaTokenDao.super.updateSession(session);
}
@Override
public void deleteSession(String sessionId) {
SaTokenDao.super.deleteSession(sessionId);
}
@Override
public long getSessionTimeout(String sessionId) {
return SaTokenDao.super.getSessionTimeout(sessionId);
}
@Override
public void updateSessionTimeout(String sessionId, long timeout) {
SaTokenDao.super.updateSessionTimeout(sessionId, timeout);
}
@Override
public List<String> searchData(String prefix, String keyword, int start, int size) {
List<String> list = CacheUtil.use(cacheName).getKeys(prefix + "*" + keyword + "*");
return SaFoxUtil.searchList(list, start, size);
}
}

211
sa-token-starter/sa-token-jboot-plugin/src/main/java/cn/dev33/satoken/jboot/SaTokenDaoRedis.java
View File

@@ -1,211 +0,0 @@
package cn.dev33.satoken.jboot;
import cn.dev33.satoken.dao.SaTokenDao;
import cn.dev33.satoken.util.SaFoxUtil;
import io.jboot.Jboot;
import io.jboot.exception.JbootIllegalConfigException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class SaTokenDaoRedis implements SaTokenDao {
private SaJedisImpl redis;
/**
* 标记：是否已初始化成功
*/
public boolean isInit;
public SaTokenDaoRedis(){
SaRedisConfig redisConfig = Jboot.config(SaRedisConfig.class);
redisConfig.setSerializer("cn.dev33.satoken.jboot.SaJdkSerializer");
//优先使用 jboot.cache.redis 的配置
if (redisConfig.isConfigOk()) {
redis = SaRedisManager.me().getRedis(redisConfig);
}
if (redis == null) {
this.isInit = false;
throw new JbootIllegalConfigException("can not get redis, please check your jboot.properties , please correct config jboot.cache.redis.host or jboot.redis.host ");
}else{
this.isInit = true;
}
}
/**
* 获取Value，如无返空
* @param key
* @return
*/
@Override
public String get(String key) {
return redis.get(key);
}
/**
* 写入Value，并设定存活时间 (单位: 秒)
* @param key
* @param value
* @param timeout
*/
@Override
public void set(String key, String value, long timeout) {
if(timeout == 0 || timeout <= SaTokenDao.NOT_VALUE_EXPIRE) {
return;
}
if(timeout == SaTokenDao.NEVER_EXPIRE) {
redis.set(key, value);
}else{
redis.setex(key,value,timeout);
}
}
/**
* 修改指定key-value键值对 (过期时间不变)
* @param key
* @param value
*/
@Override
public void update(String key, String value) {
long expire = getTimeout(key);
// -2 = 无此键
if(expire == SaTokenDao.NOT_VALUE_EXPIRE) {
return;
}
this.set(key,value,expire);
}
/**
* 删除Value
* @param key
*/
@Override
public void delete(String key) {
redis.del(key);
}
/**
* 获取Value的剩余存活时间 (单位: 秒)
* @param key
* @return
*/
@Override
public long getTimeout(String key) {
return redis.ttl(key);
}
/**
* 修改Value的剩余存活时间 (单位: 秒)
* @param key
* @param timeout
*/
@Override
public void updateTimeout(String key, long timeout) {
//判断是否想要设置为永久
if(timeout == SaTokenDao.NEVER_EXPIRE) {
long expire = getTimeout(key);
if(expire == SaTokenDao.NEVER_EXPIRE) {
// 如果其已经被设置为永久，则不作任何处理
} else {
// 如果尚未被设置为永久，那么再次set一次
this.set(key, this.get(key), timeout);
}
return;
}
redis.expire(key,timeout);
}
/**
* 获取Object，如无返空
* @param key
* @return
*/
@Override
public Object getObject(String key) {
return redis.getObject(key);
}
/**
* 写入Object，并设定存活时间 (单位: 秒)
* @param key
* @param object
* @param timeout
*/
@Override
public void setObject(String key, Object object, long timeout) {
if(timeout == 0 || timeout <= SaTokenDao.NOT_VALUE_EXPIRE) {
return;
}
if(timeout == SaTokenDao.NEVER_EXPIRE) {
redis.setObject(key, object);
}else{
redis.setexObject(key,object,timeout);
}
}
/**
* 更新Object (过期时间不变)
* @param key
* @param object
*/
@Override
public void updateObject(String key, Object object) {
long expire = getObjectTimeout(key);
// -2 = 无此键
if(expire == SaTokenDao.NOT_VALUE_EXPIRE) {
return;
}
this.setObject(key, object, expire);
}
/**
* 删除Object
* @param key
*/
@Override
public void deleteObject(String key) {
redis.deleteObject(key);
}
@Override
public long getObjectTimeout(String key) {
return redis.getObjectTimeout(key);
}
/**
* 修改Object的剩余存活时间 (单位: 秒)
* @param key
* @param timeout
*/
@Override
public void updateObjectTimeout(String key, long timeout) {
//判断是否想要设置为永久
if(timeout == SaTokenDao.NEVER_EXPIRE) {
long expire = getTimeout(key);
if(expire == SaTokenDao.NEVER_EXPIRE) {
// 如果其已经被设置为永久，则不作任何处理
} else {
// 如果尚未被设置为永久，那么再次set一次
this.setObject(key, this.get(key), timeout);
}
return;
}
redis.expireObject(key,timeout);
}
/**
* 搜索数据
* @param prefix
* @param keyword
* @param start
* @param size
* @return
*/
@Override
public List<String> searchData(String prefix, String keyword, int start, int size) {
Set<String> keys = redis.keys(prefix + "*" + keyword + "*");
List<String> list = new ArrayList<String>(keys);
return SaFoxUtil.searchList(list, start, size);
}
}

5
sa-token-starter/sa-token-jboot-plugin/src/test/java/cn/dev33/satoken/jboot/test/AtteStartListener.java
View File

@@ -5,8 +5,8 @@ import cn.dev33.satoken.config.SaCookieConfig;
import cn.dev33.satoken.config.SaTokenConfig;
import cn.dev33.satoken.context.SaTokenContext;
import cn.dev33.satoken.jboot.SaAnnotationInterceptor;
import cn.dev33.satoken.jboot.SaTokenCacheDao;
import cn.dev33.satoken.jboot.SaTokenContextForJboot;
import cn.dev33.satoken.jboot.SaTokenDaoRedis;
import cn.dev33.satoken.util.SaTokenConsts;
import com.jfinal.config.Constants;
import com.jfinal.config.Interceptors;
@@ -29,7 +29,6 @@ public class AtteStartListener implements JbootAppListener {
saTokenConfig.setTokenName("token"); //更换satoken的名称
saTokenConfig.setCookie(new SaCookieConfig().setHttpOnly(true)); //开启cookies的httponly属性
SaManager.setConfig(saTokenConfig);
SaManager.setSaTokenDao(new SaTokenDaoRedis());
}
@Override
@@ -70,7 +69,7 @@ public class AtteStartListener implements JbootAppListener {
@Override
public void onStart() {
SaManager.setSaTokenDao(new SaTokenCacheDao(null));
}
@Override