Cache avalanche

[tmtbe]

When there is no cache and in a high concurrency state, the cache does not converge and the request will penetrate to the backend. The same situation occurs when the cache is invalid.

Example:

 @Cacheable("my-cache")
    open fun test(): Mono<String?> {
        println(1)
        return testClient.hello().doOnTerminate {
            println(2)
        }
    }

When I make concurrent requests, many requests will access the backend, which is a problem in high-concurrency design.

wrk -c100 -d1000 -t8 http://localhost:8080/test

The console will print a lot of 1 and 2.

[graemerocher]

This seems expected since in a reactive context what is cached is the result of the Mono not the mono itself

[tmtbe]

Is it possible to do some special optimizations for Reactor, such as caching Mono.cache() instead of the result of Mono

[tmtbe]

I simply tried:

 private void doProceed(MethodInvocationContext context, ValueWrapper wrapper) {
        Object result = context.proceed();
        if(result instanceof Flux){
            result = ((Flux<?>) result).cache();
        }
        if(result instanceof Mono){
            result = ((Mono<?>) result).cache();
        }

 public Object intercept(MethodInvocationContext<Object, Object> context) {
        if (context.hasStereotype(CacheConfig.class)) {
            ReturnType returnTypeObject = context.getReturnType();
            Class returnType = returnTypeObject.getType();
            if (CompletionStage.class.isAssignableFrom(returnType)) {
                Supplier<CompletionStage<Object>> supplier = () -> (CompletionStage<Object>) context.proceed();
                return interceptAsCompletableFuture(context, supplier, returnTypeObject, returnType);
            } else if(returnType.equals(Flux.class)){
                return interceptSync(context, returnTypeObject, returnType);
            } else if(returnType.equals(Mono.class)){
                return interceptSync(context, returnTypeObject, returnType);

@Cacheable("my-cache",atomic = true)
    open fun test(): Mono<String?> {
        return testClient.hello().doOnTerminate {
            println(2)
        }
    }

By using Mono.cache() and adding some logical judgments through atomic = true, I can achieve the effect I want. This is just a simple experiment, not a very good method, because the error message will be cached, if it is really available, the logic should be more cautious.

[graemerocher]

I think this is up to the end user to do I don't think we can just apply cache automatically. Typically if you do your expensive operations within the reactive flow then the result of these would be cached