Spring Redis索引未随主条目过期删除求助（Redis Enterprise环境）

Since you can't modify Redis configs (the CONFIG command is blocked) and enableKeyspaceEvents = ON_STARTUP fails due to that restriction, let's walk through practical workarounds to ensure :idx entries get cleaned up alongside main/phantom entries:

1. Explicitly Set TTL on Index Entries When Saving Main Entities #

Spring Data Redis generates index keys in the format {EntityName}:idx:{IndexFieldName}:{FieldValue}. You can manually apply the same TTL to these index keys right after saving your main entity to align their expiration:

@Autowired
private StringRedisTemplate redisTemplate;

@Autowired
private YourEntityRepository entityRepository;

public void saveEntityWithSyncedTTL(YourEntity entity, long ttlSeconds) {
    // Save the main entity with its TTL
    entityRepository.save(entity);
    
    // Construct the index key for your indexed field (adjust to match your index setup)
    String indexKey = String.format("{YourEntity}:idx:{email}:%s", entity.getEmail());
    
    // Apply the same TTL to the index key
    redisTemplate.expire(indexKey, ttlSeconds, TimeUnit.SECONDS);
}

• For multiple indexes: Repeat the expire step for each indexed field's corresponding key.
• Atomicity improvement: To avoid race conditions between saving the entity and setting the index TTL, use a Lua script to execute both actions atomically:

  -- Lua script to save main entity and sync index TTL
  redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[2])
  redis.call('SET', KEYS[2], ARGV[3], 'EX', ARGV[2])
  return 1
  

  Run this script via redisTemplate.execute() to ensure both operations succeed or fail together.

2. Periodic Cleanup Job for Orphaned Indexes #

Since your :idx entry volume is small, a scheduled task can periodically scan index keys and delete those that no longer have a corresponding main entity:

@Scheduled(fixedRate = 3600000) // Run hourly (adjust based on your TTLs)
public void cleanOrphanedIndexes() {
    // Match all index keys (tweak the pattern to fit your entity's index format)
    Set<String> indexKeys = redisTemplate.keys("*:idx:*");
    
    if (indexKeys == null || indexKeys.isEmpty()) {
        return;
    }
    
    for (String indexKey : indexKeys) {
        // Get the main entity ID from the index value (adjust logic to your index structure)
        String mainEntityId = redisTemplate.opsForValue().get(indexKey);
        String mainEntityKey = String.format("{YourEntity}:%s", mainEntityId);
        
        // Delete the index if the main entity no longer exists
        if (!redisTemplate.hasKey(mainEntityKey)) {
            redisTemplate.delete(indexKey);
        }
    }
}

• Production tip: Replace KEYS with SCAN if your key count grows later, as KEYS blocks the Redis instance temporarily.
• Schedule tuning: Align the task frequency with your shortest entity TTL to avoid cleaning indexes prematurely.

3. Custom Index Management with Redis Hashes #

Ditch Spring Data Redis's automatic indexes and manage them manually using Redis Hashes. This gives you full control over their lifecycle:

@Autowired
private ObjectMapper objectMapper;

public void saveEntityWithCustomIndex(YourEntity entity, long ttlSeconds) throws JsonProcessingException {
    String mainKey = String.format("{YourEntity}:%s", entity.getId());
    // Save main entity with TTL
    redisTemplate.opsForValue().set(mainKey, objectMapper.writeValueAsString(entity), ttlSeconds, TimeUnit.SECONDS);
    
    // Store index in a Hash: key = index identifier, field = indexed value, value = entity ID
    String indexHashKey = "{YourEntity}:idx:{email}";
    redisTemplate.opsForHash().put(indexHashKey, entity.getEmail(), entity.getId());
    
    // Sync TTL with the main entity
    redisTemplate.expire(indexHashKey, ttlSeconds, TimeUnit.SECONDS);
}

// Clean up index when deleting an entity
public void deleteEntity(String entityId, String email) {
    String mainKey = String.format("{YourEntity}:%s", entityId);
    redisTemplate.delete(mainKey);
    
    String indexHashKey = "{YourEntity}:idx:{email}";
    redisTemplate.opsForHash().delete(indexHashKey, email);
}

• Pros: The entire index Hash expires at the same time as the main entity, eliminating orphaned entries entirely.
• Cons: You'll need to implement custom query logic for indexed fields instead of relying on Spring Data Redis repository queries.

Why enableKeyspaceEvents = ON_STARTUP Didn't Work #

The ON_STARTUP setting attempts to run CONFIG SET notify-keyspace-events Ex to enable key expiration notifications. Since Redis Enterprise blocks the CONFIG command, this throws the ERR unknown command 'CONFIG' error. Even in local Docker, Redis doesn't enable keyspace notifications by default, and if the container doesn't persist config changes, the setting won't stick after a restart.

内容的提问来源于stack exchange，提问作者NanSil