The Scenario
We would like to cache Cassandra data to Redis for better read performance.
Cache Configuration
To make data in Redis more readable and easy for troubleshooting and debugging, we use GenericJackson2JsonRedisSerializer to serialize value as Json data in Redis, use StringRedisSerializer to serialize key.
To make GenericJackson2JsonRedisSerializer work, we also configure objectMapper to store type info: objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
- as we need store class info.
- The data would be like: {\"@class\":\"com....Configuration\",\"name\":\"configA\",\"value\":\"805\"}
We also configure objectMapper: configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false).
- As when there Cassandra, we want to cache this info to redis. So later we can return from redis cache, and no need to read from database again.
- Spring-cache stores org.springframework.cache.support.NullValue in this case, its json data is {}. We need configure ObjectMapper to return empty object with no properties. - By default it throws exception:
org.springframework.data.redis.serializer.SerializationException: Could not write JSON: No serializer found for class org.springframework.cache.support.NullValue and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS); nested exception is com.fasterxml.jackson.databind.JsonMappingException: No serializer found for class org.springframework.cache.support.NullValue and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS)
We configured cacheManager to store null value.
- We use the configuration-driven approach and have a lot of configurations; We define default configuration values in property files. In the code, it first read from db and if null then read from property files. This makes us want to cache null value.
We also use SpEL to set different TTL for different cache.
redis.expires={configData:XSeconds, userSession: YSeconds}
@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
@Value("${redis.hostname}")
String redisHostname;
@Value("${redis.port}")
int redisPort;
@Value("#{${redis.expires}}")
private Map<String, Long> expires;
@Bean
public JedisConnectionFactory redisConnectionFactory() {
final JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
redisConnectionFactory.setHostName(redisHostname);
redisConnectionFactory.setPort(redisPort);
redisConnectionFactory.setUsePool(true);
return redisConnectionFactory;
}
@Bean("redisTemplate")
public RedisTemplate<String, Object> genricJacksonRedisTemplate(final JedisConnectionFactory cf) {
final RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer(createRedisObjectmapper()));
redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer(objectMapper));
redisTemplate.setConnectionFactory(cf);
return redisTemplate;
}
@Bean
public CacheManager cacheManager(final RedisTemplate<String, Object> redisTemplate) {
final RedisCacheManager cacheManager =
new RedisCacheManager(redisTemplate, Collections.<String>emptyList(), true);
cacheManager.setDefaultExpiration(86400);
cacheManager.setExpires(expires);
cacheManager.setLoadRemoteCachesOnStartup(true);
return cacheManager;
}
public static ObjectMapper createRedisObjectmapper() {
final SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_DATE_FORMAT, Locale.ROOT);
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
final SimpleModule dateModule = (new SimpleModule()).addDeserializer(Date.class, new JsonDateDeserializer());
return new ObjectMapper()
.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL,JsonTypeInfo.As.PROPERTY)//\\
.registerModule(dateModule).setDateFormat(sdf)
.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true)
.configure(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS, true)
.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false)
.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false)
.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false)
.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false)
.configure(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY, false)
.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
.configure(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS, false)
.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false) //\\
.setSerializationInclusion(JsonInclude.Include.NON_NULL)
.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
}
}
Cache CassandraRepository
@Repository
@CacheConfig(cacheNames = Util.CACHE_CONFIG)
public interface ConfigurationDao extends CassandraRepository<Configuration> {
@Query("Select * from configuration where name=?0")
@Cacheable
Configuration findByName(String name);
@Query("Delete from configuration where name=?0")
@CacheEvict
void delete(String name);
@Override
@CacheEvict(key = "#p0.name")
void delete(Configuration config);
/*
* Check https://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html
* about what #p0 means
*/
@Override
@SuppressWarnings("unchecked")
@CachePut(key = "#p0.name")
Configuration save(Configuration config);
/*
* This API doesn't work very well with cache - as spring cache doesn't support put or evict
* multiple keys. Call save(Configuration config) in a loop instead.
*/
@Override
@CacheEvict(allEntries = true)
@Deprecated
<S extends Configuration> Iterable<S> save(Iterable<S> configs);
/*
* This API doesn't work very well with cache - as spring cache doesn't support put or evict
* multiple keys. Call delete(Configuration config) in a loop instead.
*/
@Override
@CacheEvict(allEntries = true)
@Deprecated
void delete(Iterable<? extends Configuration> configs);
}
Admin API to Manage Cache
We inject CacheManager to add or evict data from Redis.
But to scan all keys in a cache(like: cofig), I need to use stringRedisTemplate.opsForZSet() to get keys of the cache:
- as the value in the cache (config), its value is a list of string keys. So here I need use StringRedisTemplate to read it.
After get the keys, I use redisTemplate.opsForValue().multiGet to get their values.
- I will update this post if I find some better ways to do this.
public class CacheResource {
private static final String REDIS_CACHE_SUFFIX_KEYS = "~keys";
@Autowired
@Qualifier("redisTemplate")
RedisTemplate<String, Object> redisTemplate;
@Autowired
@Qualifier("stringRedisTemplate")
StringRedisTemplate stringRedisTemplate;
@Autowired
private CacheManager cacheManager;
/**
* If sessionId is not null, return its associated user info.<br>
* It also returns other cached data: they are small data.
*
* @return
*/
@GetMapping(produces = MediaType.APPLICATION_JSON_VALUE, path = "/cache")
public Map<String, Object> get(@RequestParam("sessionIds") final String sessionIds,
@RequestParam(name = "getConfig", defaultValue = "false") final boolean getConfig) {
final Map<String, Object> resultMap = new HashMap<>();
if (getConfig) {
final Set<String> configKeys =
stringRedisTemplate.opsForZSet().range(Util.CACHE_CONFIG_DAO + REDIS_CACHE_SUFFIX_KEYS, 0, -1);
final List<Object> objects = redisTemplate.opsForValue().multiGet(configKeys);
resultMap.put(Util.CACHE_CONFIG + REDIS_CACHE_SUFFIX_KEYS, objects);
}
if (StringUtils.isNotBlank(sessionIds)) {
final Map<String, Object> sessionIdToUsers = new HashMap<>();
final Long totalUserCount = stringRedisTemplate.opsForZSet().size(Util.CACHE_USER + REDIS_CACHE_SUFFIX_KEYS);
sessionIdToUsers.put("totalUserCount", totalUserCount);
final ArrayList<String> sessionIdList = Lists.newArrayList(Util.COMMA_SPLITTER.split(sessionIds));
final List<Object> sessionIDValues = redisTemplate.opsForValue().multiGet(sessionIdList);
for (int i = 0; i < sessionIdList.size(); i++) {
sessionIdToUsers.put(sessionIdList.get(i), sessionIDValues.get(i));
}
resultMap.put(Util.CACHE_USER + REDIS_CACHE_SUFFIX_KEYS, sessionIdToUsers);
}
return resultMap;
}
@DeleteMapping("/cache")
public void clear(@RequestParam("removeSessionIds") final String removeSessionIds,
@RequestParam(name = "clearSessions", defaultValue = "false") final boolean clearSessions,
@RequestParam(name = "clearConfig", defaultValue = "false") final boolean clearConfig) {
if (clearConfig) {
final Cache configCache = getConfigCache();
configCache.clear();
}
final Cache userCache = getUserCache();
if (clearSessions) {
userCache.clear();
} else if (StringUtils.isNotBlank(removeSessionIds)) {
final ArrayList<String> sessionIdList = Lists.newArrayList(Util.COMMA_SPLITTER.split(removeSessionIds));
for (final String sessionId : sessionIdList) {
userCache.evict(sessionId);
}
}
}
/**
* Only handle client() data - as other caches such as configuration we can use server side api
* to update them
*/
@PutMapping("/cache")
public void addOrupdate(...) {
if (newUserSessions == null) {
return;
}
final Cache userCache = getUserCache();
// userCache.put to add key, value
}
private Cache getConfigCache() {
return cacheManager.getCache(Util.CACHE_CONFIG_DAO);
}
private Cache getUserCache() {
return cacheManager.getCache(Util.CACHE_USER);
}
}
StringRedisTemplate
@Bean("stringRedisTemplate")
public StringRedisTemplate stringRedisTemplate(final JedisConnectionFactory cf, final ObjectMapper objectMapper) {
final StringRedisTemplate redisTemplate = new StringRedisTemplate();
redisTemplate.setConnectionFactory(cf);
return redisTemplate;
}
Misc
- If you want to disable cache in some env, use NoOpCacheManager.
- When debug, check code:
CacheAspectSupport.execute
SpringCacheAnnotationParser.parseCacheAnnotations
