Caching is an integral part of improving application performance, but ensuring cache consistency can be a challenge. I recently designed a Redis cache invalidation mechanism that efficiently removes outdated cache entries using asynchronous events. This ensures that any modification to a cached object triggers an automatic cache cleanup, maintaining data integrity.
Approach
I used Redisson Buckets for caching objects and implemented an event-driven approach for cache invalidation. Whenever an update occurs on a cached object, an asynchronous event is triggered to delete the associated cache bucket.
Cache Example
To efficiently retrieve user details, we cache user profile information using Redis. If the data is not present in the cache, we fetch it from the database, validate the status, and store it in the cache for future use.
public EntityDetails findEntityDetails(String userId) {
String cacheKey = "CACHE_ENTITY_DETAILS_" + userId;
RBucket<EntityDetails> bucket = cacheClient.getBucket(cacheKey, JsonJacksonCodec.INSTANCE);
EntityDetails entityDetails = bucket.get();
if (entityDetails == null) {
entityDetails = entityRepository.findByUserId(userId);
if (entityDetails == null) {
throw new ApplicationException(ErrorCodes.ENTITY_NOT_FOUND.getErrorCode());
}
if ("INACTIVE".equalsIgnoreCase(entityDetails.getStatus())) {
throw new ApplicationException(ErrorCodes.ENTITY_NOT_FOUND_OR_INACTIVE.getErrorCode());
}
bucket.set(entityDetails, cacheExpiryTime, TimeUnit.SECONDS);
} else {
if ("INACTIVE".equalsIgnoreCase(entityDetails.getStatus())) {
throw new ApplicationException(ErrorCodes.ENTITY_NOT_FOUND_OR_INACTIVE.getErrorCode());
}
}
return entityDetails;
}Event-Driven Cache Invalidation
The event listener processes incoming events and checks if they require cache invalidation. If an event of type INVALIDATE_CACHE_EVENT is received, the corresponding userId is extracted from the payload, and cache deletion logic is executed.
public void onEvent(CacheEvent event) {
final Map<Object, Object> payload = (Map<Object, Object>) event.getPayload();
final String eventType = event.getType();
LOGGER.info("Received event. Type: {}, Payload: {}", eventType, payload);
if (CacheService.INVALIDATE_CACHE_EVENT.equals(eventType)) {
String userId = (String) payload.get("userId");
if (StringUtils.isNotBlank(userId)) {
batchDeleteCacheKeys(userId);
} else {
LOGGER.warn("UserId is blank or missing in the event payload.");
}
}
}Batch Deletion of Cache Keys
The core cache invalidation logic revolves around dynamically constructing cache keys based on user details and associated identifiers. These keys are then deleted in bulk using Redisson’s key deletion API.
private void batchDeleteCacheKeys(String userId) {
try {
List<String> cacheKeys = new ArrayList<>();
// Load configured bucket prefixes for deletion
String[] bucketNames = configuration.getProperty("bucket.for.deletion", "").split(",\\s*");
for (String bucketPrefix : bucketNames) {
cacheKeys.add(bucketPrefix + "_" + userId);
}
// Fetch entity-related cache keys
var entityDetails = cacheService.findEntityDetails(userId);
if (entityDetails != null) {
cacheKeys.add("ENTITY_" + entityDetails.getEntityId());
}
// Fetch associated identifiers and related cache entries
var associatedIdentifiers = cacheService.findAssociatedIdentifiers(userId);
if (associatedIdentifiers != null) {
cacheKeys.addAll(associatedIdentifiers.stream()
.map(identifier -> "CACHEKEY_" + identifier.getValue())
.collect(Collectors.toList()));
}
// Perform bulk deletion
if (!cacheKeys.isEmpty()) {
LOGGER.info("Deleting {} cache keys for userId {}", cacheKeys.size(), userId);
cacheClient.getKeys().delete(cacheKeys.toArray(new String[0]));
} else {
LOGGER.info("No cache keys found for userId {}", userId);
}
} catch (Exception ex) {
LOGGER.error("Error occurred while deleting cache for userId '{}': {}", userId, ex.getMessage(), ex);
}
}Key Takeaways
- Event-Driven Invalidations: Async events ensure that cache cleanup happens seamlessly without blocking application flow.
- Efficient Bulk Deletion: Constructing and deleting cache keys in bulk prevents unnecessary Redis calls.
- Scalability & Performance: Using Redisson Buckets provides a structured and scalable approach for managing cache invalidation.
By leveraging this approach, we can maintain a consistent and optimized cache without the risk of serving stale data. This ensures high availability and responsiveness in applications relying on Redis for caching.
