Redis - Spring Boot Redis 使用 msgpack 作为序列化-阿里云开发者社区

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

2022-06-07 428

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

本文涉及的产品

云数据库 Redis 版，社区版 2GB

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

首先引入 msgpack 所需要的包

<dependency><groupId>org.msgpack</groupId><artifactId>msgpack-core</artifactId><version>0.8.13</version></dependency><dependency><groupId>org.msgpack</groupId><artifactId>jackson-dataformat-msgpack</artifactId><version>0.8.13</version></dependency>

版本一定要对齐，之前 jackson-dataformat-msgpack 版本太低导致无法使用。

RedisConfig.java（Spring Boot Redis 配置类）

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

GenericMsgpackRedisSerializer.java（Spring Cache msgpack 序列化类）

importcom.fasterxml.jackson.annotation.JsonTypeInfo.As;
importcom.fasterxml.jackson.core.JsonGenerator;
importcom.fasterxml.jackson.core.JsonProcessingException;
importcom.fasterxml.jackson.databind.ObjectMapper;
importcom.fasterxml.jackson.databind.SerializerProvider;
importcom.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;
importcom.fasterxml.jackson.databind.module.SimpleModule;
importcom.fasterxml.jackson.databind.ser.std.StdSerializer;
importjava.io.IOException;
importorg.msgpack.core.annotations.Nullable;
importorg.msgpack.jackson.dataformat.MessagePackFactory;
importorg.springframework.cache.support.NullValue;
importorg.springframework.data.redis.serializer.RedisSerializer;
importorg.springframework.data.redis.serializer.SerializationException;
importorg.springframework.util.Assert;
importorg.springframework.util.StringUtils;
publicclassGenericMsgpackRedisSerializerimplementsRedisSerializer<Object> {
staticfinalbyte[] EMPTY_ARRAY=newbyte[0];
privatefinalObjectMappermapper;
publicGenericMsgpackRedisSerializer() {
this.mapper=newObjectMapper(newMessagePackFactory());
this.mapper.registerModule((newSimpleModule()).addSerializer(newGenericMsgpackRedisSerializer.NullValueSerializer(null)));
this.mapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
    }
@Overridepublicbyte[] serialize(@NullableObjectsource) throwsSerializationException {
if (source==null) {
returnEMPTY_ARRAY;
        } else {
try {
returnthis.mapper.writeValueAsBytes(source);
            } catch (JsonProcessingExceptionvar3) {
thrownewSerializationException("Could not write JSON: "+var3.getMessage(), var3);
            }
        }
    }
@OverridepublicObjectdeserialize(@Nullablebyte[] source) throwsSerializationException {
returnthis.deserialize(source, Object.class);
    }
@Nullablepublic<T>Tdeserialize(@Nullablebyte[] source, Class<T>type) throwsSerializationException {
Assert.notNull(type, "Deserialization type must not be null! Pleaes provide Object.class to make use of Jackson2 default typing.");
if (source==null||source.length==0) {
returnnull;
        } else {
try {
returnthis.mapper.readValue(source, type);
            } catch (Exceptionvar4) {
thrownewSerializationException("Could not read JSON: "+var4.getMessage(), var4);
            }
        }
    }
privateclassNullValueSerializerextendsStdSerializer<NullValue> {
privatestaticfinallongserialVersionUID=2199052150128658111L;
privatefinalStringclassIdentifier;
NullValueSerializer(@NullableStringclassIdentifier) {
super(NullValue.class);
this.classIdentifier=StringUtils.hasText(classIdentifier) ?classIdentifier : "@class";
        }
@Overridepublicvoidserialize(NullValuevalue, JsonGeneratorjgen, SerializerProviderprovider) throwsIOException {
jgen.writeStartObject();
jgen.writeStringField(this.classIdentifier, NullValue.class.getName());
jgen.writeEndObject();
        }
    }
}

RedisCacheRedisUtils.java（序列化工具类）

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

启动 Spring Boot 开始测试

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