RouteDefinitions assertion has performance issues

[mvp31]

Describe the bug
The routing assertion is a List collection that is traversed by each request, and performance is slow in cases where there are many (more than 10,000) routing addresses.
My test environment had 2,000 routedefinitions, and each request traversed the route List collection in 50ms.
It is recommended to provide ConcorrentHashMap to store the RouteDefinition, and use ConcorrentHashMap to match the RouteDefinition.

Sample
RouteDefinitionRouteLoactor.getRoutes(){......}

[spencergibb]

/cc @GitHub-Yann

[spencergibb]

So I think there could be some enhancements but they would come with tradeoffs.

Predicates can match on any part of a request, not just path. Spring Framework has some enhanced matches we could use, but ONLY if all routes had a path portion (or even just path).

You could also have some kind of hierarchical path matching, so a tree of paths was matched.

[spencergibb]

@poutsma or @rstoyanchev may have some ideas about large number of predicates to match requests.

[GitHub-Yann]

Hi All,

Lately , I am thinking is there a hook that reminds my gateway application the routes list is refreshed done ?

My attempt :
(1) route sample:
spring.cloud.gateway.routes[0].id = dummy-route-2021-01-08-0
spring.cloud.gateway.routes[0].uri = lb://DEMO-SK-HELLO-SERVICE
spring.cloud.gateway.routes[0].predicates[0] = Path=/yann00000/api/**
spring.cloud.gateway.routes[0].filters[0] = StripPrefix=1
spring.cloud.gateway.routes[0].order = 0
......
spring.cloud.gateway.routes[200].id = dummy-route-2021-01-08-200
spring.cloud.gateway.routes[200].uri = lb://DUMMY-SERVICE-1
spring.cloud.gateway.routes[200].predicates[0] = Path=/yann00200/api/**
spring.cloud.gateway.routes[200].filters[0] = StripPrefix=1
spring.cloud.gateway.routes[200].order = 200
......
spring.cloud.gateway.routes[990].id = dummy-route-2021-01-08-990
spring.cloud.gateway.routes[990].uri = lb://DUMMY-SERVICE-2
spring.cloud.gateway.routes[990].predicates[0] = Path=/yann00990/api/**
spring.cloud.gateway.routes[990].filters[0] = StripPrefix=1
spring.cloud.gateway.routes[990].order = 990
......
spring.cloud.gateway.routes[1000].id = dummy-route-2021-01-08-1000
spring.cloud.gateway.routes[1000].uri = lb://DUMMY-SERVICE-3
spring.cloud.gateway.routes[1000].predicates[0] = Path=/yann01000/api/**
spring.cloud.gateway.routes[1000].filters[0] = StripPrefix=1
spring.cloud.gateway.routes[1000].order = 1000

(2) my route list data are strored into DB or other config-center ,
(3) when I change the data in DB , some assistant application will find the event , push the change and a MAP to gateway application.
(4) then use "this.publisher.publishEvent(new RefreshRoutesEvent(this));" to publish the event.
(5) when the route list is refreshing, gateway application still math the route one by one, after refresh is done ,
gateway application will use the MAP
this MAP contains such data:
key ---------------- value
yann00000 -------- 0
yann00200 -------- 190
yann00990 -------- 980
yann01000 -------- 990

based on this map , gateway application will know if the path is started with /yann01000 , I will find the route start from 990,

But above is limited , if the predicated does not use path . Also when I performance testing , there is 404 error found (because I don't know when the route refresh is finished).

[poutsma]

I don't know much about the setup involved, but 10.000 (or even 2.000) separate route definitions is way more than I would expect in an application. Is there any way you can nest these route definitions into ones that share a common path (or other request predicate), or make the handler method be more versatile so that it is able to handle more scenarios? That way, there are fewer routes to iterate over, and performance will improve.

At any rate: using a map would not work for general usage, because not all patterns are direct matches (some use wildcards or uri templates), and not all matches are based on path.

However, you can use a map yourself, if you are only interested in direct path matches, and by creating your own router function:

public class MapRouterFunction<T extends ServerResponse> implements RouterFunction<T> {

	private final ConcurrentHashMap<String, HandlerFunction<T>> pathMap = new ConcurrentHashMap<>();

	public void add(String pattern, HandlerFunction<T> handlerFunction) {
		Objects.requireNonNull(pattern);
		Objects.requireNonNull(handlerFunction);
		this.pathMap.put(pattern, handlerFunction);
	}

	@Override
	public Mono<HandlerFunction<T>> route(ServerRequest request) {
		return Mono.fromCallable(() -> {
			String path = request.path();
			return this.pathMap.get(path);
		});
	}

}

(This is the webflux version, the servlet version would be similar)

If you wire this up like your current route, and add handler functions using the add method, it should work.

[spencergibb]

Thanks, @poutsma. Gateway applications can routinely have large numbers of routes. It currently has a custom HandlerMapping that evaluates routes by the predicate in order. I think if a large number routes shared a common (or hierarchical) predicate we could make an optimization like RouteFunctions.nest().