reactor.cache

Class CacheFlux

java.lang.Object

reactor.cache.CacheFlux

Deprecated.

To be removed in 3.6.0 at the earliest. There is no great solution for generic caches, other than specific implementations with async support and cache stampede protection (like Caffeine). see https://github.com/reactor/reactor-addons/issues/237

@Deprecated
public class CacheFlux
extends Object

Opinionated caching helper that defines how to store and restore a Flux in an arbitrary cache abstraction. A generic writer/reader entry point is provided, but cache vendors that have a Map wrapper support can also be directly used:

Generic cache entry points:

     AtomicReference<Context> storeRef = new AtomicReference<>(Context.empty());

     Flux<Integer> cachedFlux = CacheFlux
                .lookup(k -> Mono.justOrEmpty(storeRef.get().getOrEmpty(k))
                                 .cast(Integer.class)
                                 .flatMap(max -> Flux.range(1, max)
                                                     .materialize()
                                                     .collectList()),
                                key)
                .onCacheMissResume(Flux.range(1, 10))
                .andWriteWith((k, sigs) -> Flux.fromIterable(sigs)
                                               .dematerialize()
                                               .last()
                                               .doOnNext(max -> storeRef.updateAndGet(ctx -> ctx.put(k, max)))
                                               .then());
 

Map endpoints:

    String key = "myCategory";
    LoadingCache<String, Object> graphs = Caffeine
        .newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .refreshAfterWrite(1, TimeUnit.MINUTES)
        .build(key -> createExpensiveGraph(key));

    Flux<Integer> cachedMyCategory = CacheFlux
        .lookup(graphs.asMap(), key, Integer.class)
        .onCacheMissResume(repository.findAllByCategory(key));
 

Author:

Oleh Dokuka, Simon Baslé

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	CacheFlux.FluxCacheBuilderCacheMiss<KEY,VALUE> Deprecated. Setup original source to fallback to in case of cache miss.
static interface	CacheFlux.FluxCacheBuilderCacheWriter<KEY,VALUE> Deprecated. Set up the cache writer BiFunction to use to store the source data into the cache in case of cache miss.
static interface	CacheFlux.FluxCacheBuilderMapMiss<VALUE> Deprecated. Setup original source to fallback to in case of cache miss and return a wrapped Flux that transparently looks up data from a Map representation of a cache and store data into the cache in case of cache miss.

Method Summary

Modifier and Type	Method and Description
static <KEY,VALUE> CacheFlux.FluxCacheBuilderCacheMiss<KEY,VALUE>	lookup(Function<KEY,reactor.core.publisher.Mono<List<reactor.core.publisher.Signal<VALUE>>>> reader, KEY key) Deprecated. Restore a Flux<VALUE> from the cache reader Function given a provided key.
static <KEY,VALUE> CacheFlux.FluxCacheBuilderMapMiss<VALUE>	lookup(Map<KEY,? super List> cacheMap, KEY key, Class<VALUE> valueClass) Deprecated. Restore a Flux<VALUE> from the cache-map given a provided key.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

lookup

public static <KEY,VALUE> CacheFlux.FluxCacheBuilderMapMiss<VALUE> lookup(Map<KEY,? super List> cacheMap,
                                                                          KEY key,
                                                                          Class<VALUE> valueClass)

Deprecated.

Restore a Flux<VALUE> from the cache-map given a provided key. The cache is expected to store original values as a List of Signal of T. If no value is in the cache, it will be calculated from the original source which is set up in the next step. Note that if the source completes empty, this result will be cached and all subsequent requests with the same key will return Flux.empty(). The behaviour is similar for erroring sources, except cache hits would then return Flux.error(Throwable).

Note that the wrapped Flux is lazy, meaning that subscribing twice in a row to the returned Flux on an empty cache will trigger a cache miss then a cache hit.

Type Parameters:

KEY - Key Type

VALUE - Value Type

Parameters:

cacheMap - Map wrapper of a cache

key - mapped key

Returns:

The next builder step to use to set up the source

lookup

public static <KEY,VALUE> CacheFlux.FluxCacheBuilderCacheMiss<KEY,VALUE> lookup(Function<KEY,reactor.core.publisher.Mono<List<reactor.core.publisher.Signal<VALUE>>>> reader,
                                                                                KEY key)

Deprecated.

Restore a Flux<VALUE> from the cache reader Function given a provided key. The cache is expected to store original values as a List of Signal of T. If no value is in the cache, it will be calculated from the original source which is set up in the next step. Note that if the source completes empty, this result will be cached and all subsequent requests with the same key will return Flux.empty(). The behaviour is similar for erroring sources, except cache hits would then return Flux.error(Throwable).

Note that the wrapped Flux is lazy, meaning that subscribing twice in a row to the returned Flux on an empty cache will trigger a cache miss then a cache hit.

Type Parameters:

KEY - Key Type

VALUE - Value Type

Parameters:

reader - a cache reader Function function that looks up collection of Signal from a cache

key - mapped key

Returns:

The next builder step used to set up the source