استراتژی حافظه پنهان ترکیبی در Spring Boot: راهنمای ادغام ردیسون و کافئین

        
            org.springframework.boot
            spring-boot-starter-cache
        
        
            com.github.ben-manes.caffeine
            caffeine
            3.2.0
        
        
            org.redisson
            redisson
            3.43.0
        

@Configuration
@EnableCaching
public class CacheConfig implements CachingConfigurer {

  @Value("${cache.server.address}")
  private String cacheAddress;

  @Value("${cache.server.password}")
  private String cachePassword;

  @Value("${cache.server.expirationTime:60}")
  private Long cacheExpirationTime;

  @Bean(destroyMethod = "shutdown")
  RedissonClient redisson() {
    Config config = new Config();
    config.useSingleServer().setAddress(cacheAddress).setPassword(cachePassword.trim());
    config.setLazyInitialization(true);
    return Redisson.create(config);
  }

  @Bean
  @Override
  public CacheManager cacheManager() {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();
    cacheManager.setCaffeine(
        Caffeine.newBuilder().expireAfterWrite(cacheExpirationTime, TimeUnit.MINUTES));
    return cacheManager;
  }

  @Bean
  public CacheEntryRemovedListener cacheEntryRemovedListener() {
    return new CacheEntryRemovedListener(cacheManager());
  }

  @Bean
  @Override
  public CacheResolver cacheResolver() {
    return new LocalCacheResolver(cacheManager(), redisson(), cacheEntryRemovedListener());
  }
}

    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // Simulates an expensive database call
        return productRepository.findById(id);
    }

    @CacheEvict(value = "products", key = "#id")
    public void deleteProductById(Long id) {
        productRepository.deleteById(id);
    } 

@Component
public class LocalCacheResolver implements CacheResolver {

  private final CacheManager cacheManager;
  private final RedissonClient redisson;
  private final CacheEntryRemovedListener cacheEntryRemovedListener;

  @Value("${cache.server.expirationTime:60}")
  private Long expirationTime;

  private final Map<String, LocalCache> cacheMap = new ConcurrentHashMap<>();

  public LocalCacheResolver(
      CacheManager cacheManager,
      RedissonClient redisson,
      CacheEntryRemovedListener cacheEntryRemovedListener) {
    this.cacheManager = cacheManager;
    this.redisson = redisson;
    this.cacheEntryRemovedListener = cacheEntryRemovedListener;
  }

  @Override
  @Nonnull
  public Collection extends Cache> resolveCaches(
      @Nonnull CacheOperationInvocationContext> context) {
    Collection<Cache> caches = getCaches(cacheManager, context);
    return caches.stream().map(this::getOrCreateLocalCache).toList();
  }

  private Collection<Cache> getCaches(
      CacheManager cacheManager, CacheOperationInvocationContext> context) {
    return context.getOperation().getCacheNames().stream()
        .map(cacheManager::getCache)
        .filter(Objects::nonNull)
        .toList();
  }

  private LocalCache getOrCreateLocalCache(Cache cache) {
    return cacheMap.computeIfAbsent(
        cache.getName(),
        cacheName -> new LocalCache(cache, redisson, expirationTime, cacheEntryRemovedListener));
  }
}

public class LocalCache implements Cache {

  private final Cache cache;
  private final Long expirationTime;
  private final RMapCache<Object, Object> distributedCache;

  public LocalCache(
      Cache cache,
      RedissonClient redisson,
      Long expirationTime,
      CacheEntryRemovedListener cacheEntryRemovedListener) {
    this.cache = cache;
    this.expirationTime = expirationTime;
    this.distributedCache = redisson.getMapCache(getName());
    this.distributedCache.addListener(cacheEntryRemovedListener);
  }

  @Override
  @Nonnull
  public String getName() {
    return cache.getName();
  }

  @Override
  @Nonnull
  public Object getNativeCache() {
    return cache.getNativeCache();
  }

  @Override
  public ValueWrapper get(@Nonnull Object key) {
    Object value = cache.get(key);

    if (value == null && (value = distributedCache.get(key)) != null) {
      cache.put(key, value);
    }

    return toValueWrapper(value);
  }

  private ValueWrapper toValueWrapper(Object value) {
    if (value == null) return null;
    return value instanceof ValueWrapper ? (ValueWrapper) value : new SimpleValueWrapper(value);
  }

  @Override
  public <T> T get(@Nonnull Object key, Class<T> type) {
    return cache.get(key, type);
  }

  @Override
  public <T> T get(@Nonnull Object key, @Nonnull Callable<T> valueLoader) {
    return cache.get(key, valueLoader);
  }

  @Override
  public void put(@Nonnull Object key, Object value) {
    distributedCache.put(key, value, expirationTime, TimeUnit.MINUTES);
    cache.put(key, value);
  }

  @Override
  public void evict(@Nonnull Object key) {
    distributedCache.remove(key);
  }

  @Override
  public void clear() {
    cache.clear();
  }
}

@RequiredArgsConstructor
@Component
public class CacheEntryRemovedListener implements EntryRemovedListener<Object, Object> {

  private final CacheManager cacheManager;

  @Override
  public void onRemoved(EntryEvent event) {
    Cache cache = cacheManager.getCache(event.getSource().getName());
    if (cache != null) {
      cache.evict(event.getKey());
    }
  }
}

javaCopyEdit@Override
public void put(@Nonnull Object key, Object value) {
    distributedCache.put(key, value, expirationTime, TimeUnit.MINUTES);
    cache.put(key, value);
}

@Override
public ValueWrapper get(@Nonnull Object key) {
    Object value = cache.get(key);

    if (value == null && (value = distributedCache.get(key)) != null) {
      cache.put(key, value);
    }

    return toValueWrapper(value);
}

@Override
public void evict(@Nonnull Object key) {
    distributedCache.remove(key);
}