Redis Template主键与哈希键独立过期设置技术咨询

Great question! The catch here is that Redis' native Hash data structure doesn't support per-field (your hashKey) expiration natively. But don't worry, there are a few solid workarounds to achieve what you need using Spring's RedisTemplate. Let's break them down:

方案1：拆分独立键值对 + 哈希索引 #

This approach splits each hashKey into its own standalone key-value entry, while using the original Hash as an index to track all active hashKeys under the main key. This way you can set independent expiration times for both the main index key and each individual hashKey entry.

How to implement it: #

1. When storing data:

   • Store the actual value in a dedicated key (e.g., format like {mainKey}:{hashKey}) and set its expiration.
   • Add the hashKey to the main Hash index (you can store a placeholder value like true or metadata if needed).
   • Set expiration for the main Hash index key if required.

   Here's the code snippet using RedisTemplate:

   // Define keys
   String mainKey = "user:1001";
   String hashKey = "profile";
   String standaloneKey = String.format("%s:%s", mainKey, hashKey);
   String value = "{\"name\":\"John\"}";
   
   // Store standalone value with its own expiration (e.g., 1 hour)
   redisTemplate.opsForValue().set(standaloneKey, value, 1, TimeUnit.HOURS);
   
   // Add hashKey to main Hash index
   redisTemplate.opsForHash().put(mainKey, hashKey, true);
   
   // Set expiration for main Hash index (e.g., 7 days)
   redisTemplate.expire(mainKey, 7, TimeUnit.DAYS);
   

2. When retrieving data:

   • First check if the main Hash index exists (or if the hashKey is present in it).
   • Then fetch the value from the standalone key (Redis will automatically return null if it's expired).
   • If the standalone key is expired, clean up the hashKey from the main Hash index to keep it tidy.

   String mainKey = "user:1001";
   String hashKey = "profile";
   String standaloneKey = String.format("%s:%s", mainKey, hashKey);
   
   // Check if hashKey exists in main index
   Boolean existsInIndex = redisTemplate.opsForHash().hasKey(mainKey, hashKey);
   if (Boolean.TRUE.equals(existsInIndex)) {
       String value = (String) redisTemplate.opsForValue().get(standaloneKey);
       if (value == null) {
           // Clean up expired entry from main Hash
           redisTemplate.opsForHash().delete(mainKey, hashKey);
       }
       return value;
   }
   return null;
   

Pros & Cons: #

• ✅ Fully independent expiration for both main key and each hashKey
• ✅ Native Redis expiration handling (no manual cleanup needed for standalone keys)
• ❌ Increases key count in Redis (might be a concern for very large datasets)
• ❌ Requires extra steps to maintain the index consistency

方案2：在Hash Value中嵌入过期时间戳 #

If you prefer to keep everything within the Hash structure, you can wrap your actual value with an expiration timestamp. You'll need to manually check for expiration on every read, and optionally run a background cleanup task to remove expired entries.

How to implement it: #

1. Create a wrapper class to hold the value and expiration time:

   public class ExpirableValue {
       private String data;
       private long expireTimestamp; // Unix timestamp in milliseconds
   
       // Getters, setters, constructor
   }
   

2. When storing data:

   • Calculate the expiration timestamp for the hashKey.
   • Wrap the value and timestamp, then store it in the Hash.
   • Set expiration for the main key as usual.

   String mainKey = "user:1001";
   String hashKey = "profile";
   String actualValue = "{\"name\":\"John\"}";
   
   // Set hashKey's expiration to 1 hour from now
   long hashKeyExpireTime = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);
   ExpirableValue expirableValue = new ExpirableValue(actualValue, hashKeyExpireTime);
   
   // Store in Hash (you'll need a serializer for the ExpirableValue class)
   redisTemplate.opsForHash().put(mainKey, hashKey, expirableValue);
   
   // Set main key's expiration to 7 days
   redisTemplate.expire(mainKey, 7, TimeUnit.DAYS);
   

3. When retrieving data:

   • Fetch the wrapped value from the Hash.
   • Check if the current time is past the expiration timestamp.
   • If expired, delete the hashKey from the Hash and return null; otherwise return the actual data.

   String mainKey = "user:1001";
   String hashKey = "profile";
   
   ExpirableValue expirableValue = (ExpirableValue) redisTemplate.opsForHash().get(mainKey, hashKey);
   if (expirableValue != null) {
       if (System.currentTimeMillis() > expirableValue.getExpireTimestamp()) {
           // Clean up expired entry
           redisTemplate.opsForHash().delete(mainKey, hashKey);
           return null;
       }
       return expirableValue.getData();
   }
   return null;
   

4. Background cleanup:

   • To prevent the Hash from getting cluttered with expired entries, run a periodic task (e.g., using Spring's @Scheduled) to scan the Hash and remove expired hashKeys.

Pros & Cons: #

• ✅ All data stays within a single Hash structure
• ✅ No extra keys created
• ❌ Manual expiration check required on every read
• ❌ Background cleanup needed to avoid bloated Hash
• ❌ Main key expiration will override all entries if it expires first

方案3：Sorted Set + Hash 组合方案 #

This approach uses a Sorted Set to track the expiration times of each hashKey, with the expiration timestamp as the score. You can then use the Sorted Set to efficiently find and delete expired entries.

How to implement it: #

1. When storing data:

   • Store the value in the Hash.
   • Add the hashKey to a Sorted Set (named like {mainKey}:expires) with its expiration timestamp as the score.
   • Set expiration for the main key and the Sorted Set (they should have the same expiration as the main key, or longer if needed).

   String mainKey = "user:1001";
   String hashKey = "profile";
   String value = "{\"name\":\"John\"}";
   
   // HashKey expires in 1 hour
   long expireTimestamp = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);
   String expireSetKey = String.format("%s:expires", mainKey);
   
   // Store value in Hash
   redisTemplate.opsForHash().put(mainKey, hashKey, value);
   
   // Add to Sorted Set with expiration timestamp as score
   redisTemplate.opsForZSet().add(expireSetKey, hashKey, expireTimestamp);
   
   // Set expiration for main key and expire set (7 days)
   redisTemplate.expire(mainKey, 7, TimeUnit.DAYS);
   redisTemplate.expire(expireSetKey, 7, TimeUnit.DAYS);
   

2. Retrieval & cleanup:

   • On retrieval, first check if the hashKey is still valid (by checking the Sorted Set or verifying the expiration).
   • Run a periodic task to query the Sorted Set for entries with score less than current timestamp, then delete those hashKeys from both the Hash and the Sorted Set.

   // Periodic cleanup task
   public void cleanExpiredHashKeys(String mainKey) {
       String expireSetKey = String.format("%s:expires", mainKey);
       long now = System.currentTimeMillis();
   
       // Get all hashKeys that have expired
       Set<String> expiredHashKeys = redisTemplate.opsForZSet().rangeByScore(expireSetKey, 0, now);
       if (expiredHashKeys != null && !expiredHashKeys.isEmpty()) {
           // Delete from Hash
           redisTemplate.opsForHash().delete(mainKey, expiredHashKeys.toArray());
           // Delete from Sorted Set
           redisTemplate.opsForZSet().removeRangeByScore(expireSetKey, 0, now);
       }
   }
   

Pros & Cons: #

• ✅ Efficient expiration tracking with Sorted Set's range queries
• ✅ Clean separation of expiration metadata from actual data
• ❌ Requires maintaining an additional Sorted Set per main key
• ❌ Periodic cleanup task is necessary to remove expired entries

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