Spring Кэш, обновляющий устаревшие значения

Ответ 1

Я бы сказал, что самый простой способ сделать то, что вам нужно, - создать пользовательский аспект, который будет делать всю магию прозрачно и может быть повторно использован в других местах.

Итак, предположим, что у вас есть зависимости spring-aop и aspectj от вашего пути к шаблону, следующий аспект выполнит трюк.

@Aspect
@Component
public class IndexEvictorAspect {

    @Autowired
    private Cache cache;

    @Autowired
    private IndexService indexService;

    private final ReentrantLock lock = new ReentrantLock();

    @AfterReturning(pointcut="hello.IndexService.getIndex()", returning="index")
    public void afterGetIndex(Object index) {
        if(indexService.isObsolete((Index) index) && lock.tryLock()){
            try {
                Index newIndex = indexService.calculateIndex();
                cache.put(SimpleKey.EMPTY, newIndex);
            } finally {
                lock.unlock();
            }
        }
    }
}

Несколько замечаний

• Поскольку ваш метод getIndex() не имеет параметров, он хранится в кеше для ключа SimpleKey.EMPTY
• В коде предполагается, что IndexService находится в пакете hello.

Ответ 2

Что-то вроде следующего может обновить кеш по желанию и сохранить реализацию простой и понятной.

Нет ничего плохого в написании четкого и простого кода при условии, что он удовлетворяет требованиям.

@Service
public static class IndexService {
    @Autowired
    private IndexCalculator indexCalculator;

    public Index getIndex() {
        Index cachedIndex = getCachedIndex();

        if (isObsolete(cachedIndex)) {
            evictCache();
            asyncRefreshCache();
        }

        return cachedIndex;
    }

    @Cacheable(cacheNames = "index")
    public Index getCachedIndex() {
        return indexCalculator.calculateIndex();
    }

    public void asyncRefreshCache() {
        CompletableFuture.runAsync(this::getCachedIndex);
    }

    @CacheEvict(cacheNames = "index")
    public void evictCache() { }

    public boolean isObsolete(Index index) {
        long indexTimestamp = index.getTimestamp();
        long currentTimestamp = indexCalculator.getCurrentTimestamp();

        if (index == null || indexTimestamp < currentTimestamp) {
            return true;
        } else {
            return false;
        }
    }
}

Ответ 3

EDIT1:

Абстракция кэширования на основе @Cacheable и @CacheEvict не будет работать в этом случае. Это поведение следующее: во время вызова @Cacheable, если значение находится в кеше, - возвращает значение из кеша, иначе вычислить и поместить в кеш, а затем вернуть; во время @CacheEvict значение удаляется из кеша, поэтому с этого момента в кеше нет значения, и, таким образом, первый входящий вызов на @Cacheable заставит пересчет и поместить в кеш. Использование @CacheEvict(condition="") будет выполнять только проверку состояния, чтобы удалить из значения кеша во время этого вызова на основе этого условия. Поэтому после каждого недействительности метод @Cacheable запускает эту тяжеловесную процедуру для заполнения кеша.

чтобы иметь значение beign, хранящееся в менеджере кэша, и обновлено асинхронно, я бы предложил повторно использовать следующую процедуру:

@Inject
@Qualifier("my-configured-caching")
private Cache cache; 
private ReentrantLock lock = new ReentrantLock();

public Index getIndex() {
    synchronized (this) {
        Index storedCache = cache.get("singleKey_Or_AnythingYouWant", Index.class); 
        if (storedCache == null ) {
             this.lock.lock();
             storedCache = indexCalculator.calculateIndex();
             this.cache.put("singleKey_Or_AnythingYouWant",  storedCache);
             this.lock.unlock();
         }
    }
    if (isObsolete(storedCache)) {
         if (!lock.isLocked()) {
              lock.lock();
              this.asyncUpgrade()
         }
    }
    return storedCache;
}

Первая конструкция синхронизирована, чтобы заблокировать все предстоящие вызовы до тех пор, пока первый вызов не заполнит кеш.

тогда система проверяет, должен ли кеш быть регенерирован. если да, то вызывается один вызов для асинхронного обновления значения, а текущий поток возвращает кешированное значение. входящий вызов, как только кеш находится в состоянии пересчета, просто вернет самое последнее значение из кеша. и так далее.

с таким решением вы сможете повторно использовать огромные объемы памяти, скажем, диспетчер келей hazelcast, а также многократное хранение кеша на основе ключей и сохранить сложную логику реализации и выселения кеша.

ИЛИ Если вам нравятся аннотации @Cacheable, вы можете сделать это следующим образом:

@Cacheable(cacheNames = "index", sync = true)
public Index getCachedIndex() {
    return new Index();
}

