From 369d1fff5d268159b90559cdfcd314b7fab48e39 Mon Sep 17 00:00:00 2001 From: shil <452061493@qq.com> Date: Fri, 7 Aug 2026 14:32:38 +0800 Subject: [PATCH] =?UTF-8?q?fastjson=E5=8D=87=E7=BA=A7=20+=20=E5=90=8C?= =?UTF-8?q?=E6=AD=A5=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config/FastJson2JsonRedisSerializer.java | 22 +- lib/EmergencyBaseLib/pom.xml | 3 +- lib/EmergencyService/pom.xml | 3 +- .../com/zdxt/app/task/SynUserInfoTask.java | 2 +- .../system/user/service/UserServiceImpl.java | 18 +- .../src/main/resources/templates/jump.html | 2 +- .../src/main/resources/templates/login.html | 2 +- lib/ZdxtComponent/pom.xml | 4 +- org/crazycake/shiro/RedisCache.java | 308 ++++++++++++++++++ org/crazycake/shiro/RedisCacheManager.java | 99 ++++++ 10 files changed, 436 insertions(+), 27 deletions(-) create mode 100644 org/crazycake/shiro/RedisCache.java create mode 100644 org/crazycake/shiro/RedisCacheManager.java diff --git a/lib/EmergencyBaseLib/EmergencyCommon/src/main/java/com/zdxt/common/config/FastJson2JsonRedisSerializer.java b/lib/EmergencyBaseLib/EmergencyCommon/src/main/java/com/zdxt/common/config/FastJson2JsonRedisSerializer.java index 284ce740..89a32505 100644 --- a/lib/EmergencyBaseLib/EmergencyCommon/src/main/java/com/zdxt/common/config/FastJson2JsonRedisSerializer.java +++ b/lib/EmergencyBaseLib/EmergencyCommon/src/main/java/com/zdxt/common/config/FastJson2JsonRedisSerializer.java @@ -1,8 +1,9 @@ package com.zdxt.common.config; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.parser.ParserConfig; -import com.alibaba.fastjson.serializer.SerializerFeature; +import com.alibaba.fastjson2.JSON; +import com.alibaba.fastjson2.JSONReader; +import com.alibaba.fastjson2.JSONWriter; +import com.alibaba.fastjson2.filter.Filter; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.type.TypeFactory; @@ -26,10 +27,11 @@ public class FastJson2JsonRedisSerializer implements RedisSerializer private Class clazz; - static - { - ParserConfig.getGlobalInstance().setAutoTypeSupport(true); - } + /** + * 仅允许业务包 AutoType，避免全局打开 AutoTypeSupport。 + * 若 Redis 中还有其它包的 @type 对象，按需追加前缀。 + */ + private static final Filter AUTO_TYPE_FILTER = JSONReader.autoTypeFilter("com.zdxt."); public FastJson2JsonRedisSerializer(Class clazz) { @@ -44,7 +46,7 @@ public class FastJson2JsonRedisSerializer implements RedisSerializer { return new byte[0]; } - return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET); + return JSON.toJSONBytes(t, JSONWriter.Feature.WriteClassName); } @Override @@ -54,9 +56,7 @@ public class FastJson2JsonRedisSerializer implements RedisSerializer { return null; } - String str = new String(bytes, DEFAULT_CHARSET); - - return JSON.parseObject(str, clazz); + return JSON.parseObject(bytes, clazz, AUTO_TYPE_FILTER); } public void setObjectMapper(ObjectMapper objectMapper) diff --git a/lib/EmergencyBaseLib/pom.xml b/lib/EmergencyBaseLib/pom.xml index 3c196e00..bf4edc2e 100644 --- a/lib/EmergencyBaseLib/pom.xml +++ b/lib/EmergencyBaseLib/pom.xml @@ -32,7 +32,8 @@ 3.0.0 2.1.4 1.3.1 - 2.0.61 + + 2.0.64 5.8.0 5.8.0 2.11.0 diff --git a/lib/EmergencyService/pom.xml b/lib/EmergencyService/pom.xml index 6449363e..819905d9 100644 --- a/lib/EmergencyService/pom.xml +++ b/lib/EmergencyService/pom.xml @@ -35,7 +35,8 @@ 2.1.0 1.3.2 1.2.5 - 2.0.61 + + 2.0.64 1.1.14 2.5 1.3.3 diff --git a/lib/EmergencyService/zdxtEmergencyAppService/src/main/java/com/zdxt/app/task/SynUserInfoTask.java b/lib/EmergencyService/zdxtEmergencyAppService/src/main/java/com/zdxt/app/task/SynUserInfoTask.java index 20109fd3..0331d505 100644 --- a/lib/EmergencyService/zdxtEmergencyAppService/src/main/java/com/zdxt/app/task/SynUserInfoTask.java +++ b/lib/EmergencyService/zdxtEmergencyAppService/src/main/java/com/zdxt/app/task/SynUserInfoTask.java @@ -132,7 +132,7 @@ public class SynUserInfoTask { // } // user.setUnits(units); - user.randomSalt(); +// user.randomSalt(); //新增用户默认不删除标记 user.setDelFlag("0"); diff --git a/lib/EmergencyService/zdxtEmergencyAuthService/src/main/java/com/zdxt/auth/project/system/user/service/UserServiceImpl.java b/lib/EmergencyService/zdxtEmergencyAuthService/src/main/java/com/zdxt/auth/project/system/user/service/UserServiceImpl.java index 87e40822..41c21f38 100644 --- a/lib/EmergencyService/zdxtEmergencyAuthService/src/main/java/com/zdxt/auth/project/system/user/service/UserServiceImpl.java +++ b/lib/EmergencyService/zdxtEmergencyAuthService/src/main/java/com/zdxt/auth/project/system/user/service/UserServiceImpl.java @@ -346,16 +346,16 @@ public class UserServiceImpl implements IUserService { @Override @Transactional public int updateUser(User user) { - Long userId = user.getUserId(); +// Long userId = user.getUserId(); // user.setUpdateBy(ShiroUtils.getLoginName()); - // 删除用户与角色关联 - userRoleMapper.deleteUserRoleByUserId(userId); - // 新增用户与角色管理 - insertUserRole(user); - // 删除用户与岗位关联 - userPostMapper.deleteUserPostByUserId(userId); - // 新增用户与岗位管理 - insertUserPost(user); +// // 删除用户与角色关联 +// userRoleMapper.deleteUserRoleByUserId(userId); +// // 新增用户与角色管理 +// insertUserRole(user); +// // 删除用户与岗位关联 +// userPostMapper.deleteUserPostByUserId(userId); +// // 新增用户与岗位管理 +// insertUserPost(user); int resCount = userMapper.updateUser(user); return resCount; diff --git a/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/jump.html b/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/jump.html index 4607f060..e02dd2f7 100644 --- a/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/jump.html +++ b/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/jump.html @@ -24,7 +24,7 @@ (function(){ var now = new Date(); var start = new Date('2026-06-19'); - var end = new Date('2026-09-01'); + var end = new Date('2026-12-01'); var inAllowedPeriod = (now >= start && now <= end); if(!inAllowedPeriod && window.top!==window.self){window.top.location=window.location} })(); diff --git a/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/login.html b/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/login.html index 7a627ef6..e48455a7 100644 --- a/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/login.html +++ b/lib/EmergencyService/zdxtEmergencyBootStart/src/main/resources/templates/login.html @@ -206,7 +206,7 @@ (function(){ var now = new Date(); var start = new Date('2026-06-19'); - var end = new Date('2026-09-01'); + var end = new Date('2026-12-01'); var inAllowedPeriod = (now >= start && now <= end); if(!inAllowedPeriod && window.top!==window.self){window.top.location=window.location} })(); diff --git a/lib/ZdxtComponent/pom.xml b/lib/ZdxtComponent/pom.xml index 89f9e6a4..842abbfd 100644 --- a/lib/ZdxtComponent/pom.xml +++ b/lib/ZdxtComponent/pom.xml @@ -49,11 +49,11 @@ 1.0 - + com.alibaba fastjson - 2.0.61 + 2.0.64 diff --git a/org/crazycake/shiro/RedisCache.java b/org/crazycake/shiro/RedisCache.java new file mode 100644 index 00000000..1220167a --- /dev/null +++ b/org/crazycake/shiro/RedisCache.java @@ -0,0 +1,308 @@ +package org.crazycake.shiro; + +import org.apache.shiro.cache.Cache; +import org.apache.shiro.cache.CacheException; +import org.apache.shiro.subject.PrincipalCollection; +import org.apache.shiro.util.CollectionUtils; +import org.crazycake.shiro.exception.CacheManagerPrincipalIdNotAssignedException; +import org.crazycake.shiro.exception.PrincipalIdNullException; +import org.crazycake.shiro.exception.PrincipalInstanceException; +import org.crazycake.shiro.exception.SerializationException; +import org.crazycake.shiro.serializer.RedisSerializer; +import org.crazycake.shiro.serializer.StringSerializer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.*; + +/** + * Used for setting/getting authorization information from Redis + * @param + * @param + */ +public class RedisCache implements Cache { + + private static Logger logger = LoggerFactory.getLogger(RedisCache.class); + + private RedisSerializer keySerializer; + private RedisSerializer valueSerializer; + private IRedisManager redisManager; + private String keyPrefix = RedisCacheManager.DEFAULT_CACHE_KEY_PREFIX; + private int expire; + private String principalIdFieldName = RedisCacheManager.DEFAULT_PRINCIPAL_ID_FIELD_NAME; + + /** + * + * @param redisManager redisManager + * @param keySerializer keySerializer + * @param valueSerializer valueSerializer + * @param prefix authorization prefix + * @param expire expire + * @param principalIdFieldName id field name of principal object + */ + public RedisCache(IRedisManager redisManager, RedisSerializer keySerializer, RedisSerializer valueSerializer, String prefix, int expire, String principalIdFieldName) { + if (redisManager == null) { + throw new IllegalArgumentException("redisManager cannot be null."); + } + this.redisManager = redisManager; + if (keySerializer == null) { + throw new IllegalArgumentException("keySerializer cannot be null."); + } + this.keySerializer = keySerializer; + if (valueSerializer == null) { + throw new IllegalArgumentException("valueSerializer cannot be null."); + } + this.valueSerializer = valueSerializer; + if (prefix != null && !"".equals(prefix)) { + this.keyPrefix = prefix; + } + this.expire = expire; + if (principalIdFieldName != null) { + this.principalIdFieldName = principalIdFieldName; + } + } + + /** + * get shiro authorization redis key-value + * @param key key + * @return value + * @throws CacheException get cache exception + */ + @Override + public V get(K key) throws CacheException { + logger.debug("get key [" + key + "]"); + + if (key == null) { + return null; + } + + try { + Object redisCacheKey = getRedisCacheKey(key); + byte[] rawValue = redisManager.get(keySerializer.serialize(redisCacheKey)); + if (rawValue == null) { + return null; + } + V value = (V) valueSerializer.deserialize(rawValue); + return value; + } catch (SerializationException e) { + throw new CacheException(e); + } + } + + @Override + public V put(K key, V value) throws CacheException { + if (key == null) { + logger.warn("Saving a null key is meaningless, return value directly without call Redis."); + return value; + } + try { + Object redisCacheKey = getRedisCacheKey(key); + logger.debug("put key [" + redisCacheKey + "]"); + redisManager.set(keySerializer.serialize(redisCacheKey), value != null ? valueSerializer.serialize(value) : null, expire); + return value; + } catch (SerializationException e) { + throw new CacheException(e); + } + } + + @Override + public V remove(K key) throws CacheException { + logger.debug("remove key [" + key + "]"); + if (key == null) { + return null; + } + try { + Object redisCacheKey = getRedisCacheKey(key); + byte[] rawValue = redisManager.get(keySerializer.serialize(redisCacheKey)); + V previous = (V) valueSerializer.deserialize(rawValue); + redisManager.del(keySerializer.serialize(redisCacheKey)); + return previous; + } catch (SerializationException e) { + throw new CacheException(e); + } + } + + /** + * get the full Redis key including prefix by Redis key + * @param key + * @return + */ + private Object getRedisCacheKey(K key) { + if (key == null) { + return null; + } + if (keySerializer instanceof StringSerializer) { + return this.keyPrefix + getStringRedisKey(key); + } + return key; + } + + /** + * get Redis key (not including prefix) + * @param key + * @return + */ + private String getStringRedisKey(K key) { + String redisKey; + if (key instanceof PrincipalCollection) { + redisKey = getRedisKeyFromPrincipalIdField((PrincipalCollection) key); + } else { + redisKey = key.toString(); + } + return redisKey; + } + + /** + * get the Redis key (not including prefix) by PrincipalCollection + * @param key + * @return + */ + private String getRedisKeyFromPrincipalIdField(PrincipalCollection key) { + Object principalObject = key.getPrimaryPrincipal(); + if (principalObject instanceof String) { + return principalObject.toString(); + } + Method pincipalIdGetter = getPrincipalIdGetter(principalObject); + return getIdObj(principalObject, pincipalIdGetter); + } + + private String getIdObj(Object principalObject, Method pincipalIdGetter) { + String redisKey; + try { + Object idObj = pincipalIdGetter.invoke(principalObject); + if (idObj == null) { + throw new PrincipalIdNullException(principalObject.getClass(), this.principalIdFieldName); + } + redisKey = idObj.toString(); + } catch (IllegalAccessException e) { + throw new PrincipalInstanceException(principalObject.getClass(), this.principalIdFieldName, e); + } catch (InvocationTargetException e) { + throw new PrincipalInstanceException(principalObject.getClass(), this.principalIdFieldName, e); + } + return redisKey; + } + + private Method getPrincipalIdGetter(Object principalObject) { + Method pincipalIdGetter = null; + String principalIdMethodName = this.getPrincipalIdMethodName(); + try { + pincipalIdGetter = principalObject.getClass().getMethod(principalIdMethodName); + } catch (NoSuchMethodException e) { + throw new PrincipalInstanceException(principalObject.getClass(), this.principalIdFieldName); + } + return pincipalIdGetter; + } + + private String getPrincipalIdMethodName() { + if (this.principalIdFieldName == null || "".equals(this.principalIdFieldName)) { + throw new CacheManagerPrincipalIdNotAssignedException(); + } + return "get" + this.principalIdFieldName.substring(0, 1).toUpperCase() + this.principalIdFieldName.substring(1); + } + + + @Override + public void clear() throws CacheException { + logger.debug("clear cache"); + Set keys = null; + try { + keys = redisManager.keys(keySerializer.serialize(this.keyPrefix + "*")); + } catch (SerializationException e) { + logger.error("get keys error", e); + } + if (keys == null || keys.size() == 0) { + return; + } + for (byte[] key: keys) { + redisManager.del(key); + } + } + + /** + * get all authorization key-value quantity + * @return key-value size + */ + @Override + public int size() { + Long longSize = 0L; + try { + longSize = new Long(redisManager.dbSize(keySerializer.serialize(this.keyPrefix + "*"))); + } catch (SerializationException e) { + logger.error("get keys error", e); + } + return longSize.intValue(); + } + + @SuppressWarnings("unchecked") + @Override + public Set keys() { + Set keys = null; + try { + keys = redisManager.keys(keySerializer.serialize(this.keyPrefix + "*")); + } catch (SerializationException e) { + logger.error("get keys error", e); + return Collections.emptySet(); + } + + if (CollectionUtils.isEmpty(keys)) { + return Collections.emptySet(); + } + + Set convertedKeys = new HashSet(); + for (byte[] key:keys) { + try { + convertedKeys.add((K) keySerializer.deserialize(key)); + } catch (SerializationException e) { + logger.error("deserialize keys error", e); + } + } + return convertedKeys; + } + + @Override + public Collection values() { + Set keys = null; + try { + keys = redisManager.keys(keySerializer.serialize(this.keyPrefix + "*")); + } catch (SerializationException e) { + logger.error("get values error", e); + return Collections.emptySet(); + } + + if (CollectionUtils.isEmpty(keys)) { + return Collections.emptySet(); + } + + List values = new ArrayList(keys.size()); + for (byte[] key : keys) { + V value = null; + try { + value = (V) valueSerializer.deserialize(redisManager.get(key)); + } catch (SerializationException e) { + logger.error("deserialize values= error", e); + } + if (value != null) { + values.add(value); + } + } + return Collections.unmodifiableList(values); + } + + public String getKeyPrefix() { + return keyPrefix; + } + + public void setKeyPrefix(String keyPrefix) { + this.keyPrefix = keyPrefix; + } + + public String getPrincipalIdFieldName() { + return principalIdFieldName; + } + + public void setPrincipalIdFieldName(String principalIdFieldName) { + this.principalIdFieldName = principalIdFieldName; + } +} diff --git a/org/crazycake/shiro/RedisCacheManager.java b/org/crazycake/shiro/RedisCacheManager.java new file mode 100644 index 00000000..b172d535 --- /dev/null +++ b/org/crazycake/shiro/RedisCacheManager.java @@ -0,0 +1,99 @@ +package org.crazycake.shiro; + +import org.apache.shiro.cache.Cache; +import org.apache.shiro.cache.CacheException; +import org.apache.shiro.cache.CacheManager; +import org.crazycake.shiro.serializer.ObjectSerializer; +import org.crazycake.shiro.serializer.RedisSerializer; +import org.crazycake.shiro.serializer.StringSerializer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +public class RedisCacheManager implements CacheManager { + + private final Logger logger = LoggerFactory.getLogger(RedisCacheManager.class); + + // fast lookup by name map + private final ConcurrentMap caches = new ConcurrentHashMap<>(); + private RedisSerializer keySerializer = new StringSerializer(); + private RedisSerializer valueSerializer = new ObjectSerializer(); + + private IRedisManager redisManager; + + // expire time in seconds + public static final int DEFAULT_EXPIRE = 1800; + private int expire = DEFAULT_EXPIRE; + + /** + * The Redis key prefix for caches + */ + public static final String DEFAULT_CACHE_KEY_PREFIX = "shiro:cache:"; + private String keyPrefix = DEFAULT_CACHE_KEY_PREFIX; + + public static final String DEFAULT_PRINCIPAL_ID_FIELD_NAME = "id"; + private String principalIdFieldName = DEFAULT_PRINCIPAL_ID_FIELD_NAME; + + @Override + public Cache getCache(String name) throws CacheException { + logger.debug("get cache, name=" + name); + + Cache cache = caches.get(name); + + if (cache == null) { + cache = new RedisCache(redisManager, keySerializer, valueSerializer, keyPrefix + name + ":", expire, principalIdFieldName); + caches.put(name, cache); + } + return cache; + } + + public IRedisManager getRedisManager() { + return redisManager; + } + + public void setRedisManager(IRedisManager redisManager) { + this.redisManager = redisManager; + } + + public String getKeyPrefix() { + return keyPrefix; + } + + public void setKeyPrefix(String keyPrefix) { + this.keyPrefix = keyPrefix; + } + + public RedisSerializer getKeySerializer() { + return keySerializer; + } + + public void setKeySerializer(RedisSerializer keySerializer) { + this.keySerializer = keySerializer; + } + + public RedisSerializer getValueSerializer() { + return valueSerializer; + } + + public void setValueSerializer(RedisSerializer valueSerializer) { + this.valueSerializer = valueSerializer; + } + + public int getExpire() { + return expire; + } + + public void setExpire(int expire) { + this.expire = expire; + } + + public String getPrincipalIdFieldName() { + return principalIdFieldName; + } + + public void setPrincipalIdFieldName(String principalIdFieldName) { + this.principalIdFieldName = principalIdFieldName; + } +}