[Question] Spring Boot Servlet Implementation with @Timelimiter

Resilience4j version: 1.5.0

Java version: 1.8

Hi,

we still use the Servlet part and not yet the Webflux part of Spring Boot, but still want to benefit from the @TimeLimiter annotation. The code of the TimeLimiterAspect enforces to use a CompletionStage as return type in case there is no suitable TimeLimiterAspectExt available. Since we’re using the servlet implementation methods, which are annotated with the @TimeLimiter annotation used to be blocking and therefore simply returned the desired type directly.

Now to archive the same goal we simply return a CompletableFuture<MyType> and the caller of this method calls get() on the returned CompletableFuture<MyType>. Would this be the right approach? Or to you see any undesired side effects when using the @TimeLimiter annotation like this? I am asking this because sometimes we face some delays when calling other rest APIs by using Timelimiter, and I am afraid that the timelimiter threading overhead causes these delays?

Unfortunately it is not really easy to make blocking code non blocking.

Thanks in advance for an answer to all these questions 😉

[RobWin]

After your comment GitHub was down. Is there a correlation? 😛

[SimonScholz]

For others, who might also want to use the blocking part of the timelimiter: I introduced a new annotation similar to the io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker annotation and also made use of most of the parts of the io.github.resilience4j.circuitbreaker.configure.CircuitBreakerAspect and simply added a TimeLimiter and Bulkhead to it like so:

        FallbackMethod fallbackMethod =
                FallbackMethod.create(fallbackMethodValue, method, proceedingJoinPoint.getArgs(), proceedingJoinPoint.getTarget());
        return fallbackDecorators.decorate(fallbackMethod, () -> proceed(proceedingJoinPoint, circuitBreaker, bulkhead, timelimiter)).apply();
    }

    private Object proceed(ProceedingJoinPoint proceedingJoinPoint, CircuitBreaker circuitBreaker, Bulkhead bulkhead, TimeLimiter timeLimiter)
            throws Throwable {
        return circuitBreaker.executeCallable(timeLimiter.decorateFutureSupplier(() -> CompletableFuture.supplyAsync(() -> {
            try {
                return bulkhead.executeCheckedSupplier(proceedingJoinPoint::proceed);
            } catch (Throwable throwable) {
                throw new CompletionException(throwable);
            }
        })));
    }

Hope that helps someone else with similar demands 😉