@CachePut(cacheNames = "index")
public Index putIntoCache() {
    return new Index();
}

public Index getIndex() {
    Index latestIndex = getCachedIndex();

    if (isObsolete(latestIndex)) {
        recalculateCache();
    }

    return latestIndex;
}

private ReentrantLock lock = new ReentrantLock();

@Async
public void recalculateCache() {
    if (!lock.isLocked()) {
        lock.lock();
        putIntoCache();
        lock.unlock();
    }
}

Это почти то же самое, что и выше, но повторное использование spring абстракции аннотации кэширования.

ORIGINAL: Почему вы пытаетесь решить эту проблему с помощью кеширования? Если это простое значение (не основано на ключах, вы можете упорядочить свой код более простым способом, имея в виду, что служба spring по умолчанию одиночная)

Что-то вроде этого:

@Service
public static class IndexService {
    @Autowired
    private IndexCalculator indexCalculator;

    private Index storedCache; 
    private ReentrantLock lock = new ReentrantLock();

    public Index getIndex() {
        if (storedCache == null ) {
             synchronized (this) {
                 this.lock.lock();
                 Index result = indexCalculator.calculateIndex();
                 this.storedCache = result;
                 this.lock.unlock();
             }
        }
        if (isObsolete()) {
             if (!lock.isLocked()) {
                  lock.lock();
                  this.asyncUpgrade()
             }
        }
        return storedCache;
    }

    @Async
    public void asyncUpgrade() {
        Index result = indexCalculator.calculateIndex();
        synchronized (this) {
             this.storedCache = result;
        }
        this.lock.unlock();
    }

    public boolean isObsolete() {
        long currentTimestamp = indexCalculator.getCurrentTimestamp();
        if (storedCache == null || storedCache.getTimestamp() < currentTimestamp) {
            return true;
        } else {
            return false;
        }
    }
}

то есть. первый вызов синхронизирован, и вам нужно подождать, пока результаты не будут заполнены. Затем, если сохраненное значение устарело, система выполнит асинхронное обновление значения, но текущий поток получит сохраненное "кэшированное" значение.

Я также ввел блокировку реентера, чтобы ограничить единое обновление сохраненного индекса во времени.

Ответ 4

Я использую Guava LoadCache в вашей службе индексирования, как показано в примере кода ниже:

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
 .maximumSize(1000)
 .refreshAfterWrite(1, TimeUnit.MINUTES)
 .build(
     new CacheLoader<Key, Graph>() {
       public Graph load(Key key) { // no checked exception
         return getGraphFromDatabase(key);
       }
       public ListenableFuture<Graph> reload(final Key key, Graph prevGraph) {
         if (neverNeedsRefresh(key)) {
           return Futures.immediateFuture(prevGraph);
         } else {
           // asynchronous!
           ListenableFutureTask<Graph> task = ListenableFutureTask.create(new Callable<Graph>() {
             public Graph call() {
               return getGraphFromDatabase(key);
             }
           });
           executor.execute(task);
           return task;
         }
       }
     });

Ответ 5

Я думаю, что это может быть что-то вроде

@Autowired
IndexService indexService; // self injection

@Cacheable(cacheNames = INDEX_CACHE_NAME)
@CacheEvict(cacheNames = INDEX_CACHE_NAME, condition = "target.isObsolete(#result) && @indexService.calculateIndexAsync()")
public Index getIndex() {
    return calculateIndex();
}

public boolean calculateIndexAsync() {
    someAsyncService.run(new Runable() {
        public void run() {
            indexService.updateIndex(); // require self reference to use Spring caching proxy
        }
    });
    return true;
}

@CachePut(cacheNames = INDEX_CACHE_NAME)
public Index updateIndex() {
    return calculateIndex();
}

У вышеуказанного кода возникает проблема, если вы снова вызываете getIndex() во время его обновления, он будет подсчитан снова. Чтобы этого избежать, лучше не использовать @CacheEvict, а @Cacheable вернуть устаревшее значение до тех пор, пока индекс не выполнит вычисления.

@Autowired
IndexService indexService; // self injection

@Cacheable(cacheNames = INDEX_CACHE_NAME, condition = "!(target.isObsolete(#result) && @indexService.calculateIndexAsync())")
public Index getIndex() {
    return calculateIndex();
}

public boolean calculateIndexAsync() {
    if (!someThreadSafeService.isIndexBeingUpdated()) {
        someAsyncService.run(new Runable() {
            public void run() {
                indexService.updateIndex(); // require self reference to use Spring caching proxy
            }
        });
    }
    return false;
}

@CachePut(cacheNames = INDEX_CACHE_NAME)
public Index updateIndex() {
    return calculateIndex();
}