在不同的事件循环上为不同的 webflux 端点提供服务

Question

I have ported a large spring-web codebase to spring-webflux. There two sets of endpoints, some critical endpoints that must be fast, and some others that are not vital if they end up blocking in production. I can validate that none of the critical endpoints block on the eventloop thread, but validating all the other endpoints is not feasible. I would like to run them on a different threadpool or eventloop, so if they block, they do not affect the critical endpoints.

How would I go about this?

I've tried using reflection to find all the handlers that either should or shouldn't be on a secondary eventloop, but can't think of a way to assign them to it. Alternatively, is it possible to run both spring-web and spring-webflux, and have spring-web serve the non-critical endpoints?

I've managed to get the handlers from the handler registry like so:

@Component
class HandlerFinder(val requestMappingHandlerMappings: List<RequestMappingHandlerMapping>) {

    @PostConstruct
    fun start() {
        for (rmhm : RequestMappingHandlerMapping in requestMappingHandlerMappings) {
            val handlerMethods: Map<RequestMappingInfo, HandlerMethod> = rmhm.handlerMethods

            for ((mapping, method) in handlerMethods) {
                for (urlPattern in mapping.patternsCondition.patterns) {
                    log.info("${method.beanType.name}#${method.method.name} <-- ${urlPattern}")
                }
            }
        }
    }

    companion object {
        private val log = LoggerFactory.getLogger(HandlerFinder::class.java)
    }
}

I think the next step would be to somehow change the handlers to be wrapped in something like below, but I'm not sure how to change this in the handler registry:

Mono.fromCallable(() -> { ... handler method goes here ...}).publishOn(Schedulers.elastic());

I know I can unregister the mapping with rmhm.ungreisterMapping(mapping) and then re-register it with something like rmhm.registerMapping(mapping, method.bean, method.method) , but I'll need to create new methods to wrap the existing ones somehow.

Answer 1

my suggestion would be to take your critical endpoints, that you dont want blocking and set subscribeOn

as the documentation states for subscribeOn

Changes the Thread from which the whole chain of operators subscribes

Your choice publishOn will only change the context from where that has been declared, and forward. subscribeOn will set an entire subscription to a dedicated scheduler.

This way you can split up how you want your endpoints should be handled on different schedulers internally in the application.

Answer 2

I solved this by creating a WebFilter and changing subscribeOn as Thomas' answer suggests.

@Component
class SchedulerWebFilter(): WebFilter {
    val executorService = Executors.newFixedThreadPool(32)
    private val pathsWhitelist: Set<String> = ...

    override fun filter(exchange: ServerWebExchange, chain: WebFilterChain): Mono<Void> {
        val path = exchange.request.path.toString()
        return if (!pathsWhitelist.contains(path)) {
            chain.filter(exchange).subscribeOn(Schedulers.fromExecutor(executorService))
        } else {
            chain.filter(exchange)
        }
    }
}