storing raw json in redis by using spring-data-redis

Question

I am using RedisCacheManager to store my cache data in my spring-boot application. Default serializer seems to serialize everything into byte and deserialize from byte to appropriate java type.

However, I want to make the cache data be stored as json so that I can read it from none-java clients.

I found that switching from default one to other serializers such as Jackson2JsonRedisSerializer supposed to work. After doing this, deserialization phase fails.

pom.xml

 <dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-redis</artifactId>
 </dependency>
 <dependency>
 <groupId>redis.clients</groupId>
 <artifactId>jedis</artifactId>
 </dependency>

CacheConfig.java

@Configuration
@EnableCaching
public class CacheConfig {
 @Bean
 public RedisConnectionFactory createRedisConnectionFactory() {
 JedisConnectionFactory factory = new JedisConnectionFactory();
 factory.setHostName("localhost");
 return factory;
 }
// SPRING-DATA-REDIS ALREADY PROVIDES A STRING REDIS TEMPLATE, SO THE FOLLOWING IS NOT NECESSARY
// @Bean
// public RedisTemplate<String, String> createRedisTemplate(RedisConnectionFactory factory) {
// RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
// redisTemplate.setConnectionFactory(factory);
// return redisTemplate;
// }
 @Bean
 public CacheManager redisCacheManager(RedisTemplate redisTemplate) {
 RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
 return cacheManager;
 }
}

Is there a way to store them in a pure JSON format and successfully deserialize from it?

Answer 1

add this in your configuration to explicitly set the jackson serializer in redis template.

public @Bean RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
 RedisTemplate<Object, Object> template = new RedisTemplate<>();
 template.setConnectionFactory(connectionFactory);
 template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
 template.setKeySerializer(new StringRedisSerializer());
 template.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
 template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
 return template;
}

• Muatik: I've already tried this but cache data in redis is still in bytes. like "\xac\xed\x00\x05sr\x00\x0ejava.lang.Long;\x8b\xe4\x90\xcc\x8f#\xdf\x02\x00\x01J\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\x00\x00\x00\x00\x00\x01"
• Monzurul Shimul: Have you checked with my updated answer? Let me know.
• Jeff Cook: This doesn't works if we use CrudRepository patterns for persisting data?
• Ani Aggarwal: This probably works for the older version of spring-data-redis however it doesn't work for the latest version ATM

Answer 2

As of spring-data-jpa:2.0.2.RELEASE at least, configuring the default redis template does not affect how the @Cacheable annotation family accesses redis. Anyway, since I'm using a redis template for more than that, it's not something I want to do.

This, however, isolates the configuration for the cache manager and works as expected:

@Configuration
@EnableCaching
public class RedisCacheManagerConfiguration {
 @Autowired
 private RedisConnectionFactory redisConnectionFactory;
 @Bean
 public CacheManager redisCacheManager() {
 RedisSerializationContext.SerializationPair<Object> jsonSerializer = 
 RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer());
 return RedisCacheManager.RedisCacheManagerBuilder
 .fromConnectionFactory(redisConnectionFactory)
 .cacheDefaults(
 RedisCacheConfiguration.defaultCacheConfig()
 .entryTtl(Duration.ofDays(1))
 .serializeValuesWith(jsonSerializer)
 )
 .build();
 }
}

It makes use of the generic Json serializer for Redis (GenericJackson2JsonRedisSerializer).

You can also configure other aspects of the cache manager, such as the time-to-live of the key in redis.

Answer 3

I managed to make this by defining RedisConnectionFactory

@Bean
public RedisConnectionFactory jedisPool()
{
 JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(new JedisPoolConfig());
 jedisConnectionFactory.setHostName("localhost");
 return jedisConnectionFactory;
}

and then using StringRedisTemplate

ValueOperations<String, String> ops = redisTemplate.opsForValue();
ops.set("key", "Json_string");

I hope this might help!

• Muatik: You are right, if you use redisTemplate directly, you have full control over data in and out. However, in my case, I use cache annotations such as @Cacheable, @Cacheput where cacheManager uses redisTemplate for cache operations.
• mgalala: Might this help you then? github.com/spring-projects/spring-session/issues/387