Redis - Spring Boot Redis 使用 msgpack 作为序列化

importcom.fasterxml.jackson.databind.ObjectMapper;
importorg.msgpack.jackson.dataformat.MessagePackFactory;
importorg.springframework.cache.annotation.CachingConfigurerSupport;
importorg.springframework.cache.annotation.EnableCaching;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.data.redis.cache.RedisCacheConfiguration;
importorg.springframework.data.redis.connection.RedisConnectionFactory;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.data.redis.core.StringRedisTemplate;
importorg.springframework.data.redis.serializer.*;
@Configuration@EnableCachingpublicclassRedisConfigextendsCachingConfigurerSupport {
/*** 设置spring redis data 序列化模板* @param factory* @return*/@BeanpublicRedisTemplateredisTemplate(RedisConnectionFactoryfactory) {
StringRedisTemplatetemplate=newStringRedisTemplate(factory);
ObjectMappermapper=newObjectMapper(newMessagePackFactory());
Jackson2JsonRedisSerializerJackson2Serializer=newJackson2JsonRedisSerializer(Object.class);
Jackson2Serializer.setObjectMapper(mapper);
RedisSerializerredisSerializer=Jackson2Serializer;
template.setValueSerializer(redisSerializer);
template.setKeySerializer(newStringRedisSerializer());
returntemplate;
    }
/*** 整合spring cache* 设置@cacheable 序列化方式* @return*/@BeanpublicRedisCacheConfigurationredisCacheConfiguration() {
RedisCacheConfigurationconfiguration=RedisCacheConfiguration.defaultCacheConfig();
configuration=configuration.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(newGenericMsgpackRedisSerializer()));
returnconfiguration;
    }
}

importjava.util.Set;
importcom.fasterxml.jackson.databind.ObjectMapper;
importorg.msgpack.jackson.dataformat.MessagePackFactory;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.data.redis.connection.RedisConnectionFactory;
importorg.springframework.data.redis.core.*;
importorg.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
importorg.springframework.data.redis.serializer.RedisSerializer;
importorg.springframework.stereotype.Component;
importjavax.annotation.Resource;
/*** @description: redis缓存工具类* @version：1.0*/@ComponentpublicclassRedisCacheUtils {
privatestaticLoggerlogger=LoggerFactory.getLogger(RedisCacheUtils.class);
privatefinalstaticBooleanREDIS_ENABLE=true;
@ResourceprivateRedisTemplateredisTemplate;
@ResourceRedisConnectionFactoryredisConnectionFactory;
publicRedisTemplategetRedisTemplate() {
returnredisTemplate;
    }
publicvoidsetRedisTemplate(RedisTemplateredisTemplate) {
this.redisTemplate=redisTemplate;
    }
publicRedisCacheUtils(RedisTemplateredisTemplate) {
this.redisTemplate=redisTemplate;
    }
/*** 缓存基本的对象，Integer、String、实体类等** @param key   缓存的键值* @param value 缓存的值* @return缓存的对象   */publicbooleansetCacheObject(Stringkey, Objectvalue) {
if (!REDIS_ENABLE) {
returnfalse;
        }
logger.debug("存入缓存 key:"+key);
try {
ValueOperations<String, Object>operation=redisTemplate.opsForValue();
operation.set(key, value);
returntrue;
        } catch (Exceptionex) {
logger.error(ex.getMessage());
returnfalse;
        }
    }
/*** 根据pattern匹配清除缓存* @param pattern*/publicvoidclear(Stringpattern) {
if (!REDIS_ENABLE) {
return;
        }
logger.debug("清除缓存 pattern:"+pattern);
try {
ValueOperations<String, Object>valueOper=redisTemplate.opsForValue();
RedisOperations<String, Object>redisOperations=valueOper.getOperations();
redisOperations.keys(pattern);
Set<String>keys=redisOperations.keys(pattern);
for (Stringkey : keys) {
redisOperations.delete(key);
            }
        } catch (Exceptionex) {
logger.error(ex.getMessage());
return;
        }
    }
/*** 根据key清除缓存* @param key*/publicvoiddelete(Stringkey) {
if (!REDIS_ENABLE) {
return;
        }
logger.debug("删除缓存 key:"+key);
try {
ValueOperations<String, Object>valueOper=redisTemplate.opsForValue();
RedisOperations<String, Object>redisOperations=valueOper.getOperations();
redisOperations.delete(key);
        } catch (Exceptionex) {
logger.error(ex.getMessage());
return;
        }
    }
/*** 获得缓存的基本对象。* @param key 缓存键值* @return 缓存键值对应的数据*   */publicObjectgetCacheObject(Stringkey) {
if (!REDIS_ENABLE) {
returnnull;
        }
logger.debug("获取缓存 key:"+key);
try {
ValueOperations<String, Object>operation=redisTemplate.opsForValue();
returnoperation.get(key);
        } catch (Exceptionex) {
logger.error(ex.getMessage());
returnnull;
        }
    }
/*** 获得缓存的基本对象。* @param key 缓存键值* @return 缓存键值对应的数据*   */public<T>TgetCacheObject(Stringkey, Class<T>clazz) {
if (!REDIS_ENABLE) {
returnnull;
        }
logger.debug("获取缓存 key:"+key);
RedisTemplatetemplate=newStringRedisTemplate(redisConnectionFactory);
Jackson2JsonRedisSerializerJackson2Serializer=newJackson2JsonRedisSerializer(clazz);
Jackson2Serializer.setObjectMapper(newObjectMapper(newMessagePackFactory()));
RedisSerializerredisSerializer=Jackson2Serializer;
template.setValueSerializer(redisSerializer);
try {
ValueOperations<String, T>operation=template.opsForValue();
return (T) operation.get(key);
        } catch (Exceptionex) {
logger.error(ex.getMessage());
returnnull;
        }
    }
}

@RestControllerpublicclassTestController {
@ResourceRedisCacheUtilsredisCacheUtils;
@GetMapping("/getCache")
publicObjectgetCache() {
List<String>result=redisCacheUtils.getCacheObject("list_cache", newArrayList<HashMap<String, String>>().getClass());
returnresult;
    }
@GetMapping("/setCache")
publicObjectsetCache() {
List<Map>list=newArrayList<>();
for (inti=0; i<100; i++) {
Mapmap=newHashMap<String, String>();
map.put("id", i);
map.put("name", "index="+i);
list.add(map);
        }
returnredisCacheUtils.setCacheObject("list_cache", list);
    }
}