fastjson升级 + 同步问题

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.fastjson2.JSON;
-import com.alibaba.fastjson.parser.ParserConfig;
+import com.alibaba.fastjson2.JSONReader;
-import com.alibaba.fastjson.serializer.SerializerFeature;
+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<T> implements RedisSerializer<T>
 
     private Class<T> clazz;
 
-    static
+    /**
-    {
+     * 仅允许业务包 AutoType，避免全局打开 AutoTypeSupport。
-        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
+     * 若 Redis 中还有其它包的 @type 对象，按需追加前缀。
-    }
+     */
+    private static final Filter AUTO_TYPE_FILTER = JSONReader.autoTypeFilter("com.zdxt.");
 
     public FastJson2JsonRedisSerializer(Class<T> clazz)
     {
@@ -44,7 +46,7 @@ public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
         {
             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<T> implements RedisSerializer<T>
         {
             return null;
         }
-        String str = new String(bytes, DEFAULT_CHARSET);
+        return JSON.parseObject(bytes, clazz, AUTO_TYPE_FILTER);
-
-        return JSON.parseObject(str, clazz);
     }
 
     public void setObjectMapper(ObjectMapper objectMapper)

lib/EmergencyBaseLib/pom.xml

@@ -32,7 +32,8 @@
         <swagger.version>3.0.0</swagger.version>
         <mybatis-spring-boot.version>2.1.4</mybatis-spring-boot.version>
         <pagehelper.boot.version>1.3.1</pagehelper.boot.version>
-        <fastjson.version>2.0.61</fastjson.version>
+        <!-- 升级至 Fastjson2 最新版（1.x 兼容包，内核为 fastjson2） -->
+        <fastjson.version>2.0.64</fastjson.version>
         <oshi.version>5.8.0</oshi.version>
         <jna.version>5.8.0</jna.version>
         <commons.io.version>2.11.0</commons.io.version>

lib/EmergencyService/pom.xml

@@ -35,7 +35,8 @@
         <thymeleaf.extras.shiro.version>2.1.0</thymeleaf.extras.shiro.version>
         <mybatis.spring.boot.starter.version>1.3.2</mybatis.spring.boot.starter.version>
         <pagehelper.spring.boot.starter.version>1.2.5</pagehelper.spring.boot.starter.version>
-        <fastjson.version>2.0.61</fastjson.version>
+        <!-- 升级至 Fastjson2 最新版（1.x 兼容包，内核为 fastjson2） -->
+        <fastjson.version>2.0.64</fastjson.version>
         <druid.version>1.1.14</druid.version>
         <commons.io.version>2.5</commons.io.version>
         <commons.fileupload.version>1.3.3</commons.fileupload.version>

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");
 

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);
+//        userRoleMapper.deleteUserRoleByUserId(userId);
-        // 新增用户与角色管理
+//        // 新增用户与角色管理
-        insertUserRole(user);
+//        insertUserRole(user);
-        // 删除用户与岗位关联
+//        // 删除用户与岗位关联
-        userPostMapper.deleteUserPostByUserId(userId);
+//        userPostMapper.deleteUserPostByUserId(userId);
-        // 新增用户与岗位管理
+//        // 新增用户与岗位管理
-        insertUserPost(user);
+//        insertUserPost(user);
         int resCount = userMapper.updateUser(user);
 
         return resCount;

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}
         })();

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}
     })();

lib/ZdxtComponent/pom.xml

@@ -49,11 +49,11 @@
             <version>1.0</version>
         </dependency>
 
-        <!-- fastjson -->
+        <!-- fastjson：升级至 Fastjson2 最新版（1.x 兼容包） -->
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>fastjson</artifactId>
-            <version>2.0.61</version>
+            <version>2.0.64</version>
         </dependency>
     </dependencies>
 

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 <K>
+ * @param <V>
+ */
+public class RedisCache<K, V> implements Cache<K, V> {
+
+	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<byte[]> 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<K> keys() {
+		Set<byte[]> 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<K> convertedKeys = new HashSet<K>();
+		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<V> values() {
+		Set<byte[]> 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<V> values = new ArrayList<V>(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;
+	}
+}

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<String, Cache> 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 <K, V> Cache<K, V> getCache(String name) throws CacheException {
+		logger.debug("get cache, name=" + name);
+
+		Cache<K, V> cache = caches.get(name);
+
+		if (cache == null) {
+			cache = new RedisCache<K, V>(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;
+	}
+}