From d2a60136caac7dc209c220daeddbe408c641d0ee Mon Sep 17 00:00:00 2001 From: htjcAdmin Date: Mon, 7 Jul 2025 14:10:13 +0800 Subject: [PATCH] =?UTF-8?q?/*=E5=A2=9E=E5=8A=A0redis=E6=A8=A1=E5=9D=97*/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../service/impl/AlgorithmServiceImpl.java | 4 + .../redis/FastJson2JsonRedisSerializer.java | 49 +++++++ .../simulator/utils/redis/RedisConfig.java | 44 ++++++ .../simulator/utils/redis/RedisService.java | 136 ++++++++++++++++++ 4 files changed, 233 insertions(+) create mode 100644 src/main/java/com/inspect/simulator/utils/redis/FastJson2JsonRedisSerializer.java create mode 100644 src/main/java/com/inspect/simulator/utils/redis/RedisConfig.java create mode 100644 src/main/java/com/inspect/simulator/utils/redis/RedisService.java diff --git a/src/main/java/com/inspect/simulator/service/impl/AlgorithmServiceImpl.java b/src/main/java/com/inspect/simulator/service/impl/AlgorithmServiceImpl.java index 3fe7b03..5ddc2ff 100644 --- a/src/main/java/com/inspect/simulator/service/impl/AlgorithmServiceImpl.java +++ b/src/main/java/com/inspect/simulator/service/impl/AlgorithmServiceImpl.java @@ -19,6 +19,7 @@ import com.inspect.simulator.mapper.PatrolPresetPosMapper; import com.inspect.simulator.service.AlgorithmService; import com.inspect.simulator.service.remote.AnalysisRemoteService; import com.inspect.simulator.utils.HttpClientUtils; +import com.inspect.simulator.utils.redis.RedisService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; @@ -52,6 +53,9 @@ public class AlgorithmServiceImpl implements AlgorithmService { @Resource private HikVisionServiceImpl hikVisionService; + @Resource + private RedisService redisService; + @Override public String filterPicAnalyse(String analyseRequestStr) { log.info(Color.MAGENTA + "[FILTER] filterPicAnalyse: analyseRequestStr={}" + Color.END, analyseRequestStr); diff --git a/src/main/java/com/inspect/simulator/utils/redis/FastJson2JsonRedisSerializer.java b/src/main/java/com/inspect/simulator/utils/redis/FastJson2JsonRedisSerializer.java new file mode 100644 index 0000000..93656aa --- /dev/null +++ b/src/main/java/com/inspect/simulator/utils/redis/FastJson2JsonRedisSerializer.java @@ -0,0 +1,49 @@ +package com.inspect.simulator.utils.redis; + +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.parser.ParserConfig; +import com.alibaba.fastjson.serializer.SerializerFeature; +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.type.TypeFactory; +import org.springframework.data.redis.serializer.RedisSerializer; +import org.springframework.data.redis.serializer.SerializationException; +import org.springframework.util.Assert; + +import java.nio.charset.Charset; + +public class FastJson2JsonRedisSerializer implements RedisSerializer { + private ObjectMapper objectMapper = new ObjectMapper(); + public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8"); + private Class clazz; + + public FastJson2JsonRedisSerializer(Class clazz) { + this.clazz = clazz; + } + + public byte[] serialize(T t) throws SerializationException { + return t == null?new byte[0]:JSON.toJSONString(t, new SerializerFeature[]{SerializerFeature.WriteClassName}).getBytes(DEFAULT_CHARSET); + } + + public T deserialize(byte[] bytes) throws SerializationException { + if(bytes != null && bytes.length > 0) { + String str = new String(bytes, DEFAULT_CHARSET); + return JSON.parseObject(str, this.clazz); + } else { + return null; + } + } + + public void setObjectMapper(ObjectMapper objectMapper) { + Assert.notNull(objectMapper, "'objectMapper' must not be null"); + this.objectMapper = objectMapper; + } + + protected JavaType getJavaType(Class clazz) { + return TypeFactory.defaultInstance().constructType(clazz); + } + + static { + ParserConfig.getGlobalInstance().setAutoTypeSupport(true); + } +} diff --git a/src/main/java/com/inspect/simulator/utils/redis/RedisConfig.java b/src/main/java/com/inspect/simulator/utils/redis/RedisConfig.java new file mode 100644 index 0000000..691e133 --- /dev/null +++ b/src/main/java/com/inspect/simulator/utils/redis/RedisConfig.java @@ -0,0 +1,44 @@ +package com.inspect.simulator.utils.redis; + +import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility; +import com.fasterxml.jackson.annotation.JsonTypeInfo.As; +import com.fasterxml.jackson.annotation.PropertyAccessor; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping; +import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator; +import org.springframework.cache.annotation.CachingConfigurerSupport; +import org.springframework.cache.annotation.EnableCaching; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.data.redis.connection.RedisConnectionFactory; +import org.springframework.data.redis.core.RedisTemplate; +import org.springframework.data.redis.listener.RedisMessageListenerContainer; +import org.springframework.data.redis.serializer.StringRedisSerializer; + +@Configuration +@EnableCaching +public class RedisConfig extends CachingConfigurerSupport { + @Bean + public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) { + RedisTemplate template = new RedisTemplate(); + template.setConnectionFactory(connectionFactory); + FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class); + ObjectMapper mapper = new ObjectMapper(); + mapper.setVisibility(PropertyAccessor.ALL, Visibility.ANY); + mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, DefaultTyping.NON_FINAL, As.PROPERTY); + serializer.setObjectMapper(mapper); + template.setKeySerializer(new StringRedisSerializer()); + template.setValueSerializer(serializer); + template.setHashKeySerializer(new StringRedisSerializer()); + template.setHashValueSerializer(serializer); + template.afterPropertiesSet(); + return template; + } + + @Bean + RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) { + RedisMessageListenerContainer container = new RedisMessageListenerContainer(); + container.setConnectionFactory(connectionFactory); + return container; + } +} diff --git a/src/main/java/com/inspect/simulator/utils/redis/RedisService.java b/src/main/java/com/inspect/simulator/utils/redis/RedisService.java new file mode 100644 index 0000000..9322490 --- /dev/null +++ b/src/main/java/com/inspect/simulator/utils/redis/RedisService.java @@ -0,0 +1,136 @@ +package com.inspect.simulator.utils.redis; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.data.redis.core.BoundSetOperations; +import org.springframework.data.redis.core.HashOperations; +import org.springframework.data.redis.core.RedisTemplate; +import org.springframework.data.redis.core.ValueOperations; +import org.springframework.stereotype.Component; + +import java.util.*; +import java.util.concurrent.TimeUnit; + +@Component +public class RedisService { + private final Logger logger = LoggerFactory.getLogger(RedisService.class); + + public final RedisTemplate redisTemplate; + + public RedisService(RedisTemplate redisTemplate) { + this.redisTemplate = redisTemplate; + } + + public void setCacheObject(String key, T value) { + redisTemplate.opsForValue().set(key, value); + } + + public void setCacheObjectOfTask(String key, String taskCode, T value) { + String redisKey = key + taskCode; + redisTemplate.opsForValue().set(redisKey, value); + logger.info("RedisService.setCacheObjectOfTask: {}", redisKey); + } + + public void setCacheObject(String key, T value, Long timeout, TimeUnit timeUnit) { + redisTemplate.opsForValue().set(key, value, timeout, timeUnit); + } + + public void setCacheObjectOfTask(String key, String taskCode, T value, Long timeout, TimeUnit timeUnit) { + String redisKey = key + taskCode; + redisTemplate.opsForValue().set(redisKey, value, timeout, timeUnit); + logger.info("RedisService.setCacheObjectOfTaskWithTimeout: {}", redisKey); + } + + public boolean expire(String key, long timeout) { + return expire(key, timeout, TimeUnit.SECONDS); + } + + public boolean expire(String key, long timeout, TimeUnit unit) { + return redisTemplate.expire(key, timeout, unit); + } + + public long getExpire(String key) { + return redisTemplate.getExpire(key); + } + + public Boolean hasKey(String key) { + return redisTemplate.hasKey(key); + } + + public T getCacheObject(String key) { + ValueOperations operation = redisTemplate.opsForValue(); + return operation.get(key); + } + + public T getCacheObjectOfTask(String key, String taskCode) { + String redisKey = key + taskCode; + ValueOperations operation = redisTemplate.opsForValue(); + logger.info("RedisService.getCacheObjectOfTask: {}", redisKey); + return operation.get(redisKey); + } + + public boolean deleteObject(String key) { + return redisTemplate.delete(key).booleanValue(); + } + + public boolean deleteObjectOfTask(String key, String taskCode) { + String redisKey = key + taskCode; + logger.info("RedisService.deleteObjectOfTask: {}", redisKey); + return redisTemplate.delete(redisKey).booleanValue(); + } + + public long deleteObject(Collection collection) { + return redisTemplate.delete(collection).longValue(); + } + + public long setCacheList(String key, List dataList) { + Long count = redisTemplate.opsForList().rightPushAll(key, dataList); + return count == null ? 0L : count; + } + + public List getCacheList(String key) { + return redisTemplate.opsForList().range(key, 0L, -1L); + } + + public BoundSetOperations setCacheSet(String key, Set dataSet) { + BoundSetOperations setOperation = redisTemplate.boundSetOps(key); + Iterator it = dataSet.iterator(); + + while(it.hasNext()) { + setOperation.add((T[]) new Object[]{it.next()}); + } + + return setOperation; + } + + public Set getCacheSet(String key) { + return redisTemplate.opsForSet().members(key); + } + + public void setCacheMap(String key, Map dataMap) { + if(dataMap != null) { + redisTemplate.opsForHash().putAll(key, dataMap); + } + } + + public Map getCacheMap(String key) { + return redisTemplate.opsForHash().entries(key); + } + + public void setCacheMapValue(String key, String hKey, T value) { + redisTemplate.opsForHash().put(key, hKey, value); + } + + public T getCacheMapValue(String key, String hKey) { + HashOperations opsForHash = redisTemplate.opsForHash(); + return opsForHash.get(key, hKey); + } + + public List getMultiCacheMapValue(String key, Collection hKeys) { + return redisTemplate.opsForHash().multiGet(key, hKeys); + } + + public Collection keys(String pattern) { + return redisTemplate.keys(pattern); + } +